thoughtbot--factory_bot/lib/factory_girl/attribute/dynamic.rb

module FactoryGirl
  class Attribute
    # @api private
    class Dynamic < Attribute
      def initialize(name, ignored, block)
        super(name, ignored)
        @block = block
      end

      def to_proc
        block = @block

        -> {
          value = block.arity == 1 ? instance_exec(self, &block) : instance_exec(&block)
          raise SequenceAbuseError if FactoryGirl::Sequence === value
          value
        }
      end
    end
  end
end
Moved definition loading syntax out of the factory class; moved everything into a FactoryGirl module 2010-06-24 09:45:57 -04:00			`module FactoryGirl`
Clean up documentation 2012-05-05 02:31:31 -04:00			`class Attribute`
			`# @api private`
			`class Dynamic < Attribute`
Change syntax for ignoring attributes to use block syntax instead of calling ignore on individual declarations. Old syntax: factory :user do rockstar(true).ignore four { 2 + 2 }.ignore name { "John Doe#{" - Rockstar" if rockstar}" } end New syntax: factory :user do ignore do rockstar true four { 2 + 2 } end name { "John Doe#{" - Rockstar" if rockstar}" } end 2011-10-07 18:19:27 -04:00			`def initialize(name, ignored, block)`
			`super(name, ignored)`
Split static and dynamic attributes into separate classes 2009-01-02 17:33:00 -05:00			`@block = block`
			`end`

Move class creation/handling to an anonymous evaluator This allows for Attribute#to_proc to not require a proxy to be passed to return a Proc. It also allows for removal of Attribute#add_to 2011-11-29 15:20:08 -05:00			`def to_proc`
Attributes have a to_proc method and are lazily evaluated on an anonymous class 2011-11-22 18:01:01 -05:00			`block = @block`
Change syntax for ignoring attributes to use block syntax instead of calling ignore on individual declarations. Old syntax: factory :user do rockstar(true).ignore four { 2 + 2 }.ignore name { "John Doe#{" - Rockstar" if rockstar}" } end New syntax: factory :user do ignore do rockstar true four { 2 + 2 } end name { "John Doe#{" - Rockstar" if rockstar}" } end 2011-10-07 18:19:27 -04:00
Use Ruby 1.9's stabby lambdas 2012-04-20 16:59:39 -04:00			`-> {`
Use instance_exec passing self as an argument for dynamic attributes Calling `block.call(self)` means any implied scope of block evaluation goes out the window when an arity of 1 is used. This change uses `instance_exec`, passing along self as the argument for the block variable, meaning that the block is still invoked within the context of the FactoryGirl::Evaluator while allowing the variable to have access to the evaluator. Closes #529 2013-06-07 10:42:50 -04:00			`value = block.arity == 1 ? instance_exec(self, &block) : instance_exec(&block)`
Attributes have a to_proc method and are lazily evaluated on an anonymous class 2011-11-22 18:01:01 -05:00			`raise SequenceAbuseError if FactoryGirl::Sequence === value`
			`value`
			`}`
Split static and dynamic attributes into separate classes 2009-01-02 17:33:00 -05:00			`end`
			`end`
			`end`
			`end`