elskwid

class SampleContracts
  BASE_PATH = "downloads/sample_contracts/"

  Contract = Struct.new(:type, :name, :title) do
    # Struct responds to .call so it can be used for Enumerable.find(ifnone)
    def self.call
      new
    end

    # By adding this method we get a struct that plays nicely with destructuring

elskwid

class A
  def initialize
    @lambda = ->(x) { puts "lambda: #{x}" }
    @proc   = Proc.new { |x| puts "proc: #{x}" }
    @method = method(:_method)
  end

  def lambda(x)
    @lambda[x]
  end

elskwid

module Enuma

  def enumerated(type_name, *members, &block)
    @enums      = []
    type_class  = const_set(type_name, Enuma::Type.new(*members))

    instance_eval(&block)

    finalize(@enums, type_class)
  end

elskwid

# define
class Object
  def cascade(method_name, *args, &block)
    self.send(method_name, *args, &block)
    self
  end

  # catch the cascade
  def method_missing(method_name, *args, &block)
    sig = /^__/

elskwid

# Example:
#
# class EditForm < FormModel
#   model :a
#
#   attribute :title, String
#
#   validates :title, presence: true
# end
#

elskwid

require "virtus"

class Teacher
  include Virtus::ValueObject

  attribute :id, String

  def self.inherited(descendant)
    super

elskwid

require "mechanize"

# we need some methods to clean this up so make it a class

class InspectionScraper

  BASE_URL         = "http://eats.washoecounty.us/"
  FACILITY_COLS    = ["link", "name", "score", "facility_type", "address", "inspection_date"]
  RESULTS_TABLE_ID = "table#ctl00_ContentPlaceHolder1_grdHealth"

elskwid

class SomeTypes
  @all = [
    ["TypeA",  "Type A"],
    ["Type B", "Type B"],
  ]

  Type = Struct.new(:type, :name, :slug, :sym) do
    alias_method :to_ary, :to_a

    # allows Type to be used for ifnone option in .find

elskwid

module Entity
  include Virtus.module
  
  attribute :id, Integer

  def persisted?
    !id.nil?
  end
end

elskwid

# An attempt to codify how we're using Service Objects now
#
# Most follow this pattern:
#
#  class SomeService
#
#    def self.call(a, b, &block)
#      new(a, b).call(&block)
#    end
#