inopinatus

class MyConfiguration < BasicObject
  def method_missing name, *args
    getter = name.end_with?(?=) ? name[0..-2] : name
    (class << self; self end).class_eval { attr_accessor getter }
    __send__ name, *args
  end
end

config = MyConfiguration.new
config.liverpool = 4

inopinatus

# frozen_string_literal: true

# In this example we have an application concerned about the length of a string,
# and is pushing the work to the database for efficiency.  There is an index
# on the length of a Post's title, and the scopes and orderings have been 
# neatly refactored to minimise the amount of Arel required.
#
# A bug has now arisen in the behaviour of `last`.  It is giving the first.
#
# Subsequent investigation has shown that customers were also complaining that

inopinatus

# frozen_string_literal: true

class WorkAllocation
  # Runtime process allocations. Last reviewed: 24/9/2019

  # Half a gig system allocation for agents and monitors and, unfortunately,
  # a couple of deploy-time asset compiles due to dependencies.  It's
  # okay to push some processes into swap on smaller instances during
  # deploy.   Ideally we wouldn't compile on-instance at all.
  OPS_MEMORY_ALLOWANCE = 512

inopinatus

# app/models/concerns/exceeding.rb
module Exceeding
  extend ActiveSupport::Concern

  included do
    scope :exceeds, ->(association, n) do
      joins(association).group(primary_key).having(arel_table[primary_key].count.gteq n)
    end
  end
end

inopinatus

# app/lib/adderall.rb
module Adderall
  def adderall(column_name, relation = self, filter = :itself)
    owner = proxy_association.owner
    records = proxy_association.target

    if loaded? || owner.new_record?
      relation = none
    else
      records = records.select(&:new_record?)

inopinatus

Inequality	Interval	Ruby range	Active Record¹	Arel²	Description
x >= a	[a, ∞)	a..	where(x: a..)	x.gteq(a)	Right unbounded closed
x > a	(a, ∞)	n/a	where.not(x: ..a)	x.gt(a)	Right unbounded open
x <= a	(-∞, a]	..a	where(x: ..a)	x.lteq(a)	Left unbounded closed
x < a	(-∞, a)	...a	where(x: ...a)	x.lt(a)	Left unbounded open
a <= x <= b	[a, b]	a..b	where(x: a..b)	x.between(a..b)	Closed
a < x < b	(a, b)	n/a	where.not(x: ..a).where(x: ...b)	x.gt(a).and(x.lt(b))	Open
a <= x < b	[a, b)	a...b	where(x: a...

inopinatus

module ByMost
  extend ActiveSupport::Concern

  included do
    scope :by_most, ->(assoc) {
      reflection = reflect_on_association(assoc)
      left_joins(assoc)
        .group(primary_key)
        .order(reflection.klass.arel_table[reflection.foreign_key].count.desc)
    }

inopinatus

module DigestQueries
  def predicate_builder
    @predicate_builder ||= super.tap do |pb|
      pb.register_handler(Digest::Instance, DigestHandler.new(pb))
    end
  end

  class DigestHandler
    def initialize(predicate_builder)
      @predicate_builder = predicate_builder

inopinatus

module FrequencyExtension
  def most_frequent
    frequency_order.take
  end

  def frequency_order
    group(arel_attribute(primary_key).order(arel_attribute(primary_key).count.desc)
  end
end

inopinatus

y = ->(f) {
  ->(x) { x.(x) }.(
  ->(x) { f.(->(v) { x.(x).(v) }) } )
}

fib = y.(->(f) {
  ->(n) { n < 2 ? Array(0..n) : f[n-1].then {  _1 << _1[-1] + _1[-2] } }
})

fib[6] #=> [0, 1, 1, 2, 3, 5, 8]