regexp = %r{
  start         # some text
  \s            # white space char
  (group)       # first group
  (?:alt1|alt2) # some alternation
  end
}x

def create_message_struct(message)
  objects = message["objects"].map { |object| convert_message_object(object) }
  Auditor::Message.new(message, objects)
end

def complete=(value, complete_at)
  value = value.to_b
  self.complete_at = complete_at if complete && value
  self.complete_at = nil unless value
end

gem 'wirble', :group => :development
gem 'wirble', group: :development
gem 'rest-client', require: 'rest_client'

#1 
  class A
    module B
      include C
    end
  end

#2
module A
  class B
    class << self
      include C
    end
  end
end

Object.new.methods
# => [:tap, :public_send, :instance_variables, :instance_variable_set, :instance_variable_defined?, :remove_instance_variable, :private_methods, :kind_of?, :is_a?, :instance_variable_get, :instance_of?, :public_method, :extend, :define_singleton_method, :singleton_method, :to_enum, :enum_for, :<=>, :===, :=~, :!~, :eql?, :respond_to?, :freeze, :inspect, :display, :object_id, :send, :to_s, :method, :nil?, :hash, :class, :singleton_class, :clone, :dup, :itself, :taint, :tainted?, :untaint, :untrust, :trust, :untrusted?, :methods, :protected_methods, :frozen?, :public_methods, :singleton_methods, :!, :==, :!=, :__send__, :equal?, :instance_eval, :instance_exec, :__id__]

validates :year, numericality: { only_integer: true }, 
  inclusion: { in: Date.current.year - 1..Date.current.year + 2 }

[
  Date.today - RATE_CHANGES_DAYS, 
  Date.today + RATE_CHANGES_DAYS
]

def initialize
  @used_year = settings[:year] || Date.current.year
  @used_quarter = settings[:quarter] || quarter(Date.current)
end

Import.where(begin_date: Date.today, end_date: Date.today).first_or_create!

scope :active, -> { where(completed_at: nil) } # good
scope :active, -> { where(tasks: { completed_at: nil }) } # better

# ducalis:disable: use `delete_all` because of performance reasons
def remove_garbage
  AuditLog.where(user_id: user_id).delete_all
end

hash[:name] || DEFAULT_NAME
# to
hash.fetch(:name. DEFAULT_NAME)
# or
hash.fetch(:name) { DEFAULT_NAME }

/json|yaml/
/(>=)|(<=)|(~>)|(>)|(<)|(=)/
/Access Denied/
%r{^/(book|chapter)}

ALLOWED_FORMATS = %w[json yaml] && Regexp.union(ALLOWED_FORMATS)
OPERATORS = %w(>= <= > < =) && Regexp.new(OPERATORS.map { |key| "(#{key})" }.join('|'))
'bookshelf'.include?('book')
Regexp.new("^/(#{%w(book chapter).join('|')})")

require 'benchmark/ips'

SUBJECT = 'bookshelf.xml'

LONG_FORMATS      = %w[json yaml xml]
LONG_PURE_REGEX   = /json|yaml|xml/
LONG_UNION_REGEX  = Regexp.union(LONG_FORMATS)
LONG_FORMAT_REGEX = Regexp.new(LONG_FORMATS.join('|'))

Benchmark.ips do |x|
  puts '(n > 2)'
  x.report("regex mode") { SUBJECT =~ LONG_FORMAT_REGEX }
  x.report("union mode") { SUBJECT =~ LONG_UNION_REGEX }
  x.report("pure regex mode") { SUBJECT =~ LONG_PURE_REGEX }
  x.report("include mode") do
    LONG_FORMATS.any? { |format| SUBJECT.include?(format) }
  end
  x.compare!
end

SHORT_FORMATS      = %w[xml json]
SHORT_PURE_REGEX   = /xml|json/
SHORT_UNION_REGEX  = Regexp.union(SHORT_FORMATS)
SHORT_FORMAT_REGEX = Regexp.new(SHORT_FORMATS.join('|'))

Benchmark.ips do |x|
  puts '(n <= 2)'
  x.report("regex mode") { SUBJECT =~ SHORT_FORMAT_REGEX }
  x.report("union mode") { SUBJECT =~ SHORT_UNION_REGEX }
  x.report("pure regex mode") { SUBJECT =~ SHORT_PURE_REGEX }
  x.report("include mode") do
    SHORT_FORMATS.any? { |format| SUBJECT.include?(format) }
  end
  x.compare!
end

def filtered_admins(reducers)
  reducers
    .map { |reducer| @base_scope.public_send(reducer) }
    .order("admin_users.created_at DESC")
end

day = params[:day] || Time.zone.today

params.fetch(:day) { Time.zone.today }

params = {}
params[:day] || Time.zone.today #=> Time.zone.today result

params = { day: nil }
params.fetch(:day) { Time.zone.today } #=> nil