lockbox_middleware 1.2.0 → 1.2.1

data/vendor/gems/factory_girl-1.2.3/lib/factory_girl/proxy.rb

@@ -0,0 +1,79 @@
+class Factory
+
+  class Proxy #:nodoc:
+
+    attr_reader :callbacks
+
+    def initialize(klass)
+    end
+
+    def get(attribute)
+      nil
+    end
+
+    def set(attribute, value)
+    end
+
+    def associate(name, factory, attributes)
+    end
+
+    def add_callback(name, block)
+      @callbacks ||= {}
+      @callbacks[name] ||= []
+      @callbacks[name] << block
+    end
+
+    def run_callbacks(name)
+      if @callbacks && @callbacks[name]
+        @callbacks[name].each do |block|
+          block.arity.zero? ? block.call : block.call(@instance)
+        end
+      end
+    end
+
+    # Generates an association using the current build strategy.
+    #
+    # Arguments:
+    #   name: (Symbol)
+    #     The name of the factory that should be used to generate this
+    #     association.
+    #   attributes: (Hash)
+    #     A hash of attributes that should be overridden for this association.
+    #
+    # Returns:
+    #   The generated association for the current build strategy. Note that
+    #   assocaitions are not generated for the attributes_for strategy. Returns
+    #   nil in this case.
+    #
+    # Example:
+    #
+    #   Factory.define :user do |f|
+    #     # ...
+    #   end
+    #
+    #   Factory.define :post do |f|
+    #     # ...
+    #     f.author {|a| a.association :user, :name => 'Joe' }
+    #   end
+    #
+    #   # Builds (but doesn't save) a Post and a User
+    #   Factory.build(:post)
+    #
+    #   # Builds and saves a User, builds a Post, assigns the User to the 
+    #   # author association, and saves the User.
+    #   Factory.create(:post)
+    #
+    def association(name, overrides = {})
+      nil
+    end
+
+    def method_missing(method, *args, &block)
+      get(method)
+    end
+
+    def result
+      raise NotImplementedError, "Strategies must return a result"
+    end
+  end
+
+end

data/vendor/gems/factory_girl-1.2.3/lib/factory_girl/proxy/attributes_for.rb

@@ -0,0 +1,21 @@
+class Factory
+  class Proxy #:nodoc:
+    class AttributesFor < Proxy #:nodoc:
+      def initialize(klass)
+        @hash = {}
+      end
+
+      def get(attribute)
+        @hash[attribute]
+      end
+
+      def set(attribute, value)
+        @hash[attribute] = value
+      end
+
+      def result
+        @hash
+      end
+    end
+  end
+end

data/vendor/gems/factory_girl-1.2.3/lib/factory_girl/proxy/build.rb

@@ -0,0 +1,30 @@
+class Factory
+  class Proxy #:nodoc:
+    class Build < Proxy #:nodoc:
+      def initialize(klass)
+        @instance = klass.new
+      end
+
+      def get(attribute)
+        @instance.send(attribute)
+      end
+
+      def set(attribute, value)
+        @instance.send(:"#{attribute}=", value)
+      end
+
+      def associate(name, factory, attributes)
+        set(name, Factory.create(factory, attributes))
+      end
+
+      def association(factory, overrides = {})
+        Factory.create(factory, overrides)
+      end
+
+      def result
+        run_callbacks(:after_build)
+        @instance
+      end
+    end
+  end
+end

data/vendor/gems/factory_girl-1.2.3/lib/factory_girl/proxy/create.rb

@@ -0,0 +1,12 @@
+class Factory
+  class Proxy #:nodoc:
+    class Create < Build #:nodoc:
+      def result
+        run_callbacks(:after_build)
+        @instance.save!
+        run_callbacks(:after_create)
+        @instance
+      end
+    end
+  end
+end

data/vendor/gems/factory_girl-1.2.3/lib/factory_girl/proxy/stub.rb

@@ -0,0 +1,50 @@
+class Factory 
+  class Proxy
+    class Stub < Proxy #:nodoc:
+      @@next_id = 1000
+
+      def initialize(klass)
+        @instance = klass.new
+        @instance.id = next_id
+        @instance.instance_eval do
+          def new_record?
+            id.nil?
+          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
+        end
+      end
+
+      def next_id
+        @@next_id += 1
+      end
+
+      def get(attribute)
+        @instance.send(attribute)
+      end
+
+      def set(attribute, value)
+        @instance.send(:"#{attribute}=", value)
+      end
+
+      def associate(name, factory, attributes)
+        set(name, Factory.stub(factory, attributes))
+      end
+
+      def association(factory, overrides = {})
+        Factory.stub(factory, overrides)
+      end
+
+      def result
+        run_callbacks(:after_stub)
+        @instance
+      end
+    end
+  end
+end

data/vendor/gems/factory_girl-1.2.3/lib/factory_girl/sequence.rb

@@ -0,0 +1,63 @@
+class Factory
+
+  # Raised when calling Factory.sequence from a dynamic attribute block
+  class SequenceAbuseError < StandardError; end
+
+  # Sequences are defined using Factory.sequence. Sequence values are generated
+  # using next.
+  class Sequence
+
+    def initialize (&proc) #:nodoc:
+      @proc  = proc
+      @value = 0
+    end
+
+    # Returns the next value for this sequence
+    def next
+      @value += 1
+      @proc.call(@value)
+    end
+
+  end
+
+  class << self
+    attr_accessor :sequences #:nodoc:
+  end
+  self.sequences = {}
+
+  # Defines a new sequence that can be used to generate unique values in a specific format.
+  #
+  # Arguments:
+  #   name: (Symbol)
+  #     A unique name for this sequence. This name will be referenced when
+  #     calling next to generate new values from this sequence.
+  #   block: (Proc)
+  #     The code to generate each value in the sequence. This block will be
+  #     called with a unique number each time a value in the sequence is to be
+  #     generated. The block should return the generated value for the
+  #     sequence.
+  #
+  # Example:
+  #   
+  #   Factory.sequence(:email) {|n| "somebody_#{n}@example.com" }
+  def self.sequence (name, &block)
+    self.sequences[name] = Sequence.new(&block)
+  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 self.next (sequence)
+    unless self.sequences.key?(sequence)
+      raise "No such sequence: #{sequence}"
+    end
+
+    self.sequences[sequence].next
+  end
+
+end

data/vendor/gems/factory_girl-1.2.3/lib/factory_girl/step_definitions.rb

@@ -0,0 +1,54 @@
+module FactoryGirlStepHelpers
+  def convert_association_string_to_instance(factory_name, assignment)
+    attribute, value = assignment.split(':', 2)
+    attributes = convert_human_hash_to_attribute_hash(attribute => value.strip)
+    factory = Factory.factory_by_name(factory_name)
+    model_class = factory.build_class
+    model_class.find(:first, :conditions => attributes) or
+      Factory(factory_name, attributes)
+  end
+
+  def convert_human_hash_to_attribute_hash(human_hash, associations = [])
+    human_hash.inject({}) do |attribute_hash, (human_key, value)|
+      key = human_key.downcase.gsub(' ', '_').to_sym
+      if association = associations.detect {|association| association.name == key }
+        value = convert_association_string_to_instance(association.factory, value)
+      end
+      attribute_hash.merge(key => value)
+    end
+  end
+end
+
+World(FactoryGirlStepHelpers)
+
+Factory.factories.values.each do |factory|
+  # TODO: support irregular pluralizations
+  Given /^the following #{factory.human_name}s? exists?:$/ do |table|
+    table.hashes.each do |human_hash|
+      attributes = convert_human_hash_to_attribute_hash(human_hash, factory.associations)
+      Factory.create(factory.factory_name, attributes)
+    end
+  end
+
+  Given /^an? #{factory.human_name} exists$/ do
+    Factory(factory.factory_name)
+  end
+
+  Given /^(\d+) #{factory.human_name}s exist$/ do |count|
+    count.to_i.times { Factory(factory.human_name) }
+  end
+
+  if factory.build_class.respond_to?(:columns)
+    factory.build_class.columns.each do |column|
+      human_column_name = column.name.downcase.gsub('_', ' ')
+      Given /^an? #{factory.human_name} exists with an? #{human_column_name} of "([^"]*)"$/i do |value|
+        Factory(factory.factory_name, column.name => value)
+      end
+
+      Given /^(\d+) #{factory.human_name}s exist with an? #{human_column_name} of "([^"]*)"$/i do |count, value|
+        count.to_i.times { Factory(factory.factory_name, column.name => value) }
+      end
+    end
+  end
+end
+

data/vendor/gems/factory_girl-1.2.3/lib/factory_girl/syntax.rb

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

data/vendor/gems/factory_girl-1.2.3/lib/factory_girl/syntax/blueprint.rb

@@ -0,0 +1,42 @@
+class Factory
+  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
+    #
+    #   Factory(: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)
+            instance.instance_eval(&block)
+            Factory.factories[instance.factory_name] = instance
+          end
+
+        end
+
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, Factory::Syntax::Blueprint::ActiveRecord)
+

data/vendor/gems/factory_girl-1.2.3/lib/factory_girl/syntax/generate.rb

@@ -0,0 +1,68 @@
+class Factory
+  module Syntax
+
+    # Extends ActiveRecord::Base to provide generation methods for factories.
+    #
+    # Usage:
+    #
+    #   require 'factory_girl/syntax/generate'
+    #
+    #   Factory.define :user do |factory|
+    #     factory.name 'Billy Bob'
+    #     factory.email 'billy@bob.example.com'
+    #   end
+    #
+    #   # Creates a saved instance without raising (same as saving the result
+    #   # of Factory.build)
+    #   User.generate(:name => 'Johnny')
+    #
+    #   # Creates a saved instance and raises when invalid (same as
+    #   # Factory.create)
+    #   User.generate!
+    #
+    #   # Creates an unsaved instance (same as Factory.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 = Factory.build(name.underscore, overrides)
+            instance.save
+            yield(instance) if block_given?
+            instance
+          end
+
+          def generate!(overrides = {}, &block)
+            instance = Factory.create(name.underscore, overrides)
+            yield(instance) if block_given?
+            instance
+          end
+
+          def spawn(overrides = {}, &block)
+            instance = Factory.build(name.underscore, overrides)
+            yield(instance) if block_given?
+            instance
+          end
+
+        end
+
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, Factory::Syntax::Generate::ActiveRecord)