challah 0.5.2 → 0.5.3

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

@@ -0,0 +1,32 @@
+require "factory_girl/strategy/build"
+require "factory_girl/strategy/create"
+require "factory_girl/strategy/attributes_for"
+require "factory_girl/strategy/stub"
+require "observer"
+
+module FactoryGirl
+  class Strategy #:nodoc:
+    include Observable
+
+    def association(runner)
+      raise NotImplementedError, "Strategies must return an association"
+    end
+
+    def result(attribute_assigner, to_create)
+      raise NotImplementedError, "Strategies must return a result"
+    end
+
+    def self.ensure_strategy_exists!(strategy)
+      unless Strategy.const_defined? strategy.to_s.camelize
+        raise ArgumentError, "Unknown strategy: #{strategy}"
+      end
+    end
+
+    private
+
+    def run_callbacks(name, result_instance)
+      changed
+      notify_observers(name, result_instance)
+    end
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/lib/factory_girl/strategy/attributes_for.rb

@@ -0,0 +1,12 @@
+module FactoryGirl
+  class Strategy #:nodoc:
+    class AttributesFor < Strategy #:nodoc:
+      def association(runner)
+      end
+
+      def result(attribute_assigner, to_create)
+        attribute_assigner.hash
+      end
+    end
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/lib/factory_girl/strategy/build.rb

@@ -0,0 +1,15 @@
+module FactoryGirl
+  class Strategy #:nodoc:
+    class Build < Strategy #:nodoc:
+      def association(runner)
+        runner.run
+      end
+
+      def result(attribute_assigner, to_create)
+        attribute_assigner.object.tap do |result_instance|
+          run_callbacks(:after_build, result_instance)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/lib/factory_girl/strategy/create.rb

@@ -0,0 +1,17 @@
+module FactoryGirl
+  class Strategy #:nodoc:
+    class Create < Strategy #:nodoc:
+      def association(runner)
+        runner.run
+      end
+
+      def result(attribute_assigner, to_create)
+        attribute_assigner.object.tap do |result_instance|
+          run_callbacks(:after_build, result_instance)
+          to_create[result_instance]
+          run_callbacks(:after_create, result_instance)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/lib/factory_girl/strategy/stub.rb

@@ -0,0 +1,61 @@
+module FactoryGirl
+  class Strategy
+    class Stub < Strategy #:nodoc:
+      @@next_id = 1000
+
+      def association(runner)
+        runner.run(Strategy::Stub)
+      end
+
+      def result(attribute_assigner, to_create)
+        attribute_assigner.object.tap do |result_instance|
+          stub_database_interaction_on_result(result_instance)
+          run_callbacks(:after_stub, result_instance)
+        end
+      end
+
+      private
+
+      def next_id
+        @@next_id += 1
+      end
+
+      def stub_database_interaction_on_result(result_instance)
+        result_instance.id = next_id
+        result_instance.instance_eval do
+          def persisted?
+            !new_record?
+          end
+
+          def created_at
+            @created_at ||= Time.now
+          end
+
+          def new_record?
+            id.nil?
+          end
+
+          def save(*args)
+            raise "stubbed models are not allowed to access the database"
+          end
+
+          def destroy(*args)
+            raise "stubbed models are not allowed to access the database"
+          end
+
+          def connection
+            raise "stubbed models are not allowed to access the database"
+          end
+
+          def reload
+            raise "stubbed models are not allowed to access the database"
+          end
+
+          def update_attribute(*args)
+            raise "stubbed models are not allowed to access the database"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module FactoryGirl
+  class StrategyCalculator
+    def initialize(name_or_object)
+      @name_or_object = name_or_object
+    end
+
+    def strategy
+      if strategy_is_object?
+        @name_or_object
+      else
+        strategy_name_to_object
+      end
+    end
+
+    private
+
+    def strategy_is_object?
+      @name_or_object.is_a?(Class) && @name_or_object.ancestors.include?(::FactoryGirl::Strategy)
+    end
+
+    def strategy_name_to_object
+      case @name_or_object
+      when :build  then Strategy::Build
+      when :create then Strategy::Create
+      else raise "unrecognized method #{@name_or_object}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require "factory_girl/syntax/methods"
+require "factory_girl/syntax/default"
+require "factory_girl/syntax/vintage"
+
+module FactoryGirl
+  # Provides alternate syntaxes for factory_girl. If you don't like the default
+  # syntax for defining or using factories, look at one of the
+  # FactoryGirl::Syntax modules:
+  #
+  # * FactoryGirl::Syntax::Blueprint: definition syntax similar to Machinist
+  # * FactoryGirl::Syntax::Generate: usage syntax similar to Object Daddy
+  # * FactoryGirl::Syntax::Make: usage syntax similar to Machinist
+  # * FactoryGirl::Syntax::Sham: sequence syntax similar to Machinist
+  module Syntax
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/lib/factory_girl/syntax/blueprint.rb

@@ -0,0 +1,42 @@
+module FactoryGirl
+  module Syntax
+
+    # Extends ActiveRecord::Base to provide a make class method, which is an
+    # alternate syntax for defining factories.
+    #
+    # Usage:
+    #
+    #   require 'factory_girl/syntax/blueprint'
+    #
+    #   User.blueprint do
+    #     name  { 'Billy Bob'             }
+    #     email { 'billy@bob.example.com' }
+    #   end
+    #
+    #   FactoryGirl.create(:user, name: 'Johnny')
+    #
+    # This syntax was derived from Pete Yandell's machinist.
+    module Blueprint
+      module ActiveRecord #:nodoc:
+
+        def self.included(base) # :nodoc:
+          base.extend ClassMethods
+        end
+
+        module ClassMethods #:nodoc:
+
+          def blueprint(&block)
+            instance = Factory.new(name.underscore, class: self)
+            proxy = FactoryGirl::DefinitionProxy.new(instance)
+            proxy.instance_eval(&block)
+            FactoryGirl.register_factory(instance)
+          end
+
+        end
+
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, FactoryGirl::Syntax::Blueprint::ActiveRecord)

data/vendor/bundle/gems/factory_girl-3.0.0/lib/factory_girl/syntax/default.rb

@@ -0,0 +1,56 @@
+module FactoryGirl
+  module Syntax
+    module Default
+      include Methods
+
+      def define(&block)
+        DSL.run(block)
+      end
+
+      def modify(&block)
+        ModifyDSL.run(block)
+      end
+
+      class DSL
+        def self.run(block)
+          new.instance_eval(&block)
+        end
+
+        def factory(name, options = {}, &block)
+          factory = Factory.new(name, options)
+          proxy = FactoryGirl::DefinitionProxy.new(factory.definition)
+          proxy.instance_eval(&block) if block_given?
+
+          FactoryGirl.register_factory(factory)
+
+          proxy.child_factories.each do |(child_name, child_options, child_block)|
+            parent_factory = child_options.delete(:parent) || name
+            factory(child_name, child_options.merge(parent: parent_factory), &child_block)
+          end
+        end
+
+        def sequence(name, start_value = 1, &block)
+          FactoryGirl.register_sequence(Sequence.new(name, start_value, &block))
+        end
+
+        def trait(name, &block)
+          FactoryGirl.register_trait(Trait.new(name, &block))
+        end
+      end
+
+      class ModifyDSL
+        def self.run(block)
+          new.instance_eval(&block)
+        end
+
+        def factory(name, options = {}, &block)
+          factory = FactoryGirl.factory_by_name(name)
+          proxy = FactoryGirl::DefinitionProxy.new(factory.definition.overridable)
+          proxy.instance_eval(&block)
+        end
+      end
+    end
+  end
+
+  extend Syntax::Default
+end

data/vendor/bundle/gems/factory_girl-3.0.0/lib/factory_girl/syntax/generate.rb

@@ -0,0 +1,70 @@
+module FactoryGirl
+  module Syntax
+
+    # Extends ActiveRecord::Base to provide generation methods for factories.
+    #
+    # Usage:
+    #
+    #   require 'factory_girl/syntax/generate'
+    #
+    #   FactoryGirl.define do
+    #     factory :user do
+    #       name 'Billy Bob'
+    #       email 'billy@bob.example.com'
+    #     end
+    #   end
+    #
+    #   # Creates a saved instance without raising (same as saving the result
+    #   # of FactoryGirl.build)
+    #   User.generate(name: 'Johnny')
+    #
+    #   # Creates a saved instance and raises when invalid (same as
+    #   # FactoryGirl.create)
+    #   User.generate!
+    #
+    #   # Creates an unsaved instance (same as FactoryGirl.build)
+    #   User.spawn
+    #
+    #   # Creates an instance and yields it to the passed block
+    #   User.generate do |user|
+    #     # ...do something with user...
+    #   end
+    #
+    # This syntax was derived from Rick Bradley and Yossef Mendelssohn's
+    # object_daddy.
+    module Generate
+      module ActiveRecord #:nodoc:
+
+        def self.included(base) # :nodoc:
+          base.extend ClassMethods
+        end
+
+        module ClassMethods #:nodoc:
+
+          def generate(overrides = {}, &block)
+            instance = FactoryRunner.new(name.underscore, Strategy::Build, [overrides]).run
+            instance.save
+            yield(instance) if block_given?
+            instance
+          end
+
+          def generate!(overrides = {}, &block)
+            instance = FactoryRunner.new(name.underscore, Strategy::Create, [overrides]).run
+            yield(instance) if block_given?
+            instance
+          end
+
+          def spawn(overrides = {}, &block)
+            instance = FactoryRunner.new(name.underscore, Strategy::Build, [overrides]).run
+            yield(instance) if block_given?
+            instance
+          end
+
+        end
+
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, FactoryGirl::Syntax::Generate::ActiveRecord)

data/vendor/bundle/gems/factory_girl-3.0.0/lib/factory_girl/syntax/make.rb

@@ -0,0 +1,45 @@
+module FactoryGirl
+  module Syntax
+
+    # Extends ActiveRecord::Base to provide a make class method, which is a
+    # shortcut for FactoryGirl.create.
+    #
+    # Usage:
+    #
+    #   require 'factory_girl/syntax/make'
+    #
+    #   FactoryGirl.define do
+    #     factory :user do
+    #       name 'Billy Bob'
+    #       email 'billy@bob.example.com'
+    #     end
+    #   end
+    #
+    #   User.make(name: 'Johnny')
+    #
+    # This syntax was derived from Pete Yandell's machinist.
+    module Make
+      module ActiveRecord #:nodoc:
+
+        def self.included(base) # :nodoc:
+          base.extend ClassMethods
+        end
+
+        module ClassMethods #:nodoc:
+
+          def make(overrides = {})
+            FactoryRunner.new(name.underscore, Strategy::Build, [overrides]).run
+          end
+
+          def make!(overrides = {})
+            FactoryRunner.new(name.underscore, Strategy::Create, [overrides]).run
+          end
+
+        end
+
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, FactoryGirl::Syntax::Make::ActiveRecord)

data/vendor/bundle/gems/factory_girl-3.0.0/lib/factory_girl/syntax/methods.rb

@@ -0,0 +1,136 @@
+module FactoryGirl
+  module Syntax
+    module Methods
+      # Generates and returns a Hash of attributes from this factory. Attributes
+      # can be individually overridden by passing in a Hash of attribute => value
+      # pairs.
+      #
+      # Arguments:
+      # * name: +Symbol+ or +String+
+      #   The name of the factory that should be used.
+      # * traits_and_overrides: +Array+
+      #   [+*Array+] Traits to be applied
+      #   [+Hash+] Attributes to overwrite for this set.
+      # * block:
+      #   Yields the hash of attributes.
+      #
+      # Returns: +Hash+
+      # A set of attributes that can be used to build an instance of the class
+      # this factory generates.
+      def attributes_for(name, *traits_and_overrides, &block)
+        FactoryRunner.new(name, Strategy::AttributesFor, traits_and_overrides).run(&block)
+      end
+
+      # Generates and returns an instance from this factory. Attributes can be
+      # individually overridden by passing in a Hash of attribute => value pairs.
+      #
+      # Arguments:
+      # * name: +Symbol+ or +String+
+      #   The name of the factory that should be used.
+      # * traits_and_overrides: +Array+
+      #   [+*Array+] Traits to be applied
+      #   [+Hash+] Attributes to overwrite for this instance.
+      # * block:
+      #   Yields the built instance.
+      #
+      # Returns: +Object+
+      # An instance of the class this factory generates, with generated attributes
+      # assigned.
+      def build(name, *traits_and_overrides, &block)
+        FactoryRunner.new(name, Strategy::Build, traits_and_overrides).run(&block)
+      end
+
+      # Generates, saves, and returns an instance from this factory. Attributes can
+      # be individually overridden by passing in a Hash of attribute => value
+      # pairs.
+      #
+      # Instances are saved using the +save!+ method, so ActiveRecord models will
+      # raise ActiveRecord::RecordInvalid exceptions for invalid attribute sets.
+      #
+      # Arguments:
+      # * name: +Symbol+ or +String+
+      #   The name of the factory that should be used.
+      # * traits_and_overrides: +Array+
+      #   [+*Array+] Traits to be applied
+      #   [+Hash+] Attributes to overwrite for this instance.
+      # * block:
+      #   Yields the created instance.
+      #
+      # Returns: +Object+
+      # A saved instance of the class this factory generates, with generated
+      # attributes assigned.
+      def create(name, *traits_and_overrides, &block)
+        FactoryRunner.new(name, Strategy::Create, traits_and_overrides).run(&block)
+      end
+
+      # Generates and returns an object with all attributes from this factory
+      # stubbed out. Attributes can be individually overridden by passing in a Hash
+      # of attribute => value pairs.
+      #
+      # Arguments:
+      # * name: +Symbol+ or +String+
+      #   The name of the factory that should be used.
+      # * traits_and_overrides: +Array+
+      #   [+*Array+] Traits to be applied
+      #   [+Hash+] Attributes to overwrite for this instance.
+      # * block
+      #   Yields the stubbed object.
+      #
+      # Returns: +Object+
+      # An object with generated attributes stubbed out.
+      def build_stubbed(name, *traits_and_overrides, &block)
+        FactoryRunner.new(name, Strategy::Stub, traits_and_overrides).run(&block)
+      end
+
+      # Builds and returns multiple instances from this factory as an array. Attributes can be
+      # individually overridden by passing in a Hash of attribute => value pairs.
+      #
+      # Arguments:
+      # * name: +Symbol+ or +String+
+      #   The name of the factory to be used.
+      # * amount: +Integer+
+      #   number of instances to be built.
+      # * traits_and_overrides: +Array+
+      #   [+*Array+] Traits to be applied
+      #   [+Hash+] Attributes to overwrite for this instance.
+      #
+      # Returns: +Array+
+      # An array of instances of the class this factory generates, with generated attributes
+      # assigned.
+      def build_list(name, amount, *traits_and_overrides)
+        amount.times.map { build(name, *traits_and_overrides) }
+      end
+
+      # Creates and returns multiple instances from this factory as an array. Attributes can be
+      # individually overridden by passing in a Hash of attribute => value pairs.
+      #
+      # Arguments:
+      # * name: +Symbol+ or +String+
+      #   The name of the factory to be used.
+      # * amount: +Integer+
+      #   number of instances to be created.
+      # * traits_and_overrides: +Array+
+      #   [+*Array+] Traits to be applied
+      #   [+Hash+] Attributes to overwrite for this instance.
+      #
+      # Returns: +Array+
+      # An array of instances of the class this factory generates, with generated attributes
+      # assigned.
+      def create_list(name, amount, *traits_and_overrides)
+        amount.times.map { create(name, *traits_and_overrides) }
+      end
+
+      # Generates and returns the next value in a sequence.
+      #
+      # Arguments:
+      #   name: (Symbol)
+      #     The name of the sequence that a value should be generated for.
+      #
+      # Returns:
+      #   The next value in the sequence. (Object)
+      def generate(name)
+        FactoryGirl.sequence_by_name(name).next
+      end
+    end
+  end
+end