ruby-japanize

gem 'ruby-japanize'

5.times { print "We *love* Ruby -- it's outrageous!" }

5.回{ 印字 "みんなRubyが*大好き* -- Rubyはすごいぜ!" }

class Numeric
  def plus(x)
    self.+(x)
  end
end

y = 5.plus 6
# y は 11 になります

組(数値) {
  定義(:足す) {|他の数|
    自分.+(他の数)
  }
}

ある数 = 5.足す 6
# ある数 は 11 になります

search_engines =
  %w[Google Yahoo MSN].map do |engine|
    "http://www." + engine.downcase + ".com"
  end

検索エンジン =
  %w[Google Yahoo MSN].対応させる{|エンジン|
    "http://www." + エンジン.小文字にする + ".com"
  }

class MyArray
  include Enumerable
end

組(:私家版の配列) {
  付加 列挙できる
}

# -*- coding: utf-8 -*-

require 'japanize'

FOO = 'FOO'

class Foo
  BAR = 'BAR'

  class Bar
    BAZ = 'BAZ'
  end
end

日本語の定数 :イ, 'イ'

組(:甲) {                       # 日本語のクラス定義
  日本語の定数 :ロ, 'ロ'

  組(:乙) {
    日本語の定数 :ハ, 'ハ'
  }
}

p FOO
p Foo::BAR
p Foo::Bar::BAZ

class Foo
  p FOO                         # 最上位の定数はどこからでも参照できる
  p BAR                         # 自クラスの定数を参照できる

  def foo
    p FOO                       # 最上位の定数はどこからでも参照できる
    p BAR                       # 自クラスの定数をメソッド(操作)から参照できる
  end

  class Bar
    p FOO                       # 最上位の定数はどこからでも参照できる
    p BAR                       # 外側の定数を内側から参照できる
    p BAZ                       # 自クラスの定数を参照できる

    def bar
      p FOO                     # 最上位の定数はどこからでも参照できる
      p BAR                     # 外側の定数を内側から参照できる
      p BAZ                     # 自クラスの定数をメソッド(操作)から参照できる
    end
  end
end

点検 イ                         # 点検はpの日本語版
点検 甲::ロ
点検 甲::乙::ハ

組(甲) {
  点検 イ                       # 最上位の日本語定数はどこからでも参照できる
  点検 ロ                       # 自クラスの日本語定数は参照できる

  定義(:ある操作) {             # 日本語のメソッド定義
    点検 イ                     # 最上位の日本語定数はどこからでも参照できる
    点検 生成元::ロ             # self(自分)が異なるので日本語定数に生成元(self.classの日本語版)を付ける必要がある
    点検 ロ                     # これは失敗する
  }

  組(乙) {
    点検 イ                     # 最上位の日本語定数はどこからでも参照できる
    点検 ::JA::甲::ロ           # 自クラス以外の日本語定数は最上位(::JA)から参照する、通常の定数のように内側から参照することはできない
    点検 ハ                     # 自クラスの日本語定数は参照できる

    定義(:ある操作) {
      点検 イ                   # 最上位の日本語定数はどこからでも参照できる
      点検 ::JA::甲::ロ         # 自クラス以外の日本語定数は最上位(::JA)から参照する
      点検 生成元::ハ           # self(自分)が異なるので日本語定数に生成元(self.classの日本語版)を付ける必要がある
    }
  }
}

module Foo
  FOO = 'FOO'
end

class Bar
  include Foo

  p FOO                         # includeした先で参照できる

  def bar
    p FOO
  end
end

部(:甲) {                       # 日本語のモジュール定義
  日本語の定数 :イ, 'イ'
  日本語の定数 :ロ, 'ロ'

  日本語の定数を付加できること :イ
}

組(:乙) {
  付加 甲                       # 日本語のinclude宣言

  点検 イ                       # 付加できると宣言したので参照できる

  定義(:丙) {
    点検 生成元::イ
  }

  点検 ロ                       # 付加できると宣言してないので失敗する
}

if (age >= 12) then
  print "adult fee\n"
else
  print "child fee\n"
end

gender = if (foo.gender == "male") then "male" else "female" end

この条件が{ 年齢 >= 12 }.であるなら{
  印字 "大人料金\n"
}.でなければ{
  印字 "子供料金\n"
}.である

性別 = この条件が{ 甲.性別 == "男性" }.であるなら{ "男性" }.でなければ{ "女性" }.である

unless (baby?) then
  feed_meat
else
  feed_milk
end

この条件が{ 赤ちゃんか? }.でなければ{
  肉を食べさせる
}.であるなら{
  ミルクを飲ませる
}.である

case (age)
when 0..2
  "baby"
when 3..6
  "little child"
when 7..12
  "child"
when 13..18
  "youth"
else
  "adult"
end

この値が{
  年齢
}.もし{ 0..2 }.であるなら{
  "赤ちゃん"
}.もし{ 3..6 }.であるなら{
  "幼児"
}.もし{ 7..12 }.であるなら{
  "子供"
}.もし{ 13..18 }.であるなら{
  "若者"
}.でなければ{
  "大人"
}.である

ary = [ 0, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024 ]
i = 0
while (i < ary.length)
  puts ary[i]
  i += 1
  # break, next, redo が使える
end

一覧 = [ 0, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024 ]
添字 = 0
この条件なら{ 添字 < 一覧.長さ }.繰り返す{ #|制御|
  行出力 一覧[添字]
  添字 += 1
  # 制御.終わる, 制御.次へ進む, 制御.やり直す が使える
}

until (f.eof?)
  print f.gets
  # break, next, redo が使える
end

この条件まで{ あるファイル.終端か? }.繰り返す{ #|制御|
  印字 あるファイル.行を取得
  # 制御.終わる, 制御.次へ進む, 制御.やり直す が使える
}

send_request(data)
begin
  res = get_response()
  # break, next, redo が使える
end while (res == 'Continue')

要求を送信(情報)
繰り返す{ #|制御|
  結果 = 応答を取得()
  # 制御.終わる, 制御.次へ進む, 制御.やり直す が使える
}.この条件なら{ 結果 == '継続' }

send_request(data)
begin
  res = get_response()
  # break, next, redo が使える
end until (res == 'OK')

要求を送信(情報)
繰り返す{ #|制御|
  結果 = 応答を取得()
  # 制御.終わる, 制御.次へ進む, 制御.やり直す が使える
}.この条件まで{ 結果 == '完了' }

for i in [ 1, 2, 3 ]
  print i * 2, "\n"
  # break, next, redo が使える
end

[ 1, 2, 3 ].個別に{|数|
  印字 数 * 2, "\n"
}

[ 1, 2, 3 ].個別に.繰り返す{|制御, 数|
  印字 数 * 2, "\n"
  # 制御.終わる, 制御.次へ進む, 制御.やり直す が使える
}

式.個別に{|引数 ...|
  式 ...
}

式.個別に.繰り返す{|制御[, 引数 ...]|
  式 ...
  [制御.終わる [式]]
  [制御.次へ進む]
  [制御.やり直す]
  式 ...
}

raise "you lose"                # 例外 RuntimeError を発生させる

# 以下の二つは SyntaxError を発生させる
raise SyntaxError, "invalid syntax"
raise SyntaxError.new("invalid syntax")

raise                           # 最後の例外の再発生

例外を発生 "損失"               # 例外 実行時の失敗 (RuntimeError) を発生させる

# 以下の二つは 文法誤りのため失敗 (SyntaxError) を発生させる
例外を発生 文法誤りのため失敗, "文法が不正です"
例外を発生 文法誤りのため失敗.新規("文法が不正です")

例外を発生                      # 最後の例外を再発生

begin
  do_something
rescue => e
  recover(e)
  # retry が使える
ensure
  must_to_do
end

領域{|制御|
  制御.本処理{
    何かをする
  }
  制御.例外を補足{|発生した例外|
    復旧する(発生した例外)
    # 制御.やり直す が使える
  }
  制御.後始末{
    必ず実行する
  }
}

class Foo < Super
  def test
    :
  end
    :
end

組(:甲, 原型: 親) {
  定義(:試行) {
    :
  }
    :
}

class Foo
end

p Foo

組(:甲) {
}

点検 甲

obj = Object.new
class << obj
  def test
    :
  end
    :
end

ある物 = 物.新規
ある物.特異組{
  定義(:試行) {
    :
  }
    :
}

obj = Object.new
p obj.singleton_class

ある物 = 物.新規
点検 ある物.特異組

module Foo
  def test
    :
  end
    :
end

部(:甲) {
  定義(:試行) {
    :
  }
    :
}

module Foo
end

p Foo

部(:甲) {
}

点検 甲

def fact(n)
  if (n == 1) then
    1
  else
    n * fact(n - 1)
  end
end

定義(:階乗) {|数|
  もし条件が{ 数 == 1 }.であるなら{
    1
  }.でなければ{
    数 * 階乗(数 - 1)
  }.である
}

def foo
  if (block_given?) then
    yield(1, 2)
  end
end

定義(:甲) {|&塊|
  # yield だけでなく block_given? も使えない
  もし条件が{ 塊.無値か? }.でなければ{
    塊[1, 2]
  }.である
}

def foo
  return 1, 2, 3
end

定義(:甲) {
  領域{|制御|
    制御.戻る 1, 2, 3
  }
}

def foo.test
  print "this is foo\n"
end

甲.特異操作の定義(:試行) {
  印字 "これは甲です\n"
}

def fact(n)
  if (n == 1) then
    1
  else
    n * fact(n - 1)
  end
end

`定義 階乗(数)
  もし条件が{ 数 == 1 }.であるなら{
    1
  }.でなければ{
    数 * 階乗(数 - 1)
  }.である
`

# Ruby 2.7から有効
def foo(...)
  @other.foo(...)
end

# Ruby 2.7だけでなくRuby 2.6でも有効
`定義 甲(...)
   @別の物.甲(...)
`

# 明示的に引数を転送しなければならない
def method_missing(name, *args, **kw_args, &block)
  @other.__send__(name, *args, **kw_args, &block)
end

# 略記法で末尾の引数を転送できる
`定義 不明な操作(名前, [...])
   @別の物.__送信__(名前, [...])
`

count = 0
ARGF.each_line do |line|
  next if line.strip.empty?     # 空行を無視
  break if (line =~ /eof/)      # 終了
  print line
  if (line =~ /dup/) then       # 再実行×3回
    if (count < 3) then
      count += 1
      redo
    end
  end
end

回数 = 0
スクリプトの入力.手続きを渡す(:行毎に) {|制御, 行|
  もし条件が{ 行.空白を削る.空か? }.であるなら{ 制御.次へ進む }.である
  もし条件が{ 行 =~ /終わり/ }.であるなら{ 制御.終わる }.である
  印字 行
  もし条件が{ 行 =~ /繰り返し/ }.であるなら{
    もし条件が{ 回数 < 3 }.であるなら{
      回数 += 1
      制御.やり直す
    }.である
  }.である
}

class Foo
  def initialize(name)
    puts "initialize Foo"
    @name = name
  end
end

class Bar < Foo
  def initialize(name, pass)
    puts "initialize Bar"
    super(name)
    @pass = pass
  end
end

it = Bar.new('myname', '0500')
p it
#=> initialize Bar
#   initialize Foo
#   #<Bar:0x2b68f08 @name="myname", @pass="0500">

組(:甲) {
  定義(:初期化) {|名前|
    行を出力 "甲を初期化"
    @名前 = 名前
  }
}

組(:乙, 原型: 甲) {
  定義(:初期化) {|名前, 符丁|
    行を出力 "乙を初期化"
    super(名前)
    @符丁 = 符丁
  }
}

ある物 = 乙.新規('自分の名前', '0500')
点検 ある物
#=> 乙を初期化
#   甲を初期化
#   #<JA::JA乙:0x2b68f08 @名前="自分の名前", @符丁="0500">