challah 0.5.2 → 0.5.3

data/vendor/bundle/gems/factory_girl-3.0.0/lib/factory_girl/callback.rb

@@ -0,0 +1,33 @@
+module FactoryGirl
+  class Callback
+    attr_reader :name, :block
+
+    def initialize(name, block)
+      @name  = name.to_sym
+      @block = block
+      check_name
+    end
+
+    def run(instance, evaluator)
+      case block.arity
+      when 1 then block.call(instance)
+      when 2 then block.call(instance, evaluator)
+      else block.call
+      end
+    end
+
+    def ==(other)
+      name == other.name &&
+        block == other.block
+    end
+
+    private
+
+    def check_name
+      unless FactoryGirl.callback_names.include?(name)
+        raise InvalidCallbackNameError, "#{name} is not a valid callback name. " +
+          "Valid callback names are #{FactoryGirl.callback_names.inspect}"
+      end
+    end
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/lib/factory_girl/declaration.rb

@@ -0,0 +1,22 @@
+require "factory_girl/declaration/static"
+require "factory_girl/declaration/dynamic"
+require "factory_girl/declaration/association"
+require "factory_girl/declaration/implicit"
+
+module FactoryGirl
+  class Declaration
+    attr_reader :name
+
+    def initialize(name, ignored = false)
+      @name    = name
+      @ignored = ignored
+    end
+
+    def to_attributes
+      build
+    end
+
+    protected
+    attr_reader :ignored
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/lib/factory_girl/declaration/association.rb

@@ -0,0 +1,25 @@
+module FactoryGirl
+  class Declaration
+    class Association < Declaration
+      def initialize(name, options)
+        super(name, false)
+        @options = options
+      end
+
+      def ==(other)
+        name == other.name &&
+          options == other.options
+      end
+
+      protected
+      attr_reader :options
+
+      private
+
+      def build
+        factory_name = @options.delete(:factory) || name
+        [Attribute::Association.new(name, factory_name, @options)]
+      end
+    end
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/lib/factory_girl/declaration/dynamic.rb

@@ -0,0 +1,25 @@
+module FactoryGirl
+  class Declaration
+    class Dynamic < Declaration
+      def initialize(name, ignored = false, block = nil)
+        super(name, ignored)
+        @block = block
+      end
+
+      def ==(other)
+        name == other.name &&
+          ignored == other.ignored &&
+          block == other.block
+      end
+
+      protected
+      attr_reader :block
+
+      private
+
+      def build
+        [Attribute::Dynamic.new(name, @ignored, @block)]
+      end
+    end
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/lib/factory_girl/declaration/implicit.rb

@@ -0,0 +1,32 @@
+module FactoryGirl
+  class Declaration
+    class Implicit < Declaration
+      def initialize(name, factory = nil, ignored = false)
+        super(name, ignored)
+        @factory = factory
+      end
+
+      def ==(other)
+        name == other.name &&
+          factory == other.factory &&
+          ignored == other.ignored
+      end
+
+      protected
+      attr_reader :factory
+
+      private
+
+      def build
+        if FactoryGirl.factories.registered?(name)
+          [Attribute::Association.new(name, name, {})]
+        elsif FactoryGirl.sequences.registered?(name)
+          [Attribute::Sequence.new(name, name, @ignored)]
+        else
+          @factory.inherit_traits([name])
+          []
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/lib/factory_girl/declaration/static.rb

@@ -0,0 +1,25 @@
+module FactoryGirl
+  class Declaration
+    class Static < Declaration
+      def initialize(name, value, ignored = false)
+        super(name, ignored)
+        @value = value
+      end
+
+      def ==(other)
+        name == other.name &&
+          value == other.value &&
+          ignored == other.ignored
+      end
+
+      protected
+      attr_reader :value
+
+      private
+
+      def build
+        [Attribute::Static.new(name, @value, @ignored)]
+      end
+    end
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/lib/factory_girl/declaration_list.rb

@@ -0,0 +1,48 @@
+module FactoryGirl
+  class DeclarationList
+    include Enumerable
+
+    def initialize(name = nil)
+      @declarations = []
+      @name         = name
+      @overridable  = false
+    end
+
+    def declare_attribute(declaration)
+      delete_declaration(declaration) if overridable?
+
+      @declarations << declaration
+      declaration
+    end
+
+    def overridable
+      @overridable = true
+    end
+
+    def attribute_list
+      AttributeList.new(@name).tap do |list|
+        to_attributes.each do |attribute|
+          list.define_attribute(attribute)
+        end
+      end
+    end
+
+    def each(&block)
+      @declarations.each(&block)
+    end
+
+    private
+
+    def delete_declaration(declaration)
+      @declarations.delete_if {|decl| decl.name == declaration.name }
+    end
+
+    def to_attributes
+      @declarations.inject([]) {|result, declaration| result += declaration.to_attributes }
+    end
+
+    def overridable?
+      @overridable
+    end
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/lib/factory_girl/definition.rb

@@ -0,0 +1,76 @@
+module FactoryGirl
+  class Definition
+    attr_reader :callbacks, :defined_traits, :declarations, :constructor
+
+    def initialize(name = nil, base_traits = [])
+      @declarations      = DeclarationList.new(name)
+      @callbacks         = []
+      @defined_traits    = []
+      @to_create         = lambda {|instance| instance.save! }
+      @base_traits       = base_traits
+      @additional_traits = []
+      @constructor       = nil
+    end
+
+    delegate :declare_attribute, to: :declarations
+
+    def attributes
+      @attributes ||= declarations.attribute_list
+    end
+
+    def compile
+      attributes
+    end
+
+    def processing_order
+      base_traits + [self] + additional_traits
+    end
+
+    def overridable
+      declarations.overridable
+      self
+    end
+
+    def inherit_traits(new_traits)
+      @additional_traits += new_traits
+    end
+
+    def add_callback(callback)
+      @callbacks << callback
+    end
+
+    def to_create(&block)
+      if block_given?
+        @to_create = block
+      else
+        @to_create
+      end
+    end
+
+    def define_trait(trait)
+      @defined_traits << trait
+    end
+
+    def define_constructor(&block)
+      @constructor = block
+    end
+
+    private
+
+    def base_traits
+      @base_traits.map { |name| trait_by_name(name) }
+    end
+
+    def additional_traits
+      @additional_traits.map { |name| trait_by_name(name) }
+    end
+
+    def trait_by_name(name)
+      trait_for(name) || FactoryGirl.trait_by_name(name)
+    end
+
+    def trait_for(name)
+      defined_traits.detect {|trait| trait.name == name }
+    end
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/lib/factory_girl/definition_proxy.rb

@@ -0,0 +1,159 @@
+module FactoryGirl
+  class DefinitionProxy
+    UNPROXIED_METHODS = %w(__send__ __id__ nil? send object_id extend instance_eval initialize block_given? raise)
+
+    (instance_methods + private_instance_methods).each do |method|
+      undef_method(method) unless UNPROXIED_METHODS.include?(method.to_s)
+    end
+
+    attr_reader :child_factories
+
+    def initialize(definition, ignore = false)
+      @definition      = definition
+      @ignore          = ignore
+      @child_factories = []
+    end
+
+    # Adds an attribute that should be assigned on generated instances for this
+    # factory.
+    #
+    # This method should be called with either a value or block, but not both. If
+    # called with a block, the attribute will be generated "lazily," whenever an
+    # instance is generated. Lazy attribute blocks will not be called if that
+    # attribute is overridden for a specific instance.
+    #
+    # When defining lazy attributes, an instance of FactoryGirl::Strategy will
+    # be yielded, allowing associations to be built using the correct build
+    # strategy.
+    #
+    # Arguments:
+    # * name: +Symbol+ or +String+
+    #   The name of this attribute. This will be assigned using "name=" for
+    #   generated instances.
+    # * value: +Object+
+    #   If no block is given, this value will be used for this attribute.
+    def add_attribute(name, value = nil, &block)
+      raise AttributeDefinitionError, "Both value and block given" if value && block_given?
+
+      declaration = if block_given?
+        Declaration::Dynamic.new(name, @ignore, block)
+      else
+        Declaration::Static.new(name, value, @ignore)
+      end
+
+      @definition.declare_attribute(declaration)
+    end
+
+    def ignore(&block)
+      proxy = DefinitionProxy.new(@definition, true)
+      proxy.instance_eval(&block)
+    end
+
+    # Calls add_attribute using the missing method name as the name of the
+    # attribute, so that:
+    #
+    #   factory :user do
+    #     name 'Billy Idol'
+    #   end
+    #
+    # and:
+    #
+    #   factory :user do
+    #     add_attribute :name, 'Billy Idol'
+    #   end
+    #
+    # are equivalent.
+    #
+    # If no argument or block is given, factory_girl will look for a sequence
+    # or association with the same name. This means that:
+    #
+    #   factory :user do
+    #     email { create(:email) }
+    #     association :account
+    #   end
+    #
+    # and:
+    #
+    #   factory :user do
+    #     email
+    #     account
+    #   end
+    #
+    # are equivalent.
+    def method_missing(name, *args, &block)
+      if args.empty? && block.nil?
+        @definition.declare_attribute(Declaration::Implicit.new(name, @definition, @ignore))
+      elsif args.first.is_a?(Hash) && args.first.has_key?(:factory)
+        association(name, *args)
+      elsif FactoryGirl.callback_names.include?(name)
+        @definition.add_callback(Callback.new(name, block))
+      else
+        add_attribute(name, *args, &block)
+      end
+    end
+
+    # Adds an attribute that will have unique values generated by a sequence with
+    # a specified format.
+    #
+    # The result of:
+    #   factory :user do
+    #     sequence(:email) { |n| "person#{n}@example.com" }
+    #   end
+    #
+    # Is equal to:
+    #   sequence(:email) { |n| "person#{n}@example.com" }
+    #
+    #   factory :user do
+    #     email { FactoryGirl.create(:email) }
+    #   end
+    #
+    # Except that no globally available sequence will be defined.
+    def sequence(name, start_value = 1, &block)
+      sequence = Sequence.new(name, start_value, &block)
+      add_attribute(name) { sequence.next }
+    end
+
+    # Adds an attribute that builds an association. The associated instance will
+    # be built using the same build strategy as the parent instance.
+    #
+    # Example:
+    #   factory :user do
+    #     name 'Joey'
+    #   end
+    #
+    #   factory :post do
+    #     association :author, factory: :user
+    #   end
+    #
+    # Arguments:
+    # * name: +Symbol+
+    #   The name of this attribute.
+    # * options: +Hash+
+    #
+    # Options:
+    # * factory: +Symbol+ or +String+
+    #    The name of the factory to use when building the associated instance.
+    #    If no name is given, the name of the attribute is assumed to be the
+    #    name of the factory. For example, a "user" association will by
+    #    default use the "user" factory.
+    def association(name, options = {})
+      @definition.declare_attribute(Declaration::Association.new(name, options))
+    end
+
+    def to_create(&block)
+      @definition.to_create(&block)
+    end
+
+    def factory(name, options = {}, &block)
+      @child_factories << [name, options, block]
+    end
+
+    def trait(name, &block)
+      @definition.define_trait(Trait.new(name, &block))
+    end
+
+    def initialize_with(&block)
+      @definition.define_constructor(&block)
+    end
+  end
+end