mnishiguchi/ruby_poro.md

## ruby_poro.md

      
    Raw
  

              ruby_poro.md
            
          
    Ruby Poros, tableless models, service objects


RubyHack 2019 - The Circle of Lifecycle Events by Nelson Wittwer
7 Patterns to Refactor Fat ActiveRecord Models

tableless model


We can optionnally use cgriego/active_attr
ActiveModel::Attributes が最高すぎるんだよな。 - Qiita

PORO

module Feeds
  class Property
    
    @@attribute_names = [
      :name,
      :latitude,
      :longitude,
      :street,
      :city,
      :state,
      :floorplan,
    ]

    attr_accessor *@@attribute_names

    # https://stackoverflow.com/questions/12763016/how-to-cleanly-initialize-attributes-in-ruby-with-new
    def initialize(params = {})
      @@attribute_names.each do |attr|
        instance_variable_set("@#{attr}", params[attr]) if params[attr]
      end
    end

    # Returns a hash of all the attributes with their names as keys and the values of the attributes as values.
    def attributes
      Hash[@@attribute_names.map { |name| [name, self.send(name)] }]
    end
  end
end
      def attributes
        instance_variables.map{ |ivar| instance_variable_get ivar }
      end
ActiveModel::Model

class ContactForm
  include ActiveModel::Model

  ATTRIBUTE_NAMES = %i[
    name
    phone
    email
    message
    subscribe
  ].freeze

  attr_accessor(*ATTRIBUTE_NAMES)

  validates :name, presence: true, length: { maximum: 50 }
  validates :email, length: { maximum: 255 }, format: { with: /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i }

  # Error messages are available after valid? is called
  def submit
    if valid?
      true
    else
      false
    end
  end

  # Returns a hash of all the attributes with their names as keys and the values of the attributes as values.
  def attributes
    Hash[ATTRIBUTE_NAMES.map { |name| [name, send(name)] }]
  end
end
Form object


https://medium.com/selleo/essential-rubyonrails-patterns-form-objects-b199aada6ec9
https://github.com/trailblazer/reform

Service object


A Comprehensive Guide to Rails Service Objects
nebulab/simple_command
RubyConf 2016 - Composition by James Dabbs
Anatomy of a Rails Service Object

class ApplicationService
  def call
    raise NotImplementedError
  end

  def self.call(*args, &block)
    new(*args, &block).call
  end
end
Virtual attribute with PORO

class GeoLocation
  module AttrAccessors
    module Bbox
      extend ActiveSupport::Concern

      included do
        def bbox
          BoundingBox.new(north: bbox_north, south: bbox_south, east: bbox_east, west: bbox_west)
        end

        def bbox=(bbox_instance)
          %i[west south east north].each do |x|
            raise ArgumentError, "must respond to #{x}" unless bbox_instance.respond_to?(x)
          end
          self.bbox_north = bbox_instance.north
          self.bbox_south = bbox_instance.south
          self.bbox_east = bbox_instance.east
          self.bbox_west = bbox_instance.west
        end
      end
    end
  end
end
ActiveRecord model with PORO sub-model

# migration
class CreateCallEvents < ActiveRecord::Migration[5.2]
  def change
    create_table :call_events do |t|
      t.jsonb :raw_data

      t.string :call_sid, null: false

      t.string :caller_phone, null: false
      t.string :caller_city
      t.string :caller_state
      t.string :caller_zipcode

      t.string :called_phone, null: false
      t.string :called_city
      t.string :called_state
      t.string :called_zipcode

      t.timestamps
    end
  end
end
# model
# A call event from Twilio Webhook
class CallEvent < ApplicationRecord
  validates :raw_data, :call_sid, :caller_phone, :called_phone, presence: true
  validates :call_sid, uniqueness: { case_sensitive: false }

  [:caller, :called].each do |caller_or_called|
    define_method caller_or_called do
      # getter
      CallEvent::Phone.new(
        phone: send("#{caller_or_called}_phone"),
        city: send("#{caller_or_called}_city"),
        state: send("#{caller_or_called}_state"),
        zipcode: send("#{caller_or_called}_zipcode")
      )
    end

    # setter
    define_method "#{caller_or_called}=" do |call_event_phone|
      raise ArgumentError, "must respond to phone" unless call_event_phone.respond_to?(:phone)

      self["#{caller_or_called}_phone"] = call_event_phone.phone
      self["#{caller_or_called}_city"] = call_event_phone.city
      self["#{caller_or_called}_state"] = call_event_phone.state
      self["#{caller_or_called}_zipcode"] = call_event_phone.zipcode
    end
  end

  # sub-model for caller and called
  class Phone
    attr_reader :phone, :city, :state, :zipcode

    def initialize(phone:, city: nil, state: nil, zipcode: nil)
      @phone = phone
      @city = city
      @state = state
      @zipcode = zipcode
    end

    def to_s
      phone
    end
  end
end
    private def create_call_event
      CallEvent.create!(
        raw_data: raw_data,
        call_sid: raw_data["CallSid"],
        caller: caller_info,
        called: called_info
      )
    end

    private def caller_info
      CallEvent::Phone.new(
        phone: raw_data["From"] || raw_data["Called"],
        city: raw_data["FromCity"] || raw_data["CalledCity"],
        state: raw_data["FromState"] || raw_data["CalledState"],
        zipcode: raw_data["FromZip"] || raw_data["CalledZip"]
      )
    end

    private def called_info
      CallEvent::Phone.new(
        phone: raw_data["To"] || raw_data["Called"],
        city: raw_data["ToCity"] || raw_data["CalledCity"],
        state: raw_data["ToState"] || raw_data["CalledState"],
        zipcode: raw_data["ToZip"] || raw_data["CalledZip"]
      )
    end

    private def raw_data
      @raw_data ||= params.permit(*PERMITTED_PARAM_KEYS).to_h.with_indifferent_access
    end