RubyでProcオブジェクトを使って動的にメソッドを定義する方法を解説

my_proc = Proc.new { puts "Hello from Proc!" }
my_proc.call
# 出力: Hello from Proc!

my_proc = proc { |name| puts "Hello, #{name}!" }
my_proc.call("Ruby")
# 出力: Hello, Ruby!

def execute_with_proc(proc_obj)
  puts "Starting execution..."
  proc_obj.call
  puts "Execution finished."
end

my_proc = Proc.new { puts "This is a dynamic method!" }
execute_with_proc(my_proc)
# 出力:
# Starting execution...
# This is a dynamic method!
# Execution finished.

def greeting(proc_obj)
  puts "Welcome!"
  proc_obj.call("Rubyist")
end

english_proc = proc { |name| puts "Hello, #{name}!" }
japanese_proc = proc { |name| puts "こんにちは、#{name}さん！" }

greeting(english_proc)
# 出力:
# Welcome!
# Hello, Rubyist!

greeting(japanese_proc)
# 出力:
# Welcome!
# こんにちは、Rubyistさん！

addition = Proc.new { |a, b| puts "Sum: #{a + b}" }
addition.call(5, 10)
# 出力: Sum: 15

my_proc = Proc.new { |a, b| puts "First: #{a}, Second: #{b}" }
my_proc.call(3)
# 出力: First: 3, Second: 

greet = Proc.new { |name="Guest"| puts "Hello, #{name}!" }
greet.call
# 出力: Hello, Guest!
greet.call("Rubyist")
# 出力: Hello, Rubyist!

greeting = "Hello"
my_proc = Proc.new { puts "#{greeting}, world!" }
my_proc.call
# 出力: Hello, world!

def create_multiplier(factor)
  Proc.new { |x| x * factor }
end

times_three = create_multiplier(3)
puts times_three.call(10)
# 出力: 30

number = 10
my_proc = Proc.new { number = 20; puts "Inside Proc: #{number}" }
my_proc.call
puts "Outside Proc: #{number}"
# 出力:
# Inside Proc: 20
# Outside Proc: 20

formatter = Proc.new { |text| text.upcase }

def greet(proc_obj)
  puts proc_obj.call("Hello from greet!")
end

def farewell(proc_obj)
  puts proc_obj.call("Goodbye from farewell!")
end

greet(formatter)
# 出力: HELLO FROM GREET!
farewell(formatter)
# 出力: GOODBYE FROM FAREWELL!

formal_formatter = Proc.new { |text| "Dear Sir/Madam, #{text}." }
casual_formatter = Proc.new { |text| "Hey! #{text}!" }

def personalized_message(name, proc_obj)
  puts proc_obj.call("It's nice to meet you, #{name}")
end

# フォーマルなメッセージ
personalized_message("Alice", formal_formatter)
# 出力: Dear Sir/Madam, It's nice to meet you, Alice.

# カジュアルなメッセージ
personalized_message("Bob", casual_formatter)
# 出力: Hey! It's nice to meet you, Bob!

error_checker = Proc.new { |value| raise "Invalid value!" if value.nil? || value == "" }

def process_data(data, checker)
  checker.call(data)
  puts "Processing #{data}"
end

def save_data(data, checker)
  checker.call(data)
  puts "Saving #{data}"
end

# 正常なデータの場合
process_data("Valid data", error_checker)
# 出力: Processing Valid data
save_data("More data", error_checker)
# 出力: Saving More data

# 無効なデータの場合（エラー発生）
process_data("", error_checker)
# 出力: エラー: Invalid value!

def greet
  yield "Rubyist"
end

greet { |name| puts "Hello, #{name}!" }
# 出力: Hello, Rubyist!

greeting = Proc.new { |name| puts "Hello, #{name}!" }
greeting.call("Rubyist")
# 出力: Hello, Rubyist!

def execute_twice(&block)
  2.times { block.call }
end

execute_twice { puts "This will print twice!" }
# 出力:
# This will print twice!
# This will print twice!

# Procの例
my_proc = Proc.new { |a, b| puts "a: #{a}, b: #{b}" }
my_proc.call(1)          # 出力: a: 1, b:
my_proc.call(1, 2, 3)    # 出力: a: 1, b: 2

# Lambdaの例
my_lambda = lambda { |a, b| puts "a: #{a}, b: #{b}" }
my_lambda.call(1, 2)     # 出力: a: 1, b: 2
# my_lambda.call(1)      # エラー: wrong number of arguments (given 1, expected 2)

def test_proc
  my_proc = Proc.new { return "Proc return" }
  my_proc.call
  "End of test_proc"  # この行は実行されない
end

def test_lambda
  my_lambda = lambda { return "Lambda return" }
  my_lambda.call
  "End of test_lambda"  # この行も実行される
end

puts test_proc      # 出力: Proc return
puts test_lambda    # 出力: End of test_lambda

my_lambda = lambda { |name| puts "Hello, #{name}!" }
my_lambda.call("Rubyist")
# 出力: Hello, Rubyist!

# 短縮記法でのLambda定義
my_lambda = ->(name) { puts "Hi, #{name}!" }
my_lambda.call("Developer")
# 出力: Hi, Developer!

validate_name = lambda { |name| raise "Name cannot be empty" if name.strip.empty? }
format_error = Proc.new { |error| puts "Error: #{error.message}" }

def register_user(name, validate, format)
  validate.call(name)
  puts "User #{name} registered!"
rescue => e
  format.call(e)
end

register_user("", validate_name, format_error)
# 出力: Error: Name cannot be empty

class Greeting
  %w[english french japanese].each do |lang|
    define_method("greet_in_#{lang}") do |name|
      greetings = {
        "english" => Proc.new { "Hello, #{name}!" },
        "french" => Proc.new { "Bonjour, #{name}!" },
        "japanese" => Proc.new { "こんにちは、#{name}さん！" }
      }
      puts greetings[lang].call
    end
  end
end

greet = Greeting.new
greet.greet_in_english("Rubyist")
# 出力: Hello, Rubyist!
greet.greet_in_french("Rubyist")
# 出力: Bonjour, Rubyist!
greet.greet_in_japanese("Rubyist")
# 出力: こんにちは、Rubyistさん！

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

  def with_logging(proc_obj)
    puts "Starting process for #{@name}..."
    proc_obj.call
    puts "Finished process for #{@name}."
  end

  def update_profile
    with_logging(Proc.new { puts "#{@name}'s profile updated!" })
  end

  def delete_account
    with_logging(Proc.new { puts "#{@name}'s account deleted!" })
  end
end

user = User.new("Alice")
user.update_profile
# 出力:
# Starting process for Alice...
# Alice's profile updated!
# Finished process for Alice.

user.delete_account
# 出力:
# Starting process for Alice...
# Alice's account deleted!
# Finished process for Alice.

def execute_task(task_name, user_role)
  tasks = {
    "admin" => Proc.new { puts "Performing admin-level task: #{task_name}" },
    "editor" => Proc.new { puts "Performing editor-level task: #{task_name}" },
    "viewer" => Proc.new { puts "Performing viewer-level task: #{task_name}" }
  }
  tasks[user_role].call
end

execute_task("Publish Article", "admin")
# 出力: Performing admin-level task: Publish Article
execute_task("Edit Content", "editor")
# 出力: Performing editor-level task: Edit Content
execute_task("View Dashboard", "viewer")
# 出力: Performing viewer-level task: View Dashboard

# 加算、減算、乗算、除算のProcオブジェクトを作成する
addition = Proc.new { |a, b| a + b }
subtraction = Proc.new { |a, b| a - b }
multiplication = Proc.new { |a, b| a * b }
division = Proc.new { |a, b| b != 0 ? a / b : "Division by zero error" }

# calculateメソッドを定義し、各Procオブジェクトを呼び出して結果を出力する
def calculate(a, b, operation)
  operation.call(a, b)
end

# 演算を実行
puts calculate(10, 5, addition)        # 出力例: 15
puts calculate(10, 5, subtraction)     # 出力例: 5
puts calculate(10, 5, multiplication)  # 出力例: 50
puts calculate(10, 5, division)        # 出力例: 2
puts calculate(10, 0, division)        # 出力例: Division by zero error

# 各時間帯のProcオブジェクトを作成する
morning_greeting = Proc.new { |name| "Good morning, #{name}!" }
afternoon_greeting = Proc.new { |name| "Good afternoon, #{name}!" }
evening_greeting = Proc.new { |name| "Good evening, #{name}!" }

# greet_userメソッドを定義し、時間帯に応じた挨拶を表示する
def greet_user(name, greeting)
  puts greeting.call(name)
end

# 各時間帯の挨拶を実行
greet_user("Alice", morning_greeting)    # 出力例: Good morning, Alice!
greet_user("Bob", afternoon_greeting)    # 出力例: Good afternoon, Bob!
greet_user("Charlie", evening_greeting)  # 出力例: Good evening, Charlie!

# 名前と年齢のバリデーション用Procオブジェクトを作成する
name_validator = Proc.new { |name| name.strip.empty? ? "Name cannot be empty" : nil }
age_validator = Proc.new { |age| age < 0 || age > 150 ? "Invalid age" : nil }

# validate_userメソッドを定義し、エラーチェックを行う
def validate_user(name, age, name_check, age_check)
  name_error = name_check.call(name)
  age_error = age_check.call(age)

  if name_error
    puts name_error
  elsif age_error
    puts age_error
  else
    puts "Data is valid"
  end
end

# バリデーションを実行
validate_user("Alice", 30, name_validator, age_validator)   # 出力例: Data is valid
validate_user("", 25, name_validator, age_validator)        # 出力例: Name cannot be empty
validate_user("Bob", 200, name_validator, age_validator)    # 出力例: Invalid age