Ruby 言語仕様ガイド

local_var = "ローカル"      # ローカル変数

class Counter
  @@count = 0               # クラス変数（全インスタンス共有）

  def initialize(name)
    @name = name            # インスタンス変数
    @@count += 1
  end

  def self.count = @@count  # クラスメソッド（Ruby 3.0+ の短縮形）
end

$debug = true               # グローバル変数（使用は最小限に）

Counter.new("a")
Counter.new("b")
p Counter.count             # => 2

MAX_RETRIES = 3
PI = 3.14159

# MAX_RETRIES = 5  # warning: already initialized constant MAX_RETRIES

FROZEN_LIST = [1, 2, 3].freeze
# FROZEN_LIST << 4  # FrozenError: can't modify frozen Array

42          # Integer（任意精度）
3.14        # Float
"hello"     # String
:name       # Symbol（不変・内部的にキャッシュ）
true        # TrueClass
false       # FalseClass
nil         # NilClass
[1, 2, 3]   # Array
{ a: 1 }    # Hash

n = 42
p n.class          # => Integer
p n.is_a?(Integer) # => true
p n.is_a?(Numeric) # => true  ← 親クラスも true
p n.instance_of?(Numeric) # => false  ← 厳密一致のみ

p "hi".is_a?(Comparable) # => true  ← モジュールも true

score = 75

result = if score >= 90
  "S"
elsif score >= 70
  "A"
else
  "B"
end
p result   # => "A"

# unless（否定形）
puts "ゲスト" unless score >= 90

# 値による分岐（=== を使用）
val = "hello"
case val
when String  then puts "文字列"
when Integer then puts "整数"
else              puts "その他"
end

# Ruby 3.0+ パターンマッチ
data = { name: "Alice", age: 30 }
case data
in { name: String => name, age: (18..) }
  puts "成人: #{name}"
end

i = 0
while i < 3
  print "#{i} "
  i += 1
end
# => 0 1 2

j = 3
until j == 0
  print "#{j} "
  j -= 1
end
# => 3 2 1

loop do
  puts "one shot"
  break
end

puts "正" if 1 > 0
puts "偽ではない" unless false

def greet(name)
  return "名前が空です" if name.nil? || name.empty?
  "Hello, #{name}!"
end

p greet("")      # => "名前が空です"
p greet("Ruby")  # => "Hello, Ruby!"

def add(a, b)
  a + b          # 最後の式が戻り値
end

def sign(n)
  return "正" if n > 0
  return "負" if n < 0
  "ゼロ"         # ← これが暗黙の return
end

p add(3, 4)   # => 7
p sign(-5)    # => "負"

def greet(name, greeting: "Hello")
  "#{greeting}, #{name}!"
end

def sum(*nums)
  nums.sum
end

def show(**opts)
  opts.each { |k, v| puts "#{k}: #{v}" }
end

p greet("Alice")                  # => "Hello, Alice!"
p greet("Bob", greeting: "Hi")    # => "Hi, Bob!"
p sum(1, 2, 3, 4)                 # => 10
show(lang: "Ruby", ver: "3.3")

class BankAccount
  def initialize(balance)
    @balance = balance
  end

  def >(other)
    balance > other.balance   # protected メソッドを呼べる
  end

  protected

  def balance = @balance

  private

  def secret_pin = "1234"
end

a = BankAccount.new(100)
b = BankAccount.new(200)
p a > b             # => false
# a.balance         # NoMethodError
# a.secret_pin      # NoMethodError

s = "hello"
p s.upcase   # => "HELLO"（元は変わらない）
p s          # => "hello"
s.upcase!    # 破壊的
p s          # => "HELLO"

p [1, nil, 2, nil].compact          # => [1, 2]（コピー）
p "".empty?   # => true
p nil.nil?    # => true
p 5.between?(1, 10)  # => true

name = "Ruby"
p "Hello, #{name}!"   # => "Hello, Ruby!"  ← 補間あり
p 'Hello, #{name}!'   # => "Hello, #{name}!"  ← 補間なし

p "改行:
次の行"
p '改行:
次の行'       # 
 はそのまま文字列

x = 7
p "7 の 2 乗は #{x ** 2}"    # => "7 の 2 乗は 49"
p "現在時刻: #{Time.now}"
p "配列: #{[1,2,3].join(", ")}"

sql = <<~SQL
  SELECT *
  FROM users
  WHERE age > #{18}
SQL
puts sql

s = "  Hello, Ruby!  "
p s.strip          # => "Hello, Ruby!"
p s.upcase         # => "  HELLO, RUBY!  "
p s.gsub("Ruby", "World")  # => "  Hello, World!  "
p s.split(", ")    # => ["  Hello", "Ruby!  "]
p "%.2f" % 3.14159 # => "3.14"
p "Name: %s, Age: %d" % ["Alice", 30]

nums   = [1, 2, 3]
words  = %w[apple banana cherry]   # => ["apple", "banana", "cherry"]
syms   = %i[red green blue]        # => [:red, :green, :blue]

p words[0]     # => "apple"
p nums[-1]     # => 3（後ろから）
p nums[1, 2]   # => [2, 3]（start, length）
p nums[0..1]   # => [1, 2]（範囲）

nums = [1, 2, 3, 4, 5]

p nums.map    { |n| n * 2 }        # => [2, 4, 6, 8, 10]
p nums.select { |n| n.odd? }       # => [1, 3, 5]
p nums.reject { |n| n.odd? }       # => [2, 4]
p nums.reduce(:+)                  # => 15
p [[1, [2]], [3]].flatten          # => [1, 2, 3]
p [1, 2].zip([3, 4])               # => [[1, 3], [2, 4]]

user = { name: "Alice", age: 30, role: :admin }

p user[:name]              # => "Alice"
p user.fetch(:age)         # => 30
p user.fetch(:missing, 0)  # => 0（デフォルト値）

# ネストしたハッシュには dig
config = { db: { host: "localhost", port: 5432 } }
p config.dig(:db, :host)   # => "localhost"
p config.dig(:db, :pass)   # => nil（KeyErrorではない）

a = { x: 1, y: 2 }
b = { y: 99, z: 3 }

p a.merge(b)                           # => {x:1, y:99, z:3}
p a.select { |k, v| v > 1 }           # => {y:2}
p a.transform_values { |v| v * 10 }   # => {x:10, y:20}
p a.transform_keys { |k| k.to_s }     # => {"x"=>1, "y"=>2}

begin
  result = 10 / Integer(gets.chomp)
rescue ZeroDivisionError => e
  puts "ゼロ除算: #{e.message}"
rescue ArgumentError => e
  puts "不正な入力: #{e.message}"
else
  puts "結果: #{result}"
ensure
  puts "処理終了（必ず実行）"
end

attempts = 0
begin
  attempts += 1
  raise "一時的なエラー" if attempts < 3
  puts "成功（#{attempts} 回目）"
rescue RuntimeError => e
  puts "リトライ #{attempts}: #{e.message}"
  retry if attempts < 3
end

class InsufficientFundsError < StandardError
  def initialize(amount, balance)
    super("残高不足: 引き出し額 #{amount}、残高 #{balance}")
    @amount  = amount
    @balance = balance
  end

  attr_reader :amount, :balance
end

begin
  raise InsufficientFundsError.new(500, 200)
rescue InsufficientFundsError => e
  puts e.message
  puts "不足額: #{e.amount - e.balance}"
end

def parse_int(str)
  Integer(str)
rescue ArgumentError
  nil
end

p parse_int("42")    # => 42
p parse_int("abc")   # => nil

class Person
  attr_accessor :name, :age
  attr_reader   :id

  @@next_id = 1

  def initialize(name, age)
    @name = name
    @age  = age
    @id   = @@next_id
    @@next_id += 1
  end

  def to_s = "#{@name}(#{@age})"
end

alice = Person.new("Alice", 30)
alice.age = 31
p alice.to_s   # => "Alice(31)"
p alice.id     # => 1

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

  def speak = "#{@name} が鳴く"
end

class Dog < Animal
  def speak = "#{super}: ワン！"  # super で親を呼ぶ
end

d = Dog.new("ポチ")
p d.speak          # => "ポチ が鳴く: ワン！"
p d.is_a?(Animal)  # => true

module Greetable
  def greet = "Hello, I'm #{name}"
end

module Farewell
  def bye = "Goodbye from #{name}"
end

class User
  include Greetable
  include Farewell
  attr_reader :name

  def initialize(name)
    @name = name
  end
end

u = User.new("Bob")
p u.greet   # => "Hello, I'm Bob"
p u.bye     # => "Goodbye from Bob"

module ClassLogger
  def log(msg) = puts("[LOG] #{self}: #{msg}")
end

class Service
  extend ClassLogger
end

Service.log("起動")   # クラスメソッドとして使える

# 個別オブジェクトへの extend
obj = Object.new
obj.extend(ClassLogger)
obj.log("hello")

[10, 20, 30].each   { |n| print "#{n} " }   # => 10 20 30
[10, 20, 30].map    { |n| n / 10 }          # => [1, 2, 3]
[1..5].first(5).select { |n| n.even? }      # => [2, 4]

3.times { |i| print "#{i} " }    # => 0 1 2
1.upto(5) { |i| print "#{i} " }  # => 1 2 3 4 5
(1..10).step(3) { |i| print "#{i} " }  # => 1 4 7 10

# 1 行ブロックは {} が慣習
[1, 2, 3].map { |n| n ** 2 }

# 複数行は do...end が慣習
[1, 2, 3].each do |n|
  squared = n ** 2
  puts "#{n}^2 = #{squared}"
end

# 優先順位の違い（注意）
p [1,2].map { |n| n * 2 }  # p([1,2].map{...}) と解釈
# p [1,2].map do |n| n * 2 end  # (p [1,2]).map do...end と解釈されることがある

def repeat(n)
  n.times { yield }
end

repeat(3) { print "Ruby! " }
# => Ruby! Ruby! Ruby!

def measure(&block)
  start = Time.now
  block.call
  puts "経過: #{Time.now - start}s"
end

measure { sleep(0.01) }

square   = ->(n) { n ** 2 }         # lambda（短縮形）
cube     = lambda { |n| n ** 3 }    # lambda（明示形）
greeting = Proc.new { |n| "Hi #{n}" }

p square.call(4)   # => 16
p cube.(3)         # => 27  （.() は .call() の糖衣）
p greeting.("Bob") # => "Hi Bob"

p square.lambda?   # => true
p greeting.lambda? # => false

a = "hello"
b = "hello"
c = a

p a == b       # => true   値が等しい
p a.equal?(b)  # => false  別オブジェクト
p a.equal?(c)  # => true   同じオブジェクト

p 1 == 1.0     # => true   数値として等しい
p 1.eql?(1.0)  # => false  型が違う

p 1 <=> 2    # => -1
p 2 <=> 2    # => 0
p 3 <=> 2    # => 1

words = %w[banana apple cherry]
p words.sort                          # => ["apple", "banana", "cherry"]
p words.sort_by { |w| w.length }      # => ["apple", "banana", "cherry"]

people = [{ name: "Bob", age: 30 }, { name: "Alice", age: 25 }]
p people.sort_by { |p| p[:age] }.map { |p| p[:name] }

class Temperature
  include Comparable
  attr_reader :degrees

  def initialize(d) = (@degrees = d)
  def <=>(other) = degrees <=> other.degrees
end

temps = [30, 20, 25].map { |d| Temperature.new(d) }
sorted = temps.sort.map(&:degrees)
p sorted                             # => [20, 25, 30]

t = Temperature.new(22)
p t.between?(Temperature.new(20), Temperature.new(25))  # => true

# Range#=== は include? と同義
p (1..10) === 5       # => true

# Regexp#=== は =~ と同義
p /\d+/ === "abc123"  # => true

# Proc#=== は call と同義
even = ->(n) { n.even? }
p even === 4           # => true

# case/when で活用
def classify(x)
  case x
  when String   then "文字列"
  when (1..9)   then "1〜9"
  when Integer  then "その他整数"
  end
end

p classify("hi")  # => "文字列"
p classify(5)     # => "1〜9"

class NumberSet
  include Enumerable

  def initialize(*nums) = (@data = nums)

  def each(&block) = @data.each(&block)
end

ns = NumberSet.new(3, 1, 4, 1, 5, 9)
p ns.sort          # => [1, 1, 3, 4, 5, 9]
p ns.min           # => 1
p ns.max           # => 9
p ns.select(&:odd?) # => [3, 1, 1, 5, 9]

# each_with_object: 累積オブジェクト
result = [1, 2, 3].each_with_object({}) do |n, h|
  h[n] = n ** 2
end
p result    # => {1=>1, 2=>4, 3=>9}

# each_with_index: インデックス付き
%w[a b c].each_with_index { |v, i| puts "#{i}: #{v}" }

# each_slice: n 個ずつ
(1..6).each_slice(2) { |s| p s }    # [1,2] [3,4] [5,6]

# each_cons: スライドウィンドウ
(1..5).each_cons(3) { |c| p c }     # [1,2,3] [2,3,4] [3,4,5]

words = %w[one two three four five six]
p words.group_by { |w| w.length }
# => {3=>["one","two","six"], 4=>["four","five"], 5=>["three"]}

p [1, 1, 2, 2, 1, 3].chunk { |n| n }.map { |k, v| [k, v.size] }
# => [[1,2],[2,2],[1,1],[3,1]]

p %w[a b a a c b].tally
# => {"a"=>3, "b"=>2, "c"=>1}

# 無限の自然数から偶数の先頭 5 つ
result = (1..Float::INFINITY)
           .lazy
           .select { |n| n.even? }
           .map    { |n| n ** 2 }
           .first(5)

p result   # => [4, 16, 36, 64, 100]

lam = lambda { |x, y| x + y }
prc = Proc.new { |x, y| [x, y].inspect }

p lam.call(1, 2)     # => 3
# lam.call(1)        # ArgumentError

p prc.call(1, 2)     # => "[1, 2]"
p prc.call(1)        # => "[1, nil]"  ← 不足は nil 扱い
p prc.call(1, 2, 3)  # => "[1, 2]"   ← 余剰は無視

# Proc をブロックとして渡す
double = ->(n) { n * 2 }
p [1, 2, 3].map(&double)        # => [2, 4, 6]

# Symbol#to_proc を利用（&:メソッド名）
p ["hello", "world"].map(&:upcase)  # => ["HELLO", "WORLD"]
p [1, 2, 3].select(&:odd?)          # => [1, 3]

# method() でメソッド参照
p [1, -2, 3].map(&method(:puts))

add = ->(a, b) { a + b }
add5 = add.curry.(5)   # 第1引数に 5 を固定

p add5.(3)    # => 8
p add5.(10)   # => 15

multiply = ->(a, b, c) { a * b * c }.curry
double_then = multiply.(2).(3)   # a=2, b=3 で固定
p double_then.(4)   # => 24

def make_counter(start = 0)
  count = start
  inc   = -> { count += 1; count }
  dec   = -> { count -= 1; count }
  get   = -> { count }
  [inc, dec, get]
end

inc, dec, get = make_counter(10)
inc.()
inc.()
dec.()
p get.()   # => 11  （外の count を共有している）

# 書き込み
File.write("hello.txt", "Hello, Ruby!\n")

# 読み取り（全体）
content = File.read("hello.txt")
puts content   # => Hello, Ruby!

# 行ごとに読み取り（自動クローズ）
File.open("hello.txt") do |f|
  f.each_line { |line| puts line.chomp }
end

# 追記
File.open("hello.txt", "a") { |f| f.puts "2行目" }

# 標準出力への書き込み
$stdout.puts "標準出力"
$stderr.puts "エラー出力"

# StringIO でキャプチャ（テスト等）
require 'stringio'
buf = StringIO.new
$stdout = buf
puts "captured"
$stdout = STDOUT
p buf.string   # => "captured\n"

require 'csv'
require 'json'

# JSON
data = { name: "Alice", scores: [90, 85] }
json_str = JSON.generate(data)
p JSON.parse(json_str, symbolize_names: true)
# => {name:"Alice", scores:[90,85]}

# CSV（文字列から）
csv_str = "name,age\nAlice,30\nBob,25"
CSV.parse(csv_str, headers: true) do |row|
  puts "#{row['name']}: #{row['age']}"
end

require 'pathname'

# Dir.glob でファイル列挙
Dir.glob("**/*.rb").first(3).each { |f| puts f }

# Pathname で OOP 的なパス操作
base = Pathname.new("/tmp/myapp")
config = base / "config" / "app.yml"
p config.to_s          # => "/tmp/myapp/config/app.yml"
p config.dirname       # => #<Pathname:/tmp/myapp/config>
p config.extname       # => ".yml"
p config.exist?        # => false（ファイルがなければ）

p /hello/i === "Hello World"   # => true

# Regexp.new（動的パターン）
word = "ruby"
re = Regexp.new(word, Regexp::IGNORECASE)
p re === "I love Ruby"   # => true

# x オプションで可読性向上
tel = /
  \A        # 先頭
  (\d{2,4}) # 市外局番
  -
  (\d{2,4}) # 市内局番
  -
  (\d{4})   # 番号
  \z        # 末尾
/x
p tel.match?("03-1234-5678")   # => true

str = "Ruby 3.3 released in 2024"

p str =~ /\d+/          # => 5（最初のマッチ位置）
p str.match(/\d+/)[0]   # => "3"

p str.scan(/\d+/)        # => ["3", "3", "2024"]

# gsub でブロック置換
p str.gsub(/\d+/) { |m| "(#{m})" }
# => "Ruby (3).(3) released in (2024)"

if "2024-05-13" =~ /(\d{4})-(\d{2})-(\d{2})/
  puts "年: #{$1}, 月: #{$2}, 日: #{$3}"
end

m = "John Doe".match(/(\w+)\s(\w+)/)
p m[0]   # => "John Doe"
p m[1]   # => "John"
p m[2]   # => "Doe"

pattern = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/
m = "2024-05-13".match(pattern)

p m[:year]   # => "2024"
p m[:month]  # => "05"
p m[:day]    # => "13"
p m.named_captures
# => {"year"=>"2024", "month"=>"05", "day"=>"13"}

# Gemfile
source "https://rubygems.org"

ruby "3.3.0"

gem "rails",   "~> 7.1"
gem "pg",      "~> 1.5"
gem "puma",    "~> 6.0"

group :development, :test do
  gem "rspec-rails"
  gem "factory_bot_rails"
end

# Rakefile
require 'rake'

desc "データベースをリセットする"
task :db_reset do
  puts "DB をリセット中..."
end

namespace :assets do
  desc "アセットをビルドする"
  task :build do
    puts "アセットをビルド中..."
  end
end

# $ rake db_reset
# $ rake assets:build

require 'net/http'
require 'uri'
require 'json'

uri = URI("https://api.github.com/users/ruby")
response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
  req = Net::HTTP::Get.new(uri)
  req["Accept"] = "application/json"
  http.request(req)
end

p response.code   # => "200"
user = JSON.parse(response.body)
p user["public_repos"]

require 'benchmark'
require 'optparse'

# Benchmark
Benchmark.bm(10) do |x|
  x.report("Array#sum:") { (1..100_000).to_a.sum }
  x.report("inject:   ") { (1..100_000).inject(:+) }
end

# OptionParser
options = {}
OptionParser.new do |opts|
  opts.on("-n NAME", "名前") { |v| options[:name] = v }
  opts.on("-v", "--verbose")  { options[:verbose] = true }
end.parse!(ARGV)
pp options

class DynamicProxy
  def initialize(target) = (@target = target)

  def method_missing(name, *args, &block)
    if @target.respond_to?(name)
      puts "[呼び出し] #{name}(#{args.join(', ')})"
      @target.send(name, *args, &block)
    else
      super
    end
  end

  def respond_to_missing?(name, include_private = false)
    @target.respond_to?(name) || super
  end
end

proxy = DynamicProxy.new([1, 2, 3])
p proxy.length    # [呼び出し] length => 3
p proxy.respond_to?(:length)   # => true

class Report
  %w[pdf csv html].each do |fmt|
    define_method("export_#{fmt}") do
      "Exporting as #{fmt.upcase}"
    end
  end
end

r = Report.new
p r.export_pdf   # => "Exporting as PDF"
p r.export_csv   # => "Exporting as CSV"

# class_eval で既存クラスに後付け
String.class_eval do
  def palindrome? = self == self.reverse
end

p "racecar".palindrome?   # => true

"hello".send(:upcase)          # => "HELLO"
"hello".public_send(:upcase)   # => "HELLO"

# tap: 値を変えずに副作用（デバッグ等）
result = [1, 2, 3]
  .tap { |a| p "before: #{a}" }
  .map { |n| n * 2 }
  .tap { |a| p "after: #{a}" }

# then（yield_self）: パイプライン変換
"  42  "
  .then { |s| s.strip }
  .then { |s| Integer(s) }
  .then { |n| n * 2 }
  .tap  { |n| p n }   # => 84

str = "hello".freeze
p str.frozen?       # => true

# str << " world"   # FrozenError

copy_dup   = str.dup
copy_clone = str.clone

p copy_dup.frozen?    # => false（freeze 解除）
p copy_clone.frozen?  # => true（freeze 保持）

copy_dup << " world"
p copy_dup   # => "hello world"

def print_length(obj)
  if obj.respond_to?(:length)
    puts "長さ: #{obj.length}"
  else
    puts "length をサポートしていません"
  end
end

print_length("hello")    # => 長さ: 5
print_length([1, 2, 3])  # => 長さ: 3
print_length({ a: 1 })   # => 長さ: 1
print_length(42)          # => length をサポートしていません

# person.rbs（型定義ファイル）
# class Person
#   attr_reader name: String
#   attr_reader age: Integer
#   def initialize: (name: String, age: Integer) -> void
#   def greet: () -> String
# end

# person.rb（実装）
class Person
  attr_reader :name, :age

  def initialize(name:, age:)
    @name = name
    @age  = age
  end

  def greet = "Hello, I'm #{name}!"
end

# $ steep check  で型エラーを検出

# frozen_string_literal: true

s = "hello"
p s.frozen?   # => true

# s << " world"  # FrozenError

# ミュータブルな文字列が必要なら String.new か +""
mutable = +"hello"
mutable << " world"
p mutable   # => "hello world"

# GC の統計情報
p GC.stat.slice(:count, :major_gc_count, :minor_gc_count)

# 手動 GC（通常は不要）
GC.start

# ObjectSpace で生きているオブジェクト数を確認
require 'objspace'
p ObjectSpace.count_objects.slice(:T_STRING, :T_ARRAY, :T_HASH)

# GC.compact（Ruby 3.0+）でヒープをコンパクション
GC.compact