Language compare

greeting = 'Hello World!'
puts greeting

greeting = 'Hello World!'
print(greeting)

puts "Don't worry," + ' be happy'

print("Don't worry," + ' be happy')

first = "Don't worry,"
second = 'be happy'
puts "#{first} #{second}"

first = "Don't worry,"
second = 'be happy'
print('%s %s' % (first, second))

puts 'This is not funny! I am not like him!'.gsub('not ', '')

print('This is not funny! I am not like him!'.replace('not ', ''))

puts 'You should work'.gsub('work', 'rest')

print('You should work'.replace('work', 'rest'))

puts 'I like beer'.split

print('I like beer'.split())

puts ' eh? '.strip

print(' eh? '.strip())

puts 'string' == 'string'
puts 'string' != 'string'

print('string' == 'string')
print('string' != 'string')

p 'apple' =~ /^b/
p 'apple' =~ /^a/

import re

print(re.search('^b', 'apple'))
print(re.search('^a', 'apple'))

i = 9
i += 1
puts i

i = 9
i += 1
print(i)

puts 1 < 2 && 2 < 3
puts 5 == 5
puts 5 != 5

print(1 < 2 < 3)
print(5 == 5)
print(5 != 5)

puts rand(1..2)

import random

print(random.randint(1, 2))

puts 9 / 2
puts 9 / 2.0
puts (9 / 2.0).floor
puts (9 / 2.0).round

import math

print(9 // 2)
print(9 / 2)
print(math.floor(9 / 2))
print(round(9 / 2))  # rounds half to even

puts 'hi'.class
puts 1.class

print(type('hi'))
print(type(1))

puts 10.to_f

print(float(10))

puts 10.to_s

print(str(10))

puts '5'.to_i

print(int('5'))

puts '10'.is_a? String

print(isinstance('10', str))

def check(label, fn, values)
  puts label
  values.each do |value|
    begin
      result = fn.call(value) ? 'true' : 'false'
    rescue NoMethodError => e
      result = "error: #{e}"
    end
    puts format("  %-9p - %s", value, result)
  end
  puts ''
end

values = ['string', '', [1, 2, 3], [], 5, 0, true, false, nil]

check('if value:', -> (v) { v }, values)
check('if value.nil?:', -> (v) { v.nil? }, values)
check('if value.empty?:', -> (v) { v.empty? }, values)

def check(label, fn, values):
    print(label)
    for value in values:
        try:
            result = 'true' if fn(value) else 'false'
        except TypeError as e:
            result = 'error: %s' % e
        print("  %-9r - %s" % (value, result))
    print()

values = ['string', '', [1, 2, 3], [], 5, 0, True, False, None]

check('if value:', lambda v: v, values)
check('if value is None:', lambda v: v is None, values)
check('if len(value):', lambda v: len(v), values)

arr = %w(first second)
puts arr

arr = ['first', 'second']
print(arr)

arr = []
arr.push 'first'
arr.push 'second'
puts arr

arr = []
arr.append('first')
arr.append('second')
print(arr)

puts ['first', 1]

print(['first', 1])

puts [1, 2].include? 1

print(1 in [1, 2])

[1, 2].each do |num|
  puts num
end

for num in [1, 2]:
  print(num)

%w(one two).each_with_index do |num, i|
  puts num
  puts i
end

for i, num in enumerate(['one', 'two']):
  print(num)
  print(i)

arr = %w(one two)
puts arr.first
puts arr.last

arr = ['one', 'two']
print(arr[0])
print(arr[-1])

arr = [1, 5, 10, 20]
puts arr.find(&:even?)

arr = [1, 5, 10, 20]
print(next(i for i in arr if i % 2 == 0))

arr = [1, 5, 10, 20]
puts arr.select(&:even?)

arr = [1, 5, 10, 20]
print([i for i in arr if i % 2 == 0])

arr = [1, 5, 10, 20]
puts arr.map { |num| num * 2 }

arr = [1, 5, 10, 20]
print([num * 2 for num in arr])

puts [1, 2] + [3, 4]

print([1, 2] + [3, 4])

puts [4, 2, 3, 1].sort

print(sorted([4, 2, 3, 1]))

multi = [%w(first second), %w(third forth)]
puts multi[1][1]

multi = [['first', 'second'], ['third', 'forth']]
print(multi[1][1])

puts [1, 2, 3].size 

print(len([1, 2, 3]))

arr = [1, 11, 111]
puts arr.count { |i| i > 10 }

arr = [1, 11, 111]
print(sum(1 for i in arr if i > 10))

puts [1, 2, 3].reduce(:+)

import functools, operator

print(functools.reduce(operator.add, [1, 2, 3]))
print(sum([1, 2, 3]))  # a more Pythonic example

puts ['a', 'b', 'c'].index('c')

print(['a', 'b', 'c'].index('c'))

arr = %w(a b c)
arr.delete('b')
puts arr

arr = ['a', 'b', 'c']
arr.remove('b')
print(arr)

puts %w(a b a).uniq

print(set(['a', 'b', 'a']))

options = { font_size: 10, font_family: 'Arial' }
puts options

options = {'font_size': 10, 'font_family': 'Arial'}
print(options)

options = {}
options[:font_size] = 10
options[:font_family] = 'Arial'
puts options

options = {}
options['font_size'] = 10
options['font_family'] = 'Arial'
print(options)

{ font_size: 10, font_family: 'Arial' }.each do |key, value|
  puts key, value
end

for key, value in {'font_size': 10, 'font_family': 'Arial'}.items():
  print(key, value)

options = { font_size: 10, font_family: 'Arial' }
puts options.include? :font_size

options = {'font_size': 10, 'font_family': 'Arial'}
print('font_size' in options)

options = { font_size: 10, font_family: 'Arial' }
puts options[:font_size]

options = {'font_size': 10, 'font_family': 'Arial'}
print(options['font_size'])

options = { font_size: 10, font_family: 'Arial' }
puts options.size

options = {'font_size': 10, 'font_family': 'Arial'}
print(len(options))

try_it = true
puts 'Garlic gum is not funny' if try_it

try_it = True
if try_it:
    print('Garlic gum is not funny')

COST = 100
COST = 50
puts COST

COST = 100
COST = 50
print(COST)

module Colors
  RED = '#FF0000'
  GREEN = '#00FF00'
end
puts Colors::GREEN

class Colors:
    RED = '#FF0000'
    GREEN = '#00FF00'

print(Colors.GREEN)

Customer = Struct.new(:name, :address) do
  def greeting
    "Hello #{name}!"
  end
end
puts Customer.new('Dave', '123 Main').greeting

import collections

class Customer(collections.namedtuple('Customer', 'name address')):
    def greeting(self):
        return "Hello %s!" % self.name

print(Customer('Dave', '123 Main').greeting())

puts 'Hello' if true

if True:
    print('Hello')

angry = false
puts 'smile!' unless angry

angry = False
if not angry:
    print('smile!')

if true
  puts 'work'
else
  puts 'sleep'
end

if True:
  print('work')
else:
  print('sleep')

puts 'no' if true && false
puts 'yes' if true || false

if True and False:
    print('no')
if True or False:
    print('yes')

foo = 'Hello!'
case foo
when 1..5
  puts "It's between 1 and 5"
when 10, 20
  puts '10 or 20'
when 'And' then puts 'case in one line'
when String
  puts "You passed a string '#{foo}'"
else
  puts "You gave me '#{foo}'"
end

foo = 'Hello!'
if foo in range(1, 6):
    print("It's between 1 and 5")
elif foo in (10, 20):
    print('10 or 20')
elif foo == 'And':
    print('case in one line')
elif isinstance(foo, str):
    print("You passed a string %r" % foo)
else:
    print("You gave me %r" % foo)

score = 76
grade = case
        when score < 60 then 'F'
        when score < 70 then 'D'
        when score < 80 then 'C'
        when score < 90 then 'B'
        else 'A'
        end
puts grade

score = 76
grades = [
    (60, 'F'),
    (70, 'D'),
    (80, 'C'),
    (90, 'B'),
]
print(next((g for x, g in grades if score < x), 'A'))

puts false ? 'no' : 'yes'

print('no' if False else 'yes')

result =
if true
  'a'
else
  'b'
end
puts result

result = 'a' if True else 'b'
print(result)

(1..3).each do |i|
  puts "#{i}. Hi"
end

for i in range(1, 4):
    print('%d. Hi' % i)

(0..4).step(2) do |i|
  puts i
end

for i in range(0, 5, 2):
    print(i)

3.times do
  puts 'Hi'
end

for i in range(3):
  print('Hi')

i = 0
while i < 3
  i += 1
end
puts i

i = 0
while i < 3:
  i += 1
print(i)

i = 0
i += 1 until i == 3
puts i

i = 0
while i != 3:
    i += 1
print(i)

greetings = Array.new(3) do |i|
  "#{i + 1}. Hello!"
end
puts greetings

greetings = ["%d. Hello!" % time for time in range(1, 4)]
print(greetings)

3.times do |time|
  puts "#{time + 1}. Hi"
  break if time == 1
end

for time in range(1, 4):
  print("%d. Hi" % time)
  if time == 2:
    break

3.times do |time|
  next if time == 1
  puts "#{time + 1}. Hi"
end

for time in range(1, 4):
  if time == 2:
      continue
  print("%d. Hi" % time)

arr = [1, 2, 3]
puts arr.min
puts arr.max

arr = [1, 2, 3]
print(min(arr))
print(max(arr))

puts Math.sqrt(9)

import math

print(math.sqrt(9))

begin
  1 / 0
rescue
  puts "Can't divide"
ensure
  puts "But that's ok"
end

1 / 0 rescue puts "Can't divide"

try:
  1 / 0
except:
  print("Can't divide")
finally:
  print("But that's ok")

begin
  1 / 0
rescue => e
  puts e.message
end

try:
  1 / 0
except Exception as e:
  print(e)

def divide(num1, num2)
  num1 / num2
rescue => e
  puts e.message
end
divide(1, 0)

def divide(num1, num2):
  try:
    num1 / num2
  except Exception as e:
    print(e)
divide(1, 0)

begin
  fail 'An error!'
rescue => e
  puts e.message
end

try:
  raise Exception('An error!')
except Exception as e:
  print(e)

file_path = File.join(Dir.getwd, 'code', 'file.txt')
puts File.read(file_path)

import os

with open(os.path.join(os.getcwd(), 'code', 'file.txt')) as f:
    print(f.read())

file_path = File.join(File.dirname(__FILE__), 'output.txt')
File.write(file_path, 'Some glorious content')

import pathlib

with (pathlib.Path(__file__).parent / 'output.txt').open('w') as f:
    f.write('Some glorious content')

puts Dir.getwd

import os

print(os.getcwd())

puts __FILE__

print(__file__)

puts File.dirname(__FILE__)

import pathlib

print(pathlib.Path(__file__).parent)

puts File.expand_path File.join(__FILE__, '..', '..')

import pathlib

print(pathlib.Path(__file__).parents[1])

puts File.expand_path File.join(__FILE__, '..', '..', 'php')

import pathlib

print(pathlib.Path(__file__).parents[1] / 'ruby')

def hey
  puts 'How are you?'
end
hey

def hey():
  print('How are you?')
hey()

def sweets(buy, *brands)
  puts brands if buy
end
sweets true, 'snickers', 'twix', 'bounty'

def sweets(buy, *brands):
  if buy:
      print(brands)
sweets(True, 'snickers', 'twix', 'bounty')

def send(abroad = false)
  puts abroad ? 'Send abroad' : 'Send locally'
end
send
send true

def send(abroad=False):
  print('Send abroad' if abroad else 'Send locally')
send()
send(True)

def multiple(a, b)
  a * b
end
puts multiple(2, 3)

def divide(a, b)
  return 0 if a == 0
  a / b
end
puts divide 0, 10

def default_value
end
p default_value

def multiply(a, b):
    return a * b

def divide(a, b):
    return 0 if a == 0 else a / b

def default_value():
    pass

print(multiply(2, 3))
print(divide(0, 10))
print(default_value())

square = -> (x) { x * x }
puts [2, 3].map(&square)

greeting = -> { puts 'Hello World!' }
greeting.call

square = lambda x: x * x
print(list(map(square, [2, 3])))

greeting = lambda: print('Hello World!')
greeting()

def my_select(arr)
  selected = []
  arr.each do |a|
    selected.push a if yield(a)
  end
  selected
end
puts my_select [1, 5, 10] { |x| x < 6 }


def my_select(arr, &filter)
  selected = []
  arr.each do |a|
    selected.push a if filter.call(a)
  end
  selected
end
puts my_select [1, 5, 10] { |x| x < 6 }

def select(arr):
    yield from arr

def select_filter(arr, filter):
    for a in arr:
        if filter(a):
            yield a

print([x for x in select([1, 5, 10]) if x < 6])
print(list(select_filter([1, 5, 10], lambda x: x < 6)))

class Action
  def self.say(&sentence)
    @name = 'Ann'
    puts sentence.call
  end
end

class Person
  def initialize(name)
    @name = name
  end

  def greet
    Action.say { "My name is #{@name}!" }
  end
end

Person.new('Alex').greet

class Action:
  name = 'Ann'

  @staticmethod
  def say(sentence):
    print(sentence())


class Person:
  def __init__(self, name):
    self.name = name

  def greet(self):
    Action.say(lambda: "My name is %s!" % self.name)


Person('Alex').greet()

class ProccessElements
  def self.element(el_name)
    define_method "#{el_name}_element" do |content|
      "<#{el_name}>#{content}</#{el_name}>"
    end
  end
end

class HtmlELements < ProccessElements
  element :div
  element :span
end

puts HtmlELements.new.div_element('hello')

class ProccessElements:
  def __init__(self):
    def element(el_name):
      def render(content):
        return '<{0}>{1}</{0}>'.format(el_name, content)
      return render

    for el_name in self.elements:
      setattr(self, el_name, element(el_name))


class HtmlELements(ProccessElements):
  elements = ('div', 'span')

print(HtmlELements().div('hello'))

class Greetings
  def hey
    puts 'How are you?'
  end
  alias_method :hi, :hey
end

Greetings.new.hi

class Greetings:
  def hey(self):
    print('How are you?')
  hi = hey

Greetings().hi()

class Animal
  def walk
    puts "I'm walking"
  end
end

Animal.new.walk

class Animal:
  def walk(self):
    print("I'm walking")

Animal().walk()

class Animal
  def initialize(name)
    @name = name
  end

  def walk
    puts "My name is #{@name} and I'm walking"
  end
end

Animal.new('Kelya').walk

class Animal:
  def __init__(self, name):
    self.name = name

  def walk(self):
    print("My name is %s and I'm walking" % self.name)

Animal('Kelya').walk()

class Animal
  def walk
    bark
    guard
    puts "I'm walking"
  end

  def bark
    puts 'Wuf!'
  end

  private

  def guard
    puts 'WUUUF!'
  end
end

Animal.new.walk

class Animal:
  def walk(self):
    self.bark()
    self._guard()
    print("I'm walking")

  def bark(self):
    print('Wuf!')

  # Private by convention
  def _guard(self):
    print('WUUUF!')

Animal().walk()

class Animal
  def self.feed
    puts 'Om nom nom'
  end
end

Animal.feed

class Animal:
  @classmethod
  def feed(cls):
    print('Om nom nom')

Animal.feed()

class Animal
  def eat(food)
    puts 'Om nom nom' if meat? food
  end

  private

  def meat?(food)
    food == 'meat'
  end
end

Animal.new.eat('meat')

class Animal:
  def eat(self, food):
    if self._is_meat(food):
      print('Om nom nom')

  def _is_meat(self, food):
    return food == 'meat'

Animal().eat('meat')

class Animal
  def initialize(name)
    @name = name
    greet
  end

  private

  def greet
    puts "Hello! My name is #{@name}"
  end
end

Animal.new('Kelya')

class Animal:
  def __init__(self, name):
    self.name = name
    self._greet()

  def _greet(self):
    print("Hello! My name is %s" % self.name)

Animal('Kelya')

class Animal
  def take(toy)
    @toy = toy
  end

  def play
    puts "I'm playing with #{@toy}"
  end
end

animal = Animal.new
animal.take('a ball')
animal.play

class Animal:
  def take(self, toy):
    self.toy = toy

  def play(self):
    print("I'm playing with %s" % self.toy)

animal = Animal()
animal.take('a ball')
animal.play()

class Animal
  attr_accessor :name
end

animal = Animal.new
animal.name = 'Kelya'
puts animal.name

class Animal:
  name = None

animal = Animal()
animal.name = 'Kelya'
print(animal.name)

class Animal
  def walk
    puts "I'm walking"
  end
end

class Dog < Animal
  def sing
    puts 'Bark!'
  end
end

Dog.new.walk

class Animal:
  def walk(self):
    print("I'm walking")

class Dog(Animal):
  def sing(self):
    print('Bark!')

Dog().walk()

module Moving
  def walk
    puts "#{self.class.name} is walking"
  end
end

module Interacting
  def talk
    puts "#{self.class.name} is talking"
  end
end

class Human
  include Moving
  include Interacting
end

human = Human.new
human.walk
human.talk

class Moving:
  def walk(self):
    print("%s is walking" % self.__class__.__name__)

class Interacting:
  def talk(self):
    print("%s is talking" % self.__class__.__name__)

class Human(Moving, Interacting):
    pass

human = Human()
human.walk()
human.talk()

class Animal
  def walk
    puts "I'm walking"
  end
end

animal = Animal.new
puts animal.respond_to? :walk

class Animal:
  def walk(self):
    print("I'm walking")

animal = Animal()
print(hasattr(animal, 'walk'))

# it's a comment

# it's a comment

speed = 0
speed ||= 15
puts speed

speed = 0
speed = 15 if speed is None else speed
print(speed)

class Winner
  attr_reader :address

  def initialize
    # @address = Address.new
  end
end

class Address
  attr_reader :zipcode

  def initialize
    @zipcode = 192187
  end
end

zip = Winner.new.address&.zipcode
puts zip ? "Zipcode is #{zip}" : "No prize without zipcode"

# other_file_to_import.rb
# class Import
#   def initialize
#     puts 'I am imported!'
#   end
# end

require_relative 'other_file_to_import'
Import.new

# other_file_to_import.py
# class Import:
#   def __init__(self):
#     print('I am imported!')

import other_file_to_import
other_file_to_import.Import()

one, two = [1, 2]
puts one, two

one, two = 1, 2
print(one, two)

require 'date'
puts Date.today

import datetime
print(datetime.date.today())

puts Time.now

import datetime
print(datetime.datetime.now())

angry = false
puts 'smile!' if !angry

angry = False
if not angry:
  print('smile!')

yeti = nil
footprints = yeti || 'bear'
puts footprints

yeti = None
footprints = yeti or 'bear'
print(footprints)

puts `ruby -v`

import subprocess
subprocess.call(['python3', '--version'])