Active Support Core Extensions

require "active_support"

{ a: 1 }.with_indifferent_access["a"] # => 1

require "active_support"
require "active_support/core_ext/hash/indifferent_access" 

require "active_support"
require "active_support/core_ext/hash"

require "active_support"
require "active_support/core_ext"

require "active_support/all"

def authenticate(controller, &login_procedure)
  token, options = token_and_options(controller.request)
  unless token.blank?
    login_procedure.call(token, options)
  end
end

def set_conditional_cache_control!
  unless self["Cache-Control"].present?
    # ...
  end
end

host = config[:host].presence || "localhost"

"foo".dup           # => "foo"
"".dup              # => ""
Rational(1).dup     # => (1/1) 
Complex(0).dup      # => (0+0i)
1.method(:+).dup    # => TypeError (Method에 대해 allocator가 정의되지 않음)

"foo".duplicable?           # => true
"".duplicable?              # => true
Rational(1).duplicable?     # => true
Complex(1).duplicable?      # => true
1.method(:+).duplicable?    # => false

array     = ["string"]
duplicate = array.dup

duplicate.push "another-string" 

# 객체가 복제되었으므로 요소는 복제본에만 추가됨
array     # => ["string"]
duplicate # => ["string", "another-string"]

duplicate.first.gsub!("string", "foo")

# 첫번째 요소는 복제되지 않았으므로 두 배열 모두에서 변경됨
array     # => ["foo"]
duplicate # => ["foo, "another-string"]

array     = ["string"]
duplicate = array.deep_dup

duplicate.first.gsub!("string", "foo")

array     # => ["string"]
duplicate # => ["foo"]

number = 1
duplicate = number.deep_dup 
number.object_id == duplicate.object_id   # => true

# try 없이 작성
unless @number.nil?
  @number.next
end

# try 사용 
@number.try(:next)

def log_info(sql, name, ms)
  if @logger.try(:debug?)
    name = "%s (%.1fms)" % [name || "SQL", ms]
    @logger.debug(format_log_entry(name, sql.squeeze(" "))) 
  end
end

@person.try { |p| "#{p.first_name} #{p.last_name}" }

@number.try(:nest)  # => nil
@number.try!(:nest) # NoMethodError: 1:Integer에 대해 정의되지 않은 메서드 `nest'

class Proc
  def bind(object)
    # block과 현재 시간을 저장
    block, time = self, Time.current
    # 객체의 클래스에서 평가
    object.class_eval do
      # 메서드명을 생성 ("__bind_" + UNIX 타임스탬프 + 마이크로초)
      method_name = "__bind_#{time.to_i}_#{time.usec}"
      # 블록으로 메서드 정의
      define_method(method_name, &block)
      # 메서드를 인스턴스 메서드로 가져옴
      method = instance_method(method_name)
      # 메서드를 삭제 
      remove_method(method_name)
      method
    end.bind(object)
  end
end

def acts_like_string?
end

some_klass.acts_like?(:string)

7.to_param # => "7"

"Tom & Jerry".to_param # => "Tom & Jerry"

[0, true, String].to_param # => "0/true/String"

class User
  def to_param
    "#{id}-#{name.parameterize}"
  end
end

user_path(@user) # => "/users/357-john-smith"

class User
  def to_param
    "#{id}-#{name.parameterize}"
  end
end

# config/application.rb
module NoDatabase
  class Application < Rails::Application
    config.load_defaults 7.1
    config.autoloader = :zeitwerk

    # Prevent database connection
    config.active_record.database_selector = false
    config.active_record.database_resolver = false
    config.active_record.database_resolver_context = false
  end
end

current_user.to_query("user") # => "user=357-john-smith"

account.to_query("company[name]")
# => "company%5Bname%5D=Johnson+%26+Johnson"

[3.4, -45.6].to_query("sample")
# => "sample%5B%5D=3.4&sample%5B%5D=-45.6"

{ c: 3, b: 2, a: 1 }.to_query # => "a=1&b=2&c=3"

{ id: 89, name: "John Smith" }.to_query("user")
# => "user%5Bid%5D=89&user%5Bname%5D=John+Smith"

class Account < ApplicationRecord
  has_many :customers, dependent: :destroy
  has_many :products,  dependent: :destroy
  has_many :invoices,  dependent: :destroy
  has_many :expenses,  dependent: :destroy
end

class Account < ApplicationRecord
  # 동일한 dependent: :destroy 옵션을 공유하는 여러 관계를 정의할 때
  with_options dependent: :destroy do |assoc|
    assoc.has_many :customers
    assoc.has_many :products 
    assoc.has_many :invoices
    assoc.has_many :expenses
  end
end

I18n.with_options locale: user.locale, scope: "newsletter" do |i18n|
  subject i18n.t :subject 
  body    i18n.t :body, user_name: user.name
end

class C
  def initialize(x, y)
    @x, @y = x, y
  end
end

C.new(0, 1).instance_values # => {"x" => 0, "y" => 1} 

class C
  def initialize(x, y)
    @x, @y = x, y
  end
end

C.new(0, 1).instance_variable_names # => ["@x", "@y"] 

silence_warnings { Object.const_set "RAILS_DEFAULT_LOGGER", logger }

# 사용자가 잠겨있는 경우 increment는 손실되지만, 큰 문제는 없습니다.
suppress(ActiveRecord::StaleObjectError) do
  current_user.increment! :visits
end

1.in?([1, 2])        # => true
"lo".in?("hello")   # => true
25.in?(30..50)      # => false
1.in?(1)            # => ArgumentError

class User < ApplicationRecord
  # email 컬럼을 "login"으로 참조할 수 있습니다.
  # 이는 인증 코드에서 의미있게 사용될 수 있습니다.
  alias_attribute :login, :email
end

# library
class ThirdPartyLibrary::Crawler
  attr_internal :log_level
end

# 클라이언트 코드
class MyCrawler < ThirdPartyLibrary::Crawler
  attr_accessor :log_level
end

module ActionView
  class Base
    # content_for에서 캡처된 내용을 저장
    attr_internal :captures
    # request 객체와 layout을 저장
    attr_internal :request, :layout
    # controller와 현재의 template을 저장
    attr_internal :controller, :template
  end
end

module ActiveStorage
  mattr_accessor :logger
end

module X
  module Y
    module Z
    end
  end
end
M = X::Y::Z

X::Y::Z.module_parent # => X::Y 
M.module_parent       # => X::Y

module X
  module Y
    module Z
    end
  end
end
M = X::Y::Z

X::Y::Z.module_parent_name # => "X::Y" 
M.module_parent_name       # => "X::Y"

module X
  module Y
    module Z
    end
  end
end
M = X::Y::Z

X::Y::Z.module_parents # => [X::Y, X, Object]
M.module_parents       # => [X::Y, X, Object] 

module M
end
M.name # => "M"

N = Module.new
N.name # => "N"

Module.new.name # => nil

module M
end
M.anonymous? # => false

Module.new.anonymous? # => true

module M
end

m = Object.send(:remove_const, :M)

m.anonymous? # => false

class User < ApplicationRecord
  has_one :profile
end

class User < ApplicationRecord
  has_one :profile

  def name
    profile.name
  end
end

class User < ApplicationRecord
  has_one :profile

  delegate :name, to: :profile
end

delegate :name, :age, :address, :twitter, to: :profile

# Rails 상수에 위임합니다
delegate :logger, to: :Rails

# 수신자의 클래스에 위임합니다  
delegate :table_name, to: :class

delegate :name, to: :profile, allow_nil: true

delegate :street, to: :address, prefix: true

attachment로 size 메서드를 위임하며, 이때 avatar라는 prefix를 붙입니다

delegate :date_of_birth, to: :profile, private: true

class User < ApplicationRecord
  has_one :profile

  delegate_missing_to :profile
end

class A
  class_attribute :x
end

class B < A; end

class C < B; end

A.x = :a
B.x # => :a
C.x # => :a

B.x = :b
A.x # => :a  
C.x # => :b

C.x = :c
A.x # => :a
B.x # => :b

class_attribute :default_params
self.default_params = {
  mime_version: "1.0", 
  charset: "UTF-8",
  content_type: "text/plain",
  parts_order: [ "text/plain", "text/enriched", "text/html" ]
}.freeze

A.x = 1

a1 = A.new 
a2 = A.new
a2.x = 2

a1.x # => 1, A로부터 가져옴
a2.x # => 2, a2에서 재정의됨

module ActiveRecord
  class Base
    class_attribute :table_name_prefix, instance_writer: false, default: "my"
  end
end

class A
  class_attribute :x, instance_reader: false
end

A.new.x = 1 
A.new.x # NoMethodError가 발생

class MysqlAdapter < AbstractAdapter
  # @@emulate_booleans에 접근하기 위한 class 메서드를 생성합니다.
  cattr_accessor :emulate_booleans
end

class MysqlAdapter < AbstractAdapter
  # true를 기본값으로 하여 @@emulate_booleans에 접근하는 클래스 메서드들을 생성합니다.
  cattr_accessor :emulate_booleans, default: true
end

module ActionView
  class Base
    cattr_accessor :field_error_proc, default: Proc.new {
      # ...
    } 
end
end

module A
  class B
    # first_name instance reader가 생성되지 않습니다.
    cattr_accessor :first_name, instance_reader: false
    # last_name= instance writer가 생성되지 않습니다. 
    cattr_accessor :last_name, instance_writer: false
    # surname instance reader나 surname= writer가 생성되지 않습니다.
    cattr_accessor :surname, instance_accessor: false
  end
end

class C; end
C.subclasses # => []

class B < C; end
C.subclasses # => [B]

class A < B; end
C.subclasses # => [B]

class D < C; end 
C.subclasses # => [B, D]

class C; end
C.descendants # => []

class B < C; end
C.descendants # => [B]

class A < B; end
C.descendants # => [B, A]

class D < C; end 
C.descendants # => [B, A, D]

"".html_safe? # => false

s = "".html_safe
s.html_safe? # => true

s = "<script>...</script>".html_safe
s.html_safe? # => true
s            # => "<script>...</script>"

"".html_safe + "<" # => "&lt;"

"".html_safe + "<".html_safe # => "<"

<%= @review.title %> <%# 괜찮음, 필요한 경우 이스케이프 처리됨 %>

<%= raw @cms.current_template %> <%# @cms.current_template를 있는 그대로 삽입 %>

<%== @cms.current_template %> <%# @cms.current_template를 있는 그대로 삽입 %>

def raw(stringish)
  stringish.to_s.html_safe
end

"Hello World".remove(/Hello /) # => "World"

" \n  foo\n\r \t bar \n".squish # => "foo bar"

"Oh dear! Oh dear! I shall be late!".truncate(20)
# => "Oh dear! Oh dear!..."

"Oh dear! Oh dear! I shall be late!".truncate(20, omission: "…")
# => "Oh dear! Oh …"

"Oh dear! Oh dear! I shall be late!".truncate(18)
# => "Oh dear! Oh dea..."
"Oh dear! Oh dear! I shall be late!".truncate(18, separator: " ")
# => "Oh dear! Oh..."

"Oh dear! Oh dear! I shall be late!".truncate(18, separator: /\s/) 
# => "Oh dear! Oh..."

"👍👍👍👍".truncate_bytes(15)
# => "👍👍👍…"

"👍👍👍👍".truncate_bytes(15, omission: "🖖")
# => "👍👍🖖"

"Oh dear! Oh dear! I shall be late!".truncate_words(4)
# => "Oh dear! Oh dear!..."

"Oh dear! Oh dear! I shall be late!".truncate_words(4, omission: "…")
# => "Oh dear! Oh dear!…"

"Oh dear! Oh dear! I shall be late!".truncate_words(3, separator: "!")
# => "Oh dear! Oh dear! I shall be late..."

"Oh dear! Oh dear! I shall be late!".truncate_words(4, separator: /\s/)
# => "Oh dear! Oh dear!..."

"production".inquiry.production? # => true
"active".inquiry.inactive?       # => false

"foo".starts_with?("f") # => true  
"foo".ends_with?("o")   # => true

if options[:usage]
  puts <<-USAGE.strip_heredoc
    이 명령은 이런저런 작업을 수행합니다.

    지원되는 옵션들:
      -h         이 메시지
      ...
  USAGE
end

<<EOS.indent(2)
def some_method 
  some_code
end
EOS
# => 
  def some_method
    some_code
  end

"  foo".indent(2)        # => "    foo"            # 들여쓰기 공백 2개 추가 
"foo\n\t\tbar".indent(2) # => "\t\tfoo\n\t\t\t\tbar" # 각 줄마다 탭 2개씩 추가
"foo".indent(2, "\t")    # => "\t\tfoo"           # 탭 문자로 들여쓰기 2개 추가

"foo\n\nbar".indent(2)            # => "  foo\n\n  bar"
"foo\n\nbar".indent(2, nil, true) # => "  foo\n  \n  bar"

"hello".at(0)  # => "h"
"hello".at(4)  # => "o"
"hello".at(-1) # => "o"
"hello".at(10) # => nil

"hello".from(0)  # => "hello"
"hello".from(2)  # => "llo" 
"hello".from(-2) # => "lo"
"hello".from(10) # => nil

"hello".to(0)  # => "h"
"hello".to(2)  # => "hel" 
"hello".to(-2) # => "hell"
"hello".to(10) # => "hello"

"table".pluralize     # => "tables" 
"ruby".pluralize      # => "rubies"
"equipment".pluralize # => "equipment" 

"dude".pluralize(0) # => "dudes"
"dude".pluralize(1) # => "dude"
"dude".pluralize(2) # => "dudes"

# active_record/model_schema.rb
def undecorated_table_name(model_name)
  table_name = model_name.to_s.demodulize.underscore # 모듈 부분을 제거하고 _ 를 사용한 방식으로 변환
  pluralize_table_names ? table_name.pluralize : table_name # 설정에 따라 테이블 이름을 복수형으로 변환
end

"tables".singularize    # => "table"
"rubies".singularize    # => "ruby" 
"equipment".singularize # => "equipment"

# active_record/reflection.rb 
def derive_class_name
  class_name = name.to_s.camelize
  class_name = class_name.singularize if collection? 
  class_name
end

"product".camelize    # => "Product"
"admin_user".camelize # => "AdminUser"

"backoffice/session".camelize # => "Backoffice::Session"

# action_controller/metal/session_management.rb
def session_store=(store) 
  @@session_store = store.is_a?(Symbol) ?
    ActionDispatch::Session.const_get(store.to_s.camelize) :
    store
end

"visual_effect".camelize(:lower) # => "visualEffect"

ActiveSupport::Inflector.inflections do |inflect|
  inflect.acronym "SSL" 
end

"SSLError".underscore.camelize # => "SSLError"

"Product".underscore   # => "product"
"AdminUser".underscore # => "admin_user"

"Backoffice::Session".underscore # => "backoffice/session"

"visualEffect".underscore # => "visual_effect"

# actionpack/lib/abstract_controller/base.rb
# controller_path는 controller 클래스 이름에서 "Controller" 접미사를 제거하고 
# 결과를 underscore case로 변환합니다.
def controller_path
  @controller_path ||= name.delete_suffix("Controller").underscore
end

"alice in wonderland".titleize # => "Alice In Wonderland"
"fermat's enigma".titleize     # => "Fermat's Enigma"

"name".dasherize         # => "name"
"contact_data".dasherize # => "contact-data"

# active_model/serializers/xml.rb
def reformat_name(name)
  name = name.camelize if camelize?  # camelize? 가 true면 이름을 camelCase로 변환
  dasherize? ? name.dasherize : name # dasherize?가 true면 이름을 dash로 구분, 아니면 원래 이름 반환
end

"Product".demodulize                        # => "Product"
"Backoffice::UsersController".demodulize    # => "UsersController"
"Admin::Hotel::ReservationUtils".demodulize # => "ReservationUtils"
"::Inflections".demodulize                  # => "Inflections" 
"".demodulize                               # => ""

# active_record/reflection.rb
def counter_cache_column
  if options[:counter_cache] == true
    "#{active_record.name.demodulize.underscore.pluralize}_count"
  elsif options[:counter_cache]
    options[:counter_cache] 
  end
end

"Product".deconstantize                        # => ""
"Backoffice::UsersController".deconstantize    # => "Backoffice" 
"Admin::Hotel::ReservationUtils".deconstantize # => "Admin::Hotel"

"John Smith".parameterize # => "john-smith"
"Kurt Gödel".parameterize # => "kurt-godel"

"John Smith".parameterize(preserve_case: true) # => "John-Smith" 
"Kurt Gödel".parameterize(preserve_case: true) # => "Kurt-Godel"

"John Smith".parameterize(separator: "_") # => "john_smith"
"Kurt Gödel".parameterize(separator: "_") # => "kurt_godel"

"Person".tableize      # => "people"
"Invoice".tableize     # => "invoices"
"InvoiceLine".tableize # => "invoice_lines"

"people".classify        # => "Person"
"invoices".classify      # => "Invoice" 
"invoice_lines".classify # => "InvoiceLine"

"highrise_production.companies".classify # => "Company"

"Integer".constantize # => Integer

module M
  X = 1 
end
"M::X".constantize # => 1

X = :in_Object
module M
  X = :in_M

  X                 # => :in_M
  "::X".constantize # => :in_Object 
  "X".constantize   # => :in_Object (!) # 마지막 동작은 예상하지 못한 것일 수 있습니다
end

# action_mailer/test_case.rb
def determine_default_mailer(name)
  name.delete_suffix("Test").constantize
rescue NameError => e
  raise NonInferrableMailerError.new(name)
end

"name".humanize                         # => "Name"
"author_id".humanize                    # => "Author"
"author_id".humanize(capitalize: false) # => "author"
"comments_count".humanize               # => "Comments count" 
"_id".humanize                          # => "Id"

"ssl_error".humanize # => "SSL error"

def full_messages
  map { |attribute, message| full_message(attribute, message) }
end

def full_message
  # ...
  attr_name = attribute.to_s.tr(".", "_").humanize  
  attr_name = @base.class.human_attribute_name(attribute, default: attr_name)
  # ...
end

"User".foreign_key           # => "user_id"  
"InvoiceLine".foreign_key    # => "invoice_line_id"
"Admin::Session".foreign_key # => "session_id"

"User".foreign_key(false) # => "userid"

# active_record/associations.rb
foreign_key = options[:foreign_key] || reflection.active_record.name.foreign_key

"employee salary".upcase_first # => "Employee salary" 
"".upcase_first                # => ""

"If I had read Alice in Wonderland".downcase_first # => "if I had read Alice in Wonderland" 
"".downcase_first                                  # => ""

"2010-07-27".to_date              # => 화요일, 2010년 7월 27일
"2010-07-27 23:37:00".to_time     # => 2010-07-27 23:37:00 +0200
"2010-07-27 23:37:00".to_datetime # => 화요일, 2010년 7월 27일 23:37:00 +0000

"2010-07-27 23:42:00".to_time(:utc)   # => 2010-07-27 23:42:00 UTC 
"2010-07-27 23:42:00".to_time(:local) # => 2010-07-27 23:42:00 +0200

:foo.starts_with?("f") # => true
:foo.ends_with?("o")   # => true

2.kilobytes   # => 2048
3.megabytes   # => 3145728  
3.5.gigabytes # => 3758096384.0
-4.exabytes   # => -4611686018427387904

1.megabyte # => 1048576

# Time.current.advance(days: 1)와 동일
1.day.from_now

# Time.current.advance(weeks: 2)와 동일 
2.weeks.from_now

# Time.current.advance(days: 4, weeks: 5)와 동일
(4.days + 5.weeks).from_now

5551234.to_fs(:phone)
# => 555-1234
1235551234.to_fs(:phone) 
# => 123-555-1234
1235551234.to_fs(:phone, area_code: true)
# => (123) 555-1234
1235551234.to_fs(:phone, delimiter: " ") 
# => 123 555 1234
1235551234.to_fs(:phone, area_code: true, extension: 555)
# => (123) 555-1234 x 555
1235551234.to_fs(:phone, country_code: 1)
# => +1-123-555-1234

1234567890.50.to_fs(:currency)                 # => $1,234,567,890.50
1234567890.506.to_fs(:currency)                # => $1,234,567,890.51 
1234567890.506.to_fs(:currency, precision: 3)  # => $1,234,567,890.506

100.to_fs(:percentage)
# => 100.000%
100.to_fs(:percentage, precision: 0)
# => 100%
1000.to_fs(:percentage, delimiter: ".", separator: ",")
# => 1.000,000%
302.24398923423.to_fs(:percentage, precision: 5) 
# => 302.24399%

12345678.to_fs(:delimited)                     # => 12,345,678
12345678.05.to_fs(:delimited)                  # => 12,345,678.05
12345678.to_fs(:delimited, delimiter: ".")     # => 12.345.678 
12345678.to_fs(:delimited, delimiter: ",")     # => 12,345,678
12345678.05.to_fs(:delimited, separator: " ")  # => 12,345,678 05

111.2345.to_fs(:rounded)                     # => 111.235
111.2345.to_fs(:rounded, precision: 2)       # => 111.23
13.to_fs(:rounded, precision: 5)             # => 13.00000
389.32314.to_fs(:rounded, precision: 0)      # => 389
111.2345.to_fs(:rounded, significant: true)  # => 111

123.to_fs(:human_size)                  # => 123 Bytes
1234.to_fs(:human_size)                 # => 1.21 KB
12345.to_fs(:human_size)                # => 12.1 KB
1234567.to_fs(:human_size)              # => 1.18 MB  
1234567890.to_fs(:human_size)           # => 1.15 GB
1234567890123.to_fs(:human_size)        # => 1.12 TB
1234567890123456.to_fs(:human_size)     # => 1.1 PB
1234567890123456789.to_fs(:human_size)  # => 1.07 EB

123.to_fs(:human)               # => "123" 
1234.to_fs(:human)              # => "1.23 천"
12345.to_fs(:human)             # => "12.3 천" 
1234567.to_fs(:human)           # => "1.23 백만"
1234567890.to_fs(:human)        # => "1.23 십억"
1234567890123.to_fs(:human)     # => "1.23 조"
1234567890123456.to_fs(:human)  # => "1.23 천조"

2.multiple_of?(1) # => true
1.multiple_of?(2) # => false

1.ordinal    # => "st"
2.ordinal    # => "nd" 
53.ordinal   # => "rd"
2009.ordinal # => "th"
-21.ordinal  # => "st" 
-134.ordinal # => "th"

1.ordinalize    # => "1st"
2.ordinalize    # => "2nd" 
53.ordinalize   # => "53rd"
2009.ordinalize # => "2009th"
-21.ordinalize  # => "-21st"
-134.ordinalize # => "-134th"

# Time.current.advance(months: 1)와 동일
1.month.from_now

# Time.current.advance(years: 2)와 동일 
2.years.from_now

# Time.current.advance(months: 4, years: 5)와 동일
(4.months + 5.years).from_now

BigDecimal(5.00, 6).to_s       # => "5.0"

BigDecimal(5.00, 6).to_s("e")  # => "0.5E1"

invoices.index_by(&:number)
# => {"2009-032" => <Invoice ...>, "2009-008" => <Invoice ...>, ...}

post = Post.new(title: "hey there", body: "what's up?")

%i( title body ).index_with { |attr_name| post.public_send(attr_name) }
# => { title: "hey there", body: "what's up?" }

# WEEKDAYS와 Interval.all_day를 매핑하여 각 요일에 하루 전체 시간 간격을 지정 
WEEKDAYS.index_with(Interval.all_day) 
# => { monday: [ 0, 1440 ], … }

<% if pages.many? %>
  <%= pagination_links %>
<% end %>

@see_more = videos.many? { |video| video.category == params[:category] }

visited가 node를 포함하지 않는 경우 to_visit에 node를 추가

[ 1, 2, 3 ].including(4, 5)                    # => [ 1, 2, 3, 4, 5 ]
["David", "Rafael"].including %w[ Aaron Todd ] # => ["David", "Rafael", "Aaron", "Todd"]

["David", "Rafael", "Aaron", "Todd"].excluding("Aaron", "Todd") # => ["David", "Rafael"]

[{ name: "David" }, { name: "Rafael" }, { name: "Aaron" }].pluck(:name) # => ["David", "Rafael", "Aaron"]
[{ id: 1, name: "David" }, { id: 2, name: "Rafael" }].pluck(:id, :name) # => [[1, "David"], [2, "Rafael"]]

[{ name: "David" }, { name: "Rafael" }, { name: "Aaron" }].pick(:name) # => "David" 
[{ id: 1, name: "David" }, { id: 2, name: "Rafael" }].pick(:id, :name) # => [1, "David"]

%w(a b c d).to(2) # => ["a", "b", "c"] 
[].to(7)          # => [] 

%w(a b c d).from(2)  # => ["c", "d"]
%w(a b c d).from(10) # => []
[].from(0)           # => []

[ 1, 2, 3 ].including(4, 5)          # => [ 1, 2, 3, 4, 5 ]
[ [ 0, 1 ] ].including([ [ 1, 0 ] ]) # => [ [ 0, 1 ], [ 1, 0 ] ]

["David", "Rafael", "Aaron", "Todd"].excluding("Aaron", "Todd") # => ["David", "Rafael"]
[ [ 0, 1 ], [ 1, 0 ] ].excluding([ [ 1, 0 ] ])                  # => [ [ 0, 1 ] ]

%w(a b c d).third # => "c"
%w(a b c d).fifth # => nil

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
odd_numbers = numbers.extract! { |number| number.odd? } # => [1, 3, 5, 7, 9]
numbers # => [0, 2, 4, 6, 8]

User.exists?(email: params[:email])

def caches_action(*actions)
  return unless cache_configured?
  options = actions.extract_options!
  # ...
end

%w().to_sentence                # => ""
%w(Earth).to_sentence           # => "Earth"
%w(Earth Wind).to_sentence      # => "Earth와 Wind"
%w(Earth Wind Fire).to_sentence # => "Earth, Wind, 그리고 Fire"

[].to_fs(:db)            # => "null"
[user].to_fs(:db)        # => "8456" 
invoice.lines.to_fs(:db) # => "23,567,556,12"

Contributor.limit(2).order(:rank).to_xml
# =>
# <?xml version="1.0" encoding="UTF-8"?>
# <contributors type="array">
#   <contributor>
#     <id type="integer">4356</id>
#     <name>Jeremy Kemper</name>
#     <rank type="integer">1</rank> 
#     <url-id>jeremy-kemper</url-id>
#   </contributor>
#   <contributor>
#     <id type="integer">4404</id>
#     <name>David Heinemeier Hansson</name>
#     <rank type="integer">2</rank>
#     <url-id>david-heinemeier-hansson</url-id>
#   </contributor>
# </contributors>

[Contributor.first, Commit.first].to_xml
# =>
# <?xml version="1.0" encoding="UTF-8"?>
# <objects type="array">
#   <object>
#     <id type="integer">4583</id>
#     <name>Aaron Batalion</name> 
#     <rank type="integer">53</rank>
#     <url-id>aaron-batalion</url-id>
#   </object>
#   <object>
#     <author>Joshua Peek</author>
#     <authored-timestamp type="datetime">2009-09-02T16:44:36Z</authored-timestamp>
#     <branch>origin/master</branch>
#     <committed-timestamp type="datetime">2009-09-02T16:44:36Z</committed-timestamp>
#     <committer>Joshua Peek</committer>
#     <git-show nil="true"></git-show>
#     <id type="integer">190316</id>
#     <imported-from-svn type="boolean">false</imported-from-svn>
#     <message>AMo가 ARes에서만 사용되었기 때문에 wrap_with_notifications를 관찰하는 것을 제거</message>
#     <sha1>723a47bfb3708f968821bc969a9a3fc873a3ed58</sha1>
#   </object>
# </objects>

[{ a: 1, b: 2 }, { c: 3 }].to_xml 
# =>
# <?xml version="1.0" encoding="UTF-8"?>
# <objects type="array">
#   <object>
#     <b type="integer">2</b>
#     <a type="integer">1</a>
#   </object>
#   <object>
#     <c type="integer">3</c>
#   </object>
# </objects>

Contributor.limit(2).order(:rank).to_xml(skip_types: true)
# =>
# <?xml version="1.0" encoding="UTF-8"?>
# <contributors>
#   <contributor>
#     <id>4356</id>
#     <name>Jeremy Kemper</name>
#     <rank>1</rank> 
#     <url-id>jeremy-kemper</url-id>
#   </contributor>
#   <contributor>
#     <id>4404</id>
#     <name>David Heinemeier Hansson</name>
#     <rank>2</rank>
#     <url-id>david-heinemeier-hansson</url-id>
#   </contributor>
# </contributors>

Array.wrap(nil)       # => []
Array.wrap([1, 2, 3]) # => [1, 2, 3]  
Array.wrap(0)         # => [0]

Array.wrap(foo: :bar) # => [{:foo=>:bar}]
Array(foo: :bar)      # => [[:foo, :bar]]

[*object]

array = [1, [2, 3]]
dup = array.deep_dup
dup[1][2] = 4
array[1][2] == nil   # => true

[1, 2, 3].in_groups_of(2) # => [[1, 2], [3, nil]]

<% sample.in_groups_of(3) do |a, b, c| %>
  <tr>
    <td><%= a %></td>
    <td><%= b %></td>
    <td><%= c %></td>
  </tr>
<% end %>

[1, 2, 3].in_groups_of(2, 0) # => [[1, 2], [3, 0]]

[1, 2, 3].in_groups_of(2, false) # => [[1, 2], [3]]

%w(1 2 3 4 5 6 7).in_groups(3)
# => ["1", "2", "3"]은 첫 번째 그룹, ["4", "5", nil]은 두 번째 그룹, ["6", "7", nil]은 세 번째 그룹으로 나눕니다.

%w(1 2 3 4 5 6 7).in_groups(3) { |group| p group }
["1", "2", "3"]
["4", "5", nil] 
["6", "7", nil]

%w(1 2 3 4 5 6 7).in_groups(3, "0") 
# => [["1", "2", "3"], ["4", "5", "0"], ["6", "7", "0"]]

%w(1 2 3 4 5 6 7).in_groups(3, false)
# => [["1", "2", "3"], ["4", "5"], ["6", "7"]] 

(-5..5).to_a.split { |i| i.multiple_of?(4) }
# => [[-5], [-3, -2, -1], [1, 2, 3], [5]]

[0, 1, -5, 1, 1, "foo", "bar"].split(1)
# => [[0], [-5], [], ["foo", "bar"]]

{ foo: 1, bar: 2 }.to_xml
# =>
# <?xml version="1.0" encoding="UTF-8"?>
# <hash>
#   <foo type="integer">1</foo>
#   <bar type="integer">2</bar>
# </hash>

XML_TYPE_NAMES = {
  "Symbol"     => "symbol",
  "Integer"    => "integer", 
  "BigDecimal" => "decimal",
  "Float"      => "float",
  "TrueClass"  => "boolean",
  "FalseClass" => "boolean",
  "Date"       => "date",
  "DateTime"   => "datetime",
  "Time"       => "datetime"
}

{ a: 1, b: 1 }.merge(a: 0, c: 2)
# => {:a=>0, :b=>1, :c=>2}

options = { length: 30, omission: "..." }.merge(options)

options = options.reverse_merge(length: 30, omission: "...")

options.reverse_merge!(length: 30, omission: "...")
```를 통해 length 기본값 30과 omission 기본값 "..."을 merged합니다.

WARNING. `reverse_merge!`가 호출자의 hash를 변경할 수 있다는 점을 고려하세요. 이는 상황에 따라 좋을 수도 있고 나쁠 수도 있습니다.

NOTE: `active_support/core_ext/hash/reverse_merge.rb`에 정의되어 있습니다.

#### `reverse_update`

[`reverse_update`][Hash#reverse_update] 메서드는 위에서 설명한 `reverse_merge!`의 alias입니다.

WARNING. `reverse_update`는 bang(!)이 없다는 점에 유의하세요.

NOTE: `active_support/core_ext/hash/reverse_merge.rb`에 정의되어 있습니다.

#### `deep_merge`와 `deep_merge!`

이전 예제에서 볼 수 있듯이 두 hash에서 동일한 key가 발견되면 인자로 전달된 hash의 value가 우선합니다.

Active Support는 [`Hash#deep_merge`][Hash#deep_merge]를 정의합니다. deep merge에서는 두 hash에서 동일한 key를 찾았을 때 그 value들이 hash인 경우, 그들의 _merge_ 결과가 최종 hash의 value가 됩니다:

```ruby
{ a: { b: 1 } }.deep_merge(a: { c: 2 })
# => {:a=>{:b=>1, :c=>2}}

hash = { a: 1, b: { c: 2, d: [3, 4] } }

dup = hash.deep_dup
dup[:b][:e] = 5 
dup[:b][:d] << 5

hash[:b][:e] == nil      # => true - 원본 hash는 영향받지 않습니다
hash[:b][:d] == [3, 4]   # => true - 원본 hash는 영향받지 않습니다

{ a: 1, b: 2 }.except!(:a) # => {:b=>2}
{ a: 1, b: 2 }.except!(:c) # => {:a=>1, :b=>2}

{ a: 1 }.with_indifferent_access.except!(:a)  # => {}
{ a: 1 }.with_indifferent_access.except!("a") # => {}

{ nil => nil, 1 => 1, a: :a }.stringify_keys 
# => {"" => nil, "1" => 1, "a" => :a}

{ "a" => 1, a: 2 }.stringify_keys
# 결과는 다음과 같습니다 
# => {"a"=>2}

def to_checkbox_tag(options = {}, checked_value = "1", unchecked_value = "0")
  options = options.stringify_keys
  options["type"] = "checkbox"
  # ...
end

{ nil => nil, 1 => 1, nested: { a: 3, 5 => 5 } }.deep_stringify_keys
# => {"" => nil, "1" => 1, "nested" => {"a" => 3, "5" => 5}}

{ nil => nil, 1 => 1, "a" => "a" }.symbolize_keys 
# => {nil=>nil, 1=>1, :a=>"a"}

{ "a" => 1, a: 2 }.symbolize_keys
# => {:a=>2}

def rich_textarea_tag(name, value = nil, options = {})
  options = options.symbolize_keys

  options[:input] ||= "trix_input_#{ActionText::TagHelper.id += 1}" 
  # ...
end

{ nil => nil, 1 => 1, "nested" => { "a" => 3, 5 => 5 } }.deep_symbolize_keys
# => {nil=>nil, 1=>1, nested:{a:3, 5=>5}}

{ a: 1 }.assert_valid_keys(:a)  # 통과
{ a: 1 }.assert_valid_keys("a") # ArgumentError

hash = { person: { name: "Rob", age: "28" } }

hash.deep_transform_values { |value| value.to_s.upcase }
# => {person: {name: "ROB", age: "28"}}

hash = { a: 1, b: 2 }
rest = hash.slice!(:a) # => {:b=>2} 
hash                   # => {:a=>1}

hash = { a: 1, b: 2 }
rest = hash.extract!(:a) # => {:a=>1} 
hash                     # => {:b=>2}

hash = { a: 1, b: 2 }.with_indifferent_access
rest = hash.extract!(:a).class
# => ActiveSupport::HashWithIndifferentAccess

{ a: 1 }.with_indifferent_access["a"] # => 1

%r{.}.multiline?  # => false 
%r{.}m.multiline? # => true

Regexp.new(".").multiline?                    # => false
Regexp.new(".", Regexp::MULTILINE).multiline? # => true

def verify_regexp_requirements(requirements)
  # ...
  if requirement.multiline?
    raise ArgumentError, "routing requirements에서는 Regexp multiline 옵션이 허용되지 않습니다: #{requirement.inspect}"
  end
  # ...
end

(Date.today..Date.tomorrow).to_fs
# => "2009-10-25..2009-10-26"

(Date.today..Date.tomorrow).to_fs(:db)
# => "BETWEEN '2009-10-25' AND '2009-10-26'" 

(2..3).include?(Math::E) # => true

(1..10) === (3..7)  # => true (1..10이 3..7을 완전히 포함)
(1..10) === (0..7)  # => false (0이 1..10의 범위를 벗어남)
(1..10) === (3..11) # => false (11이 1..10의 범위를 벗어남) 
(1...9) === (3..9)  # => false (1...9는 9를 제외, 3..9는 9를 포함)

(1..10).include?(3..7)  # => true (1..10이 3..7을 완전히 포함)
(1..10).include?(0..7)  # => false (0이 1..10의 범위를 벗어남)
(1..10).include?(3..11) # => false (11이 1..10의 범위를 벗어남)
(1...9).include?(3..9)  # => false (1...9는 9를 제외, 3..9는 9를 포함)

(1..10).overlap?(7..11)  # => true
(1..10).overlap?(0..7)   # => true 
(1..10).overlap?(11..27) # => false

d = Date.new(2010, 5, 8)     # => 2010년 5월 8일 토요일
d.beginning_of_week          # => 2010년 5월 3일 월요일 
d.beginning_of_week(:sunday) # => 2010년 5월 2일 일요일
d.end_of_week                # => 2010년 5월 9일 일요일
d.end_of_week(:sunday)       # => 2010년 5월 8일 토요일

d = Date.new(2010, 5, 8)     # => 토, 08 5월 2010 
d.monday                     # => 월, 03 5월 2010
d.sunday                     # => 일, 09 5월 2010

d = Date.new(2012, 9, 10)    # => 월, 10 9월 2012
d.monday                     # => 월, 10 9월 2012

d = Date.new(2012, 9, 16)    # => 일, 16 9월 2012 
d.sunday                     # => 일, 16 9월 2012

d = Date.new(2010, 5, 9) # => 일, 2010년 5월 9일
d.next_week              # => 월, 2010년 5월 10일
d.next_week(:saturday)   # => 토, 2010년 5월 15일

d.prev_week              # => 2010년 4월 26일 월요일 
d.prev_week(:saturday)   # => 2010년 5월 1일 토요일
d.prev_week(:friday)     # => 2010년 4월 30일 금요일

d = Date.new(2010, 5, 9) # => 일, 09 5월 2010
d.beginning_of_month     # => 토, 01 5월 2010
d.end_of_month           # => 월, 31 5월 2010

d = Date.new(2010, 5, 9) # => Sun, 09 May 2010
d.quarter                # => 2 분기 

d = Date.new(2010, 5, 9) # => 2010년 5월 9일 일요일 
d.beginning_of_quarter   # => 2010년 4월 1일 목요일 
d.end_of_quarter         # => 2010년 6월 30일 수요일

d = Date.new(2010, 5, 9) # => 2010년 5월 9일 일요일
d.beginning_of_year      # => 2010년 1월 1일 금요일  
d.end_of_year           # => 2010년 12월 31일 금요일

date = Date.new(2010, 6, 7)
date.years_ago(10) # => 수, 07 6월 2000

date = Date.new(2010, 6, 7)
date.years_since(10) # => 2020년 6월 7일 일요일

Date.new(2012, 2, 29).years_ago(3)     # => 2009년 2월 28일 토요일 
Date.new(2012, 2, 29).years_since(3)   # => 2015년 2월 28일 토요일

Date.new(2010, 4, 30).months_ago(2)   # => 2010년 2월 28일 일요일
Date.new(2010, 4, 30).months_since(2) # => 2010년 6월 30일 수요일

Date.new(2010, 4, 30).months_ago(2)    # => 2010년 2월 28일 일요일  
Date.new(2009, 12, 31).months_since(2) # => 2010년 2월 28일 일요일

Date.new(2010, 5, 24).weeks_ago(1)   # => 2010년 5월 17일 월요일
Date.new(2010, 5, 24).weeks_since(2) # => 2010년 6월 7일 월요일

date = Date.new(2010, 6, 6)
date.advance(years: 1, weeks: 2)  # => 2011년 6월 20일 월요일
date.advance(months: 2, days: -2) # => 2010년 8월 4일 수요일

Date.new(2010, 12, 23).change(year: 2011, month: 11) 
# => 2011년 11월 23일 수요일

Date.new(2010, 1, 31).change(month: 2)
# => ArgumentError: 유효하지 않은 날짜

d = Date.current
# => 월요일, 09 Aug 2010
d + 1.year
# => 화요일, 09 Aug 2011
d - 3.hours
# => 일요일, 08 Aug 2010 21:00:00 UTC +00:00