challah 0.5.2 → 0.5.3

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

@@ -0,0 +1,19 @@
+module FactoryGirl
+  # Raised when a factory is defined that attempts to instantiate itself.
+  class AssociationDefinitionError < RuntimeError; end
+
+  # Raised when a callback is defined that has an invalid name
+  class InvalidCallbackNameError < RuntimeError; end
+
+  # Raised when a factory is defined with the same name as a previously-defined factory.
+  class DuplicateDefinitionError < RuntimeError; end
+
+  # Raised when attempting to register a sequence from a dynamic attribute block
+  class SequenceAbuseError < RuntimeError; end
+
+  # Raised when defining an invalid attribute:
+  # * Defining an attribute which has a name ending in "="
+  # * Defining an attribute with both a static and lazy value
+  # * Defining an attribute twice in the same factory
+  class AttributeDefinitionError < RuntimeError; end
+end

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

@@ -0,0 +1,76 @@
+require "active_support/core_ext/hash/except"
+require "active_support/core_ext/class/attribute"
+
+module FactoryGirl
+  class Evaluator
+    class_attribute :callbacks, :attribute_lists
+
+    def self.attribute_list
+      AttributeList.new.tap do |list|
+        attribute_lists.each do |attribute_list|
+          list.apply_attributes attribute_list.to_a
+        end
+      end
+    end
+
+    private_instance_methods.each do |method|
+      undef_method(method) unless method =~ /^__|initialize/
+    end
+
+    def initialize(build_strategy, overrides = {})
+      @build_strategy    = build_strategy
+      @overrides         = overrides
+      @cached_attributes = overrides
+
+      singleton = class << self; self end
+      @overrides.each do |name, value|
+        singleton.send :define_method, name, lambda { value }
+      end
+
+      @build_strategy.add_observer(CallbackRunner.new(self.class.callbacks, self))
+    end
+
+    def association(factory_name, overrides = {})
+      build_strategy = if overrides.has_key?(:strategy)
+                         overrides[:strategy]
+                       else
+                         Strategy::Create
+                       end
+
+      build_strategy = StrategyCalculator.new(build_strategy).strategy
+      runner = FactoryRunner.new(factory_name, build_strategy, [overrides.except(:strategy)])
+      @build_strategy.association(runner)
+    end
+
+    def instance=(object_instance)
+      @instance = object_instance
+    end
+
+    def method_missing(method_name, *args, &block)
+      if @cached_attributes.key?(method_name)
+        @cached_attributes[method_name]
+      else
+        @instance.send(method_name, *args, &block)
+      end
+    end
+
+    def __overrides
+      @overrides
+    end
+
+    private
+
+    class CallbackRunner
+      def initialize(callbacks, evaluator)
+        @callbacks = callbacks
+        @evaluator = evaluator
+      end
+
+      def update(name, result_instance)
+        @callbacks.select {|callback| callback.name == name }.each do |callback|
+          callback.run(result_instance, @evaluator)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module FactoryGirl
+  class EvaluatorClassDefiner
+    def initialize(attributes, callbacks, parent_class)
+      @parent_class = parent_class
+      @callbacks    = callbacks
+      @attributes   = attributes
+
+      attributes.each do |attribute|
+        define_attribute(attribute.name, attribute.to_proc)
+      end
+    end
+
+    def evaluator_class
+      @evaluator_class ||= Class.new(@parent_class).tap do |klass|
+        klass.callbacks ||= []
+        klass.callbacks += @callbacks
+        klass.attribute_lists ||= []
+        klass.attribute_lists += [@attributes]
+      end
+    end
+
+    private
+
+    def define_attribute(attribute_name, attribute_proc)
+      evaluator_class.send(:define_method, attribute_name) do
+        if @cached_attributes.key?(attribute_name)
+          @cached_attributes[attribute_name]
+        else
+          @cached_attributes[attribute_name] = instance_exec(&attribute_proc)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+require "active_support/core_ext/hash/keys"
+require "active_support/inflector"
+
+module FactoryGirl
+  class Factory
+    attr_reader :name, :definition #:nodoc:
+
+    def initialize(name, options = {}) #:nodoc:
+      assert_valid_options(options)
+      @name             = name.is_a?(Symbol) ? name : name.to_s.underscore.to_sym
+      @parent           = options[:parent]
+      @aliases          = options[:aliases] || []
+      @class_name       = options[:class]
+      @definition       = Definition.new(@name, options[:traits] || [])
+      @compiled         = false
+    end
+
+    delegate :add_callback, :declare_attribute, :to_create, :define_trait,
+             :defined_traits, :inherit_traits, :processing_order, to: :@definition
+
+    def build_class #:nodoc:
+      @build_class ||= if class_name.is_a? Class
+        class_name
+      else
+        class_name.to_s.camelize.constantize
+      end
+    end
+
+    def run(strategy_class, overrides, &block) #:nodoc:
+      block ||= lambda {|result| result }
+      compile
+
+      strategy = strategy_class.new
+
+      evaluator = evaluator_class.new(strategy, overrides.symbolize_keys)
+      attribute_assigner = AttributeAssigner.new(evaluator, &instance_builder)
+
+      strategy.result(attribute_assigner, to_create).tap(&block)
+    end
+
+    def human_names
+      names.map {|name| name.to_s.humanize.downcase }
+    end
+
+    def associations
+      evaluator_class.attribute_list.associations
+    end
+
+    # Names for this factory, including aliases.
+    #
+    # Example:
+    #
+    #   factory :user, aliases: [:author] do
+    #     # ...
+    #   end
+    #
+    #   FactoryGirl.create(:author).class
+    #   # => User
+    #
+    # Because an attribute defined without a value or block will build an
+    # association with the same name, this allows associations to be defined
+    # without factories, such as:
+    #
+    #   factory :user, aliases: [:author] do
+    #     # ...
+    #   end
+    #
+    #   factory :post do
+    #     author
+    #   end
+    #
+    #   FactoryGirl.create(:post).author.class
+    #   # => User
+    def names
+      [name] + @aliases
+    end
+
+    def compile
+      unless @compiled
+        parent.compile
+        parent.defined_traits.each {|trait| define_trait(trait) }
+        @definition.compile
+        @compiled = true
+      end
+    end
+
+    def with_traits(traits)
+      self.clone.tap do |factory_with_traits|
+        factory_with_traits.inherit_traits traits
+      end
+    end
+
+    protected
+
+    def class_name #:nodoc:
+      @class_name || parent.class_name || name
+    end
+
+    def evaluator_class
+      @evaluator_class ||= EvaluatorClassDefiner.new(attributes, callbacks, parent.evaluator_class).evaluator_class
+    end
+
+    def attributes
+      compile
+      AttributeList.new(@name).tap do |list|
+        processing_order.each do |factory|
+          list.apply_attributes factory.attributes
+        end
+      end
+    end
+
+    def callbacks
+      processing_order.map {|factory| factory.callbacks }.flatten
+    end
+
+    def constructor
+      @constructor ||= @definition.constructor || parent.constructor
+    end
+
+    private
+
+    def assert_valid_options(options)
+      options.assert_valid_keys(:class, :parent, :aliases, :traits)
+    end
+
+    def parent
+      if @parent
+        FactoryGirl.factory_by_name(@parent)
+      else
+        NullFactory.new
+      end
+    end
+
+    def instance_builder
+      build_class = self.build_class
+      constructor || lambda { build_class.new }
+    end
+
+    def initialize_copy(source)
+      super
+      @definition = @definition.clone
+      @evaluator_class = nil
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module FactoryGirl
+  class FactoryRunner
+    def initialize(name, strategy, traits_and_overrides)
+      @name     = name
+      @strategy = strategy
+
+      @overrides = traits_and_overrides.extract_options!
+      @traits    = traits_and_overrides
+    end
+
+    def run(strategy_override = nil, &block)
+      strategy_override ||= @strategy
+      factory = FactoryGirl.factory_by_name(@name)
+
+      factory.compile
+
+      if @traits.any?
+        factory = factory.with_traits(@traits)
+      end
+
+      factory.run(strategy_override, @overrides, &block)
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module FactoryGirl
+
+  class << self
+    # An Array of strings specifying locations that should be searched for
+    # factory definitions. By default, factory_girl will attempt to require
+    # "factories," "test/factories," and "spec/factories." Only the first
+    # existing file will be loaded.
+    attr_accessor :definition_file_paths
+  end
+  self.definition_file_paths = %w(factories test/factories spec/factories)
+
+  def self.find_definitions #:nodoc:
+    absolute_definition_file_paths = definition_file_paths.map {|path| File.expand_path(path) }
+
+    absolute_definition_file_paths.uniq.each do |path|
+      load("#{path}.rb") if File.exists?("#{path}.rb")
+
+      if File.directory? path
+        Dir[File.join(path, '**', '*.rb')].sort.each do |file|
+          load file
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module FactoryGirl
+  class NullFactory
+    attr_reader :definition
+
+    def initialize
+      @definition = Definition.new
+    end
+
+    delegate :defined_traits, :callbacks, :attributes, :constructor, to: :definition
+
+    def compile; end
+    def class_name; end
+    def evaluator_class; FactoryGirl::Evaluator; end
+  end
+end

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

@@ -0,0 +1,7 @@
+module FactoryGirl
+  class NullObject < ::BasicObject
+    def method_missing(*args)
+      nil
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module FactoryGirl
+  class Registry
+    include Enumerable
+
+    def initialize(name)
+      @name  = name
+      @items = {}
+    end
+
+    def add(item)
+      item.names.each { |name| add_as(name, item) }
+      item
+    end
+
+    def find(name)
+      @items[name.to_sym] or raise ArgumentError.new("#{@name} not registered: #{name.to_s}")
+    end
+
+    def each(&block)
+      @items.values.uniq.each(&block)
+    end
+
+    def [](name)
+      find(name)
+    end
+
+    def registered?(name)
+      @items.key?(name.to_sym)
+    end
+
+    def clear
+      @items.clear
+    end
+
+    private
+
+    def add_as(name, item)
+      if registered?(name)
+        raise DuplicateDefinitionError, "#{@name} already registered: #{name}"
+      else
+        @items[name.to_sym] = item
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,8 @@
+module FactoryGirl
+  def self.reload
+    self.factories.clear
+    self.sequences.clear
+    self.traits.clear
+    self.find_definitions
+  end
+end

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

@@ -0,0 +1,24 @@
+module FactoryGirl
+
+  # Sequences are defined using sequence within a FactoryGirl.define block.
+  # Sequence values are generated using next.
+  class Sequence
+    attr_reader :name
+
+    def initialize(name, value = 1, &proc) #:nodoc:
+      @name  = name
+      @proc  = proc
+      @value = value
+    end
+
+    def next
+      @proc ? @proc.call(@value) : @value
+    ensure
+      @value = @value.next
+    end
+
+    def names
+      [@name]
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+module FactoryGirlStepHelpers
+  def convert_human_hash_to_attribute_hash(human_hash, associations = [])
+    HumanHashToAttributeHash.new(human_hash, associations).attributes
+  end
+
+  class HumanHashToAttributeHash
+    attr_reader :associations
+
+    def initialize(human_hash, associations)
+      @human_hash   = human_hash
+      @associations = associations
+    end
+
+    def attributes(strategy = CreateAttributes)
+      @human_hash.inject({}) do |attribute_hash, (human_key, value)|
+        attributes = strategy.new(self, *process_key_value(human_key, value))
+        attribute_hash.merge({ attributes.key => attributes.value })
+      end
+    end
+
+    private
+
+    def process_key_value(key, value)
+      value = value.strip if value.is_a?(String)
+      [key.downcase.gsub(' ', '_').to_sym, value]
+    end
+
+    class AssociationManager
+      def initialize(human_hash_to_attributes_hash, key, value)
+        @human_hash_to_attributes_hash = human_hash_to_attributes_hash
+        @key   = key
+        @value = value
+      end
+
+      def association
+        @human_hash_to_attributes_hash.associations.detect {|association| association.name == @key }
+      end
+
+      def association_instance
+        return unless association
+
+        if attributes_hash = nested_attribute_hash
+          factory.build_class.first(conditions: attributes_hash.attributes(FindAttributes)) or
+          FactoryGirl.create(association.factory, attributes_hash.attributes)
+        end
+      end
+
+      private
+
+      def factory
+        FactoryGirl.factory_by_name(association.factory)
+      end
+
+      def nested_attribute_hash
+        attribute, value = @value.split(':', 2)
+        return if value.blank?
+
+        HumanHashToAttributeHash.new({ attribute => value }, factory.associations)
+      end
+    end
+
+    class AttributeStrategy
+      attr_reader :key, :value, :association_manager
+
+      def initialize(human_hash_to_attributes_hash, key, value)
+        @association_manager = AssociationManager.new(human_hash_to_attributes_hash, key, value)
+        @key   = key
+        @value = value
+      end
+    end
+
+    class FindAttributes < AttributeStrategy
+      def initialize(human_hash_to_attributes_hash, key, value)
+        super
+
+        if association_manager.association
+          @key = "#{@key}_id"
+          @value = association_manager.association_instance.try(:id)
+        end
+      end
+    end
+
+    class CreateAttributes < AttributeStrategy
+      def initialize(human_hash_to_attributes_hash, key, value)
+        super
+
+        if association_manager.association
+          @value = association_manager.association_instance
+        end
+      end
+    end
+  end
+end
+
+World(FactoryGirlStepHelpers)
+
+FactoryGirl.factories.each do |factory|
+  factory.compile
+  factory.human_names.each do |human_name|
+    Given /^the following (?:#{human_name}|#{human_name.pluralize}) exists?:?$/i do |table|
+      table.hashes.each do |human_hash|
+        attributes = convert_human_hash_to_attribute_hash(human_hash, factory.associations)
+        FactoryGirl.create(factory.name, attributes)
+      end
+    end
+
+    Given /^an? #{human_name} exists$/i do
+      FactoryGirl.create(factory.name)
+    end
+
+    Given /^(\d+) #{human_name.pluralize} exist$/i do |count|
+      FactoryGirl.create_list(factory.name, count.to_i)
+    end
+
+    if factory.build_class.respond_to?(:columns)
+      factory.build_class.columns.each do |column|
+        name = column.respond_to?(:name) ? column.name : column.to_s
+        human_column_name = name.downcase.gsub('_', ' ')
+        Given /^an? #{human_name} exists with an? #{human_column_name} of "([^"]*)"$/i do |value|
+          FactoryGirl.create(factory.name, name => value)
+        end
+
+        Given /^(\d+) #{human_name.pluralize} exist with an? #{human_column_name} of "([^"]*)"$/i do |count, value|
+          FactoryGirl.create_list(factory.name, count.to_i, name => value)
+        end
+      end
+    end
+  end
+end
+