Ruby

expect(item_type_pool.types.select { |t| t.category == :canon }.length).to be > 10
expect(item_type_pool.types.count { |t| t.category == :canon }).to be > 10

true.class.ancestors

true.public_methods

true.public_methods(false)
=# => [:===, :^, :inspect, :to_s, :&, :|]

case item
when MyClass
...
when Array
...
when String
...

if MyClass === item
...
elsif Array === item
...
elsif String === item
...

if item.is_a?(MyClass)
...
elsif item.is_a?(Array)
...
elsif item.is_a?(String)
...

def self.instance
  @instance ||= new
end

private_class_method :new

let(:instance) { GlobalClass.send(:new) }

let(:instance) { Class.new(GlobalClass).instance }

1.to_s # => "1"

h = { a: 1, b: 2 }
h.map { |k, v| [k, v.to_s] }.to_h

h = { a: 1, b: 2 }
h.transform_values(&:to_s)

"foobar".scan(/../)

"1 2 3".scan(/\d+/)

"1, 2, 3".scan(/\d+/)

require 'objspace'
puts "#{ObjectSpace.memsize_of_all / (1000.0 * 1000.0)} MB"

require 'rspec'
include RSpec::Matchers

include ActionView::Helpers::OutputSafetyHelper

class A < B
end

class B
end

class Abstruct
  def print_child_constant
    self.class::NAME
  end
end

class A < Abstruct
  NAME = 'AA'
end

class B < Abstruct
  NAME = 'BB'
end

p A.new.print_child_constant # AA

['a', 'b'] + ['a', 'b']

['a', 'b'] | ['a', 'b']

(['a', 'b'] + ['a', 'b']).uniq

user = Struct.new(:name, :age)
user.new('taro', 15)

module Gemat
  class Cli < Thor
    class_options input: :string, output: :string, columns: :array, all: :boolean
    # メソッド共通のオプション

    desc 'csv', 'csv command description'
    def csv
    end

    desc md, 'md command description'
    def md
    end

    no_tasks do
      def command(options, method_name)
      end
    end
  end
end

$ gemat csv

options[:columns].map do |column|
  od = OutDsl.new(column)
  od.idx = index
  od # ここ
end

curl -u {user名} https://rubygems.org/api/v1/api_key.yaml > ~/.gem/credentials; chmod 0600 ~/.gem/credentials

rake release

object.present? ? object : nil
object.presense

p ( 1 .. 5 )
.tap{|obj| puts obj.class}
.to_a.tap{|obj| puts obj.class}

[5, -8, 3, 9].min_by{|num| num.abs }

%w{ a b c }.map(&:capitalize)

require 'stringio'
string = <<EOM
  aaa
  "aaa"
EOM

file1 = StringIO.new(string)
file.read # => aaa\n"aaa"
file2 = StringIO.new('')
file.read # => ""

msg = "aaa"
3.times do
  prefix = "I"
  puts "#{prefix} #{msg}"
end

msg = "aaa"
3.times do
  prefix = "I"
  puts "#{prefix} #{msg}"
end
prefix

chalkboard_gag = lambda do |msg|
  lambda do
    prefix = "I will not"
    "#{prefix} #{msg}"
  end
end
chalkboard_gag
inner_lambda = chalkboard_gag.call("drive the car")
inner_lambda.call

counter = lambda do
  x = 0
  get_x = lambda { p x } # x is free variable
  incr = lambda { p x += 1 }
  decr = lambda { p x -= 1 }

  {get_x: get_x, incr: incr, decr: decr}
end
c1 = counter.call
c1[:incr].call
c1[:incr].call
c1[:incr].call
c1[:get_x].call
c1[:decr].call
c1[:decr].call

c2 = counter.call
c2[:get_x].call

class Generator
  attr_reader :report

  def initialize(report)
    @report = report
  end

  def run
    report.to_csv
  end

Notifier.new(Generator.new(good_report),
             on_success: lambda { |r| puts "Send #{r} to boss" },
             on_failure: lambda { puts "Send to ben" }
            ).tap do |n|
  n.run
end

is_even = lambda { |x| x % 2 == 0 }
is_even.call(3)

is_even = lambda { |x| x % 2 == 0 }
def complement(predicate, value)
  not predicate.call(value)
end
complement(is_even, 3)

is_even = lambda { |x| x % 2 == 0 }
def complement(predicate)
  lambda do |value|
    not predicate.call(value)
  end
end
complement(is_even).call(4)
complement(is_even).call(5)

class Generator
  attr_reader :report

  def initialize(report)
    @report = report
  end

  def run
    report.to_csv
  end
end

class Notifier
  attr_reader :generator, :callbacks

  def initialize(generator, callbacks)
    @generator = generator
    @callbacks = callbacks
  end

  def run
    result = generator.run
    if result
      callbacks.fetch(:on_success).call(result)
    else
      callbacks.fetch(:on_failure).call
    end
  end
end

good_report = OpenStruct.new(to_csv: "59.99, Great Success")

Notifier.new(Generator.new(good_report),
             on_success: lambda { |r| puts "Send #{r} to boss" },
             on_failure: lambda { puts "Send email to ben" }
            ).tap do |n|
  n.run #=> send 59.99, great succes to boss
end

good_report = OpenStruct.new(to_csv: nil)

Notifier.new(Generator.new(good_report),
             on_success: lambda { |r| puts "Send #{r} to boss" },
             on_failure: lambda { puts "Send email to ben" }
            ).tap do |n|
  n.run #=> ben
end

[1, 2, 3, 4, 5].reduce(10) { |acc, x| p "#{acc}, #{x}"; acc + x }

adder = lambda do |acc, arr|
  if arr.empty?
    acc
  else
    adder.call(acc + arr.first, arr.drop(1))
  end
end
adder.call(10, [1, 2, 3, 4, 5])

multiplier = lambda do |acc, arr|
  if arr.empty?
    acc
  else
    multiplier.call(acc * arr.first, arr.drop(1))
  end
end
multiplier.call(10, [1, 2, 3, 4, 5])

reducer = lambda do |acc, arr, binary_function|
  if arr.empty?
    acc
  else
    reducer.call(binary_function.call(acc, arr.first), arr.drop(1), binary_function)
  end
end
reducer.call(1, [1, 2, 3, 4, 5], lambda { |x, y| x + y })

reducer = lambda do |acc, arr, binary_function|
  reducer_aux = lambda do |acc, arr|
    if arr.empty?
      acc
    else
      reducer_aux.call(binary_function.call(acc, arr.first), arr.drop(1))
    end
  end

  reducer_aux.call(acc, arr)
end

reducer.call(1, [1, 2, 3, 4, 5], lambda { |x, y| x + y })

def is_larger_than(amount)
  lambda do |a|
    a > amount # amount is free variable
  end
end

larger_than_5 = is_larger_than(5)
larger_than_5.call(7)
larger_than_5.call(3)

new_db = lambda do
  db = {}
  insert = lambda do |key, value|
    p db.store(key, value)
  end
  dump = lambda { p db }
  delete = lambda do |key|
    p db.delete(key)
  end
  {insert: insert, dump: dump, delete: delete}
end
db = new_db.call
db[:insert].call("this is key", "this is value")
db[:dump].call
db[:delete].call("this is key")
db[:dump].call

complement = lambda do |function|
  lambda do |arg|
    not function.call(arg)
  end
end

is_even = lambda { |x| x % 2 == 0 }
complement.call(is_even).call(5)

[1, 2, 3, 4, 5].reduce(Array.new()) { |result, item| result << item * 2 }

def do_it
  yield
end
do_it {"I'm doing it."}

def do_it
  yield
end
do_it { [1, 2, 3] << 4}

def do_it(x, y)
  yield(x, y)
end
do_it(2, 3) { |x, y| x + y }
do_it("Ohai", "Dictator") do |greeting, title|
    "#{greeting}, #{title}!!!"
end

def do_it(x)
  yield x
end
do_it(42) { |num, line| "#{num}: #{line}" }

x = "outside x"
1.times { x = "modified from the outside block" }
x

x = "outside x"
1.times { |;x| x = "modified from the outside block" }
x

3.times { puts "D'oh!" }

class Fixnum
  def times
    puts "This does nothing yet!"
  end
end
3.times { puts "D'oh!" }

class Array
  def each
  end
end
%w(look ma no for loops).each do |x|
  puts x
end

class Array
  def each
    x = 0
    while x < self.length
      yield self[x]
      x += 1
    end
  end
end

%w(look me no for loops).each do |x|
  puts x
end

# look
# me
# no
# for
# loops

File.open() do |f|
  f << "aaa"
end

class File
  def self.open(name, mode)
    file = new(name, mode)
    return file unless block_given?
    yield(file)
  ensure
    file.close
  end
end

module Twitter
  module REST
    class Client
      attr_accessor :consumer_key, :consumer_secret,
                    :access_token, :access_token_secret
      def initialize
        yield self if block_given?
      end
    end
  end
end

client = Twitter::REST::Client.new do |config|
  config.consumer_key        = "YOUR_CONSUMER_KEY"
  config.consumer_secret     = "YOUR_CONSUMER_SECRET"
  config.access_token        = "YOUR_ACCESS_TOKEN"
  config.access_token_secret = "YOUR_ACCESS_SECRET"
end

#<Twitter::REST::Client:0x000056204ff8f410 @consumer_key="YOUR_CONSUMER_KEY", @consumer_secret="YOUR_CONSUMER_SECRET", @access_token="YOUR_ACCESS_TOKEN", @access_token_secret="YOUR_ACCESS_SECRET">

class Router
  def initialize
    yield self
  end

  def match(route)
    puts route
  end
end

routes = Router.new do |r|
  r.match '/about' => 'home#about'
  r.match '/users' => 'users#index'
end

def foo
  yield self
end

foo do
  puts self
end
# => main

class Router
  def initialize(&block)
    instance_eval &block
  end

  def match(route)
    puts route
  end
end

routes = Router.new do
  match '/about' => 'home#about'
end

module Twitter
  module REST
    class Client
      attr_accessor :consumer_key, :consumer_secret,
                    :access_token, :access_token_secret

      def initialize(options = {}, &block)
        options.each { |k, v| send("#{k}=", v) }
        instance_eval(&block) if block_given?
      end
    end
  end
end

client = Twitter::REST::Client.new({consumer_key: "YOUR_CONSUMER_KEY"}) do
  consumer_secret     = "YOUR_CONSUMER_SECRET"
  access_token        = "YOUR_ACCESS_TOKEN"
  access_token_secret = "YOUR_ACCESS_SECRET"
end

class Array
  def map
    array = []
    each do |x|
      array.push(yield x)
    end
    array
  end
end
goal = %w(look ma no for loops).map do |x|
  x.upcase
end
p goal

"Nothing lasts forever but cold November Rain".each_word do |x|
  puts x
end
# => Nothing
# => lasts
# => forever ...

class String
  def each_word
    split.each do |x|
      yield x
    end
  end
end

"Nothing lasts forever but cold November Rain".each_word do |x|
  puts x
end

ActiveRecord::Schema.define(version: 20130314230445) do
  create_table "microposts", force: true do |t|
    t.string "content"
    t.integer "user_id"
    t.datetime "created_at"
    t.datetime "updated_at"
  end
end

module ActiveRecord
  class Schema
    def self.define(version, &block)
      version
      instance_eval(&block) if block_given?
    end

    def self.create_table(table_name, options = {}, &block)
      t = Table.new(table_name, options)
      yield t if block_given?
    end
  end
end

class Table
  def initialize(name, options)
    @name = name
    @options = options
  end

  def string(value)
    puts "Creating column of type string named #{value}"
  end

  def integer(value)
    puts "Creating column of type integer named #{value}"
  end

  def datetime(value)
    puts "Creating column of type datetime named #{value}"
  end
end

ActiveRecord::Schema.define(version: 20130315230445) do
  create_table "microposts", force: true do |t|
    t.string "content"
    t.integer "user_id"
    t.datetime "created_at"
    t.datetime "updated_at"
  end
end

# Output
# Creating column of type string named content
# Creating column of type string named user_id
# Creating column of type string named created_at
# Creating column of type string named updated_at

p = proc { |x, y| x + y }

p = Kernel.proc { |x, y| x + y }

p = proc { |x, y| p x + y }
p.call("oh", "ai")
p.call(4, 2)

p = proc { |x, y| p x + y }
p.("oh", "ai")
p.(1, 2)

class Carly
  def call(who)
    "call #{who}, maybe"
  end
end
c = Carly.new
c.("me")

even = proc { |x| x % 2 == 0 }
p even === 11
p even === 10

lambda {}.class

proc {}.class

lambda { |x, y| x + y }.call(x, y)
lambda { |x, y| x + y }[x, y]
lambda { |x, y| x + y }.(x, y)
lambda { |x, y| x + y } === [x, y]

-> (x, y){ x + y }.call(x, y)
-> (x, y){ x + y }[x, y]
-> (x, y){ x + y }.(x, y)
-> (x, y){ x + y } === [x, y]

l = lambda { |x, y| puts "x: #{x}, y: #{y}" }
l.call("Ohai", "Gentle Reader")
p = proc { |x, y| puts "x: #{x}, y: #{y}" }
p.call("Ohai", "Gentle Reader")
p.call("Ohai")

l = lambda { |x, y| puts "x: #{x}, y: #{y}" }
l.call("Ohai")

class SomeClass
  def method_that_calls_proc_or_lambda(procy)
    puts "calling #{proc_or_lambda(procy)} now!"
    procy.call
    puts "#{proc_or_lambda(procy)} gets called!"
  end

  def proc_or_lambda(proc_like_thing)
    proc_like_thing.lambda? ? "lambda" : "Proc"
  end
end

c = SomeClass.new
c.method_that_calls_proc_or_lambda lambda { return } # OK
c.method_that_calls_proc_or_lambda proc { return } # gets calledまで到達しない。procはmainコンテキストで作られる。

["a", "i", "u"].map { |s| s.length }

["a", "i", "u"].map(&:length)

obj = Object.new
[1, 2, 3].map &obj

class Object
  def to_proc
    proc {}
  end
end
obj = Object.new
p [1, 2, 3].map &obj # => [nil, nil, nil]

class Object
  def to_proc
    proc { |x| "Here's #{x}!" }
  end
end
obj = Object.new
p [1, 2, 3].map(&obj) # => ["Here's 1!", "Here's 2!", "Here's 3!"]

class Symbol
  def to_proc
    proc { |obj| obj.send(self) }
  end
end
p ["ai", "iue", "u"].map(&:length)
# => [2, 3, 1]
p ["ai", "iue", "u"].map(&:upcase)
# => ["AI", "IUE", "U"]

p [1, 2, 3].inject(0) { |result, element| result + element }
p [1, 2, 3].inject(&:+)

class Symbol
  def to_proc
    lambda { |obj, args| obj.send(self, *args) }
  end
end
p [1, 2, 3].inject(&:+)

discriminant = lambda { |a| lambda { |b| lambda { |c| b **2 - 4*a*c } } }
discriminant.call(5).call(6).call(7)

discriminant = lambda { |a, b, c| b**2 - 4*a*c }.curry
discriminant.call(5).call(6).call(7)

sum_ints = lambda do |start,stop|
  (start..stop).inject{ |sum,x| sum + x }
end

sum_of_squares= lambda do |start,stop|
  (start..stop).inject{ |sum,x| sum + x*x }
end

sum_of_cubes = lambda do |start,stop|
  (start..stop).inject{ |sum,x| sum + x*x*x}
end

sum = lambda do |fun, start, stop|
  (start..stop).inject { |sum, x| sum + fun.call(x) }
end

p sum_of_ints = sum.(lambda { |x| x }, 1, 10)
p sum_of_square = sum.(lambda { |x| x*x }, 1, 10)
p sum_of_cubes = sum.(lambda { |x| x*x*x }, 1, 10)

sum = lambda do |fun, start, stop|
  (start..stop).inject { |sum, x| sum + fun.call(x) }
end

sum_of_squares = sum.curry.(lambda { |x| x*x })
sum_of_squares.(1).(10)
sum_of_squares.(50).(100)

class Symbol
  def to_proc
    proc { |obj, args| obj.send(self, *args) }
  end
end

"aaaa".send(:length)

class SpiceGirl
  def initialize(name, nick)
    @name = name
    @nick = nick
  end

  def inspect
    "#{@name} (#{@nick} Spice)"
  end

  def self.to_proc
    proc { |obj| self.new(obj[0], obj[1]) }
  end
end

spice_girls = [["tarou", "T"], ["jirou", "J"]]
p spice_girls.map(&SpiceGirl)
# => [tarou (T Spice), jirou (J Spice)]

p proc {}.class
p proc {}.lambda?
p lambda {}.class
p lambda {}.lambda?
p -> {}.class
p lambda {}.lambda?

j1 = proc   { |x,y,z| "#{x}, #{y}, #{z}" }
j2 = lambda { |x,y,z| "#{x}, #{y}, #{z}" }
j1.call("hello", "world")
# j2.call("hello", "world") # argument error

j1 = proc { |x,y,z| x + y + z }
j2 = lambda { |x,y,z| x + y + z }
# j1.call(1, 2) # -:3:in `+': nil can't be coerced into Integer (TypeError)
# j2.call(1, 2) # -:4:in `block in main': wrong number of arguments (given 2, expected 3) (ArgumentError)

p 1.upto(Float::INFINITY) # 評価せずオブジェクトを返す
p 1.upto(5).to_a # 評価する
# p 1.upto(Float::INFINITY).to_a # 処理は終わらない

p 1.upto(Float::INFINITY).lazy.map { |x| x * x }
p 1.upto(Float::INFINITY).lazy.map { |x| x * x }.take(10)
p 1.upto(Float::INFINITY).lazy.map { |x| x * x }.take(10).to_a

p e = Enumerator.new([1, 2, 3])
p e.next
p e.next
p e.next

e = Enumerator.new do |yielder|
  [1, 2, 3].each do |val|
    yielder << val
  end
end

f = Fiber.new do
  x = 0
  loop do
    Fiber.yield x
    x += 1
  end
end

p f.resume
p f.resume
p f.resume

module Enumerable
  def lax
    Lax.new(self)
  end
end

class Lax < Enumerator
  def initialize(receiver)
    super() do |yielder|
      receiver.each do |val|
        yielder << val
      end
    end
  end
end

e = 1.upto(Float::INFINITY).lax
p e.next # 1
p e.next # 2

module Enumerable
  def lax
    Lax.new(self)
  end
end

class Lax < Enumerator
  def initialize(receiver)
    super() do |yielder|
      receiver.each do |val|
        puts "add: #{val}"
        yielder << val
      end
    end
  end
end

lax = Lax.new([1, 2, 3])
lax.map { |x| puts "map: #{x}; x" }

# add: 1
# map: 1; x
# add: 2
# map: 2; x
# add: 3
# map: 3; x

module Enumerable
  def lax
    Lax.new(self)
  end
end

class Lax < Enumerator
  def initialize(receiver)
    super() do |yielder|
      receiver.each do |val|
        if block_given?
          yield(yielder, val)
        else
          yielder << val
        end
      end
    end
  end

  def map(&block)
    Lax.new(self) do |yielder, val|
      yielder << block.call(val)
    end
  end
end

p 1.upto(Float::INFINITY).lax.map { |x| x*x }.map { |x| x+1 }.first(5)
# [2, 5, 10, 17, 26]

def take(n)
  taken = 0
  Lax.new(self) do |yielder, val|
    if taken < n
      yielder << val
      taken += 1
    else
      raise StopIteration
    end
  end
end
p 1.upto(Float::INFINITY).lax.take(5).first(5)
# [1, 2, 3, 4, 5]

class Lax < Enumerator
  def initialize(receiver)
    super() do |yielder|
      receiver.each do |val|
        if block_given?
          yield(yielder, val)
        else
          yielder << val
        end
      end
    rescue StopIteration
    end
  end

  def map(&block)
    Lax.new(self) do |yielder, val|
      yielder << block.call(val)
    end
  end

  def take(n)
    taken = 0
    Lax.new(self) do |yielder, val|
      if taken < n
        yielder << val
        taken += 1
      else
        raise StopIteration
      end
    end
  end
end

p 1.upto(Float::INFINITY).lax.map { |x| x*x }.map { |x| x+1 }.first(5)
p 1.upto(Float::INFINITY).lax.map { |x| x*x }.map { |x| x+1 }.take(5).to_a # ↑と結果は同じ

def select(&block)
  Lax.new(self) do |yielder, val|
    if block.call(val)
      yielder << val
    end
  end
end

p 1.upto(Float::INFINITY).lax.take(5).select { |x| x % 2 == 0 }.to_a
# => [2, 4]

def drop(n)
  dropped = 0
  Lax.new(self) do |yielder, val|
    if dropped < n
      dropped += 1
    else
      yielder << val
    end
  end
end

p 1.upto(Float::INFINITY).lax.take(5).drop(3).to_a
# => [4, 5]

  require 'ripper'
  require 'pp'
  code = <<STR
10.times do |n|
  puts n
end
STR
  puts code
  pp Ripper.lex(code)

code = "a = 1+2; a"
RubyVM::InstructionSequence.compile(code).disasm

code = "a = 'hello' + 'world'; a"
RubyVM::InstructionSequence.compile(code).disasm

code = "a=[1, 2, 3]; a[0]=100;"
RubyVM::InstructionSequence.compile(code).disasm

# これは検知される
foo(
  # aaaa

  22
)

# これはセーフ。これで間に合うように感じる。
foo(
  # bbbb
  22
)

def on_send(node)
  method = node.method_name
  lhs = node.receiver
  rhs = node.first_argument

  # a.+(b)
  # a -> lhs
  # + -> method
  # b -> rhs
end