pardner

# Decorate an ActiveRecord or ActiveModel class by creating a subclass
# of Pardner::Base. In this example we'll pretend a User active record
# class exists.

class SilverMiner < Pardner::Base
  howdy_pardner User
end

# Instantiate it by calling `.new` and passing in a User object:
miner = SilverMiner.new User.find(123)
miner.new_record? # => true
miner.id          # => 123

# Behavior can be added to the decorator by defining methods:
class SilverMiner < Pardner::Base
  # Add the title 'Silver miner' to the user name
  def name
    "Silver miner #{super}"
  end
end

miner.name # => 'Silver miner Sam'

# by adding callbacks:
class SilverMiner < Pardner::Base
  before_destroy :retirement_party

  private

  def retirement_party
    years_worked = Time.now.year - self.start_year
    Cake.create! candles_count: years_worked
  end
end

miner.destroy # creates a Cake

# by adding validations:
class SilverMiner < Pardner::Base
  validates_inclusion_of :favorite_ore, in: ['silver']
end

miner.favorite_ore = 'gold'
miner.valid?     # => false

# app/models/conestoga_wagon.rb
# The table has columns is_covered:boolean and wheels_count:integer
class ConestogaWagon < ActiveRecord::Base
end

# app/presenters/conestoga_wagon_presenter.rb
class ConestogaWagonPresenter < Pardner::Base
  howdy_pardner ConestogaWagon

  def description
    covered_string = is_covered ? "covered" : "uncovered"
    "a #{wheels_count} wheeled #{covered_string} wagon"
  end
end

# app/controllers/conestoga_wagons_controller.rb
class ConestogaWagonsController < ApplicationController
  def show
    @wagon = ConestogaWagonPresenter.new ConestogaWagon.find(params[:id])
  end
end

    # app/models/gold_rush.rb
    # The table gold_rushes has columns city:string and territory:string
    class GoldRush < ActiveRecord::Base
    end

    # app/decorators/gold_rush_form.rb
    class GoldRushForm < Pardner::Base
      howdy_pardner GoldRush

      def location
        "#{city}, #{territory}"
      end

      def location=(val)
        self.city, self.territory = val.split ','
      end
    end

    # app/controllers/gold_rushes_controller.rb
    class GoldRushesController < ApplicationController
      def new
        @gold_rush = GoldRushForm.new GoldRush.new
      end

      def create
        @gold_rush = GoldRushForm.new GoldRush.new
        @gold_rush.attributes = params[:gold_rush]

        if @gold_rush.save
          flash[:notice] = "There's gold in them thar hills"
        else
          render :new
        end
      end
    end

# app/controllers/gold_rushes_controller.rb
class GoldRushesController < ApplicationController
  def create
    @gold_rush = GoldRushDeclared.new GoldRush.new
    @gold_rush.attributes = params[:gold_rush]

    if @gold_rush.save
      flash[:notice] = "There's gold in them thar hills"
    else
      render :new
    end
  end
end

# app/services/gold_rush_declared.rb
class GoldRushDeclared < Pardner::Base
  howdy_pardner GoldRush
  before_validate :build_infrastructure
  validate :mining_town_must_exist
  validate :transport_must_exist

  private

  def build_infrastructure
    if MiningTown.where(territory: self.territory).is_nearby(self).empty?
      MiningTown.create! territory: self.territory, name: "Town near #{self.name}"
    end

    if Railroad.is_nearby(self).empty? && WagonTrail.is_nearby(self).empty?
      WagonTrail.create! territory: self.territory, destination: self.location
    end
  end

  def mining_town_must_exist
    return if MiningTown.is_nearby(self)
    errors.add :base, 'no mining town exists'
  end

  def transport_must_exist
    return if Railroad.is_nearby(self) || WagonTrail.is_nearby(self)
    errors.add :base, 'no transport exists'
  end
end

# app/decorators/small_posse.rb
class SmallPosse < Pardner::Base
  howdy_pardner Posse
  validate :must_be_small

  MAX_SIZE = 5

  private

  def must_be_small
    if deputies_count > MAX_SIZE
      errors.add :deputies, "must be less than #{MAX_SIZE}"
    end
  end
end

# app/controllers/posses_controller.rb
class PossesController < ApplicationController
  def create
    # This controller is customer facing so they can only create small posses
    @posse = SmallPosse.new Posse.new
    @posse.attributes = params[:posse]

    if @posse.save
      flash[:notice] = 'Get a rope'
    else
      render :new
    end
  end
end

# app/controllers/admin/posses_controller.rb
module Admin
  class PossesController < ApplicationController
    def create
      # This controller is for admins so they can do what they want
      @posse = Posse.new params[:posse]

      if @posse.save
        flash[:notice] = 'Every day above ground is a good day'
      else
        render :new
      end
    end
  end
end

gem 'pardner'