# scenario in a feature file
Given a person named "Mischa"

# step matcher in a ruby steps file
Given /^a person named "(.*)"$/ do |name|
  @person = Person.make(:name => name)
end

# blueprints.rb, usually put in rails_root/spec, or wherever you want.
Person.blueprint do 
  name {"Example name"}
  birthday {Time.now}
  hair_color {"Brown"}
end

module Machinist
  
  module ActiveRecord
    
    module Extensions

      def self.included(base)
        base.extend(ClassMethods)
      end
    
      module ClassMethods
        # this gives us:
        # Model.blueprint do
        # end 
        def blueprint(name = :master, &blueprint) #default the name to a sybmol, take the block
          @blueprints ||= {}  # initialize a hash of possible blueprints for the model
          @blueprints[name] = blueprint if block_given?  # store the block in the hash
          @blueprints[name] # return the block
        end
  

        # This gives us:
        # Model.make do 
        # end
        def make(*args, &block)
          lathe = Lathe.run(self.new, *args)  # pass a new instance of self (e.g. Post.new) to Lathe
          lathe.object.save!   #actually save the object, using a bang to fail early
          lathe.object.reload  #reload to get everything
          lathe.object(&block) # if there was a block
        end

      end
    end
  
  end
end


class ActiveRecord::Base
  include Machinist::ActiveRecord::Extensions #...
end

Post.blueprint do # passing a block, which gets evaluated inside the lathe
  title {"hi"} # inside the block, calling a method on a lathe that won't be defined (title)
  author {"mischa"} # passing a block to the method on lathe that won't be defined
end

require 'machinist/active_record' # we just looked at this

module Machinist

  # A Lathe is used to execute the blueprint and construct an object.
  # The blueprint is instance_eval'd against the Lathe.
  class Lathe
    def self.run(object, *args) #so, object here is a model instance (E.g. @post = Post.new)
      blueprint       = object.class.blueprint # get the main blueprint for the class (which is a block)
      attributes = args.pop || {} # get the attributes from the args. E.g. :name => "Titus"

     # now, returning a new lathe evaluate the block that we passed in with Model.blueprint
      returning self.new(object, attributes) do |lathe| #the .new method sends us to initialize
        lathe.instance_eval(&blueprint) #So, if I call name, then name will get send to method missing
      end
    end
    

   # so, initialize is called in in Lathe.run, after we have the attributes
   # the purpose of initialize is to set the values for the attributes that we specify in Make
   # so, if I call Post.make(:title => "Mischa's post"), then the name of the post will get set here.
    def initialize(object, attributes = {})
      @object = object #assign ivars
      @assigned_attributes = {}
      attributes.each do |key, value|  #for each of the attributes
        @object.send("#{key}=", value)  # set the value
        @assigned_attributes[key.to_sym] = value 
      end
    end
    
    # this returns the instance of the model
    def object
      yield @object if block_given?
      @object
    end
    
    attr_reader :assigned_attributes
    
    # method missing is going to get called when we say lathe.instance_eval(&blueprint)
   # the purpose of method missing, here, is to dynamically set the attributes
   # that we don't specify in Post.make
    
   # So, if we had a blueprint that was like:
   # Post.blueprint do 
   #   name {"hi"}
   #   date {Time.now}
   # end
   # and we called Post.name(:name => "foo")
   # both name and date would hit method missing for the lathe,
   # and then just get sent to the object (the post) itself.

    def method_missing(symbol, *args, &block)
      if @assigned_attributes.has_key?(symbol)  # if we've passed an attribute to make
        @object.send(symbol)  # just send it
      else # if we have to dynamically generate the attribute
         # send it with the generated attribute
        @object.send("#{symbol}=", generate_attribute(symbol, args, &block)) 
      end
    end
    
   # This is a simplified version of how machinist generates attributes
   # simplified enough to require no explanation, I think
    def generate_attribute(attribute, args)
      value = if block_given?
        yield
      else
        args.first
      end
      @assigned_attributes[attribute] = value
    end
    
  end
end