lockbox_middleware 1.2.1 → 1.2.2

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

@@ -1,395 +0,0 @@
-class Factory
-
-  # 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
-  
-  class << self
-    attr_accessor :factories #:nodoc:
-
-    # 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.factories = {}
-  self.definition_file_paths = %w(factories test/factories spec/factories)
-
-  attr_reader :factory_name #:nodoc:
-  attr_reader :attributes #:nodoc:
-
-  # Defines a new factory that can be used by the build strategies (create and
-  # build) to build new objects.
-  #
-  # Arguments:
-  # * name: +Symbol+ or +String+
-  #   A unique name used to identify this factory.
-  # * options: +Hash+
-  #
-  # Options:
-  # * class: +Symbol+, +Class+, or +String+
-  #   The class that will be used when generating instances for this factory. If not specified, the class will be guessed from the factory name.
-  # * parent: +Symbol+
-  #   The parent factory. If specified, the attributes from the parent
-  #   factory will be copied to the current one with an ability to override
-  #   them.
-  # * default_strategy: +Symbol+
-  #   The strategy that will be used by the Factory shortcut method.
-  #   Defaults to :create.
-  #
-  # Yields: +Factory+
-  # The newly created factory.
-  def self.define (name, options = {})
-    instance = Factory.new(name, options)
-    yield(instance)
-    if parent = options.delete(:parent)
-      instance.inherit_from(Factory.factory_by_name(parent))
-    end    
-    self.factories[instance.factory_name] = instance
-  end
-  
-  def class_name #:nodoc:
-    @options[:class] || factory_name
-  end
-
-  def build_class #:nodoc:
-    @build_class ||= class_for(class_name)
-  end
-  
-  def default_strategy #:nodoc:
-    @options[:default_strategy] || :create
-  end
-
-  def initialize (name, options = {}) #:nodoc:
-    assert_valid_options(options)
-    @factory_name = factory_name_for(name)
-    @options      = options      
-    @attributes   = []
-  end
-  
-  def inherit_from(parent) #:nodoc:
-    @options[:class] ||= parent.class_name
-    parent.attributes.each do |attribute|
-      unless attribute_defined?(attribute.name)
-        @attributes << attribute.clone
-      end
-    end
-  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 overriden for a specific instance.
-  #
-  # When defining lazy attributes, an instance of Factory::Proxy 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)
-    if block_given?
-      if value
-        raise AttributeDefinitionError, "Both value and block given"
-      else
-        attribute = Attribute::Dynamic.new(name, block)
-      end
-    else
-      attribute = Attribute::Static.new(name, value)
-    end
-
-    if attribute_defined?(attribute.name)
-      raise AttributeDefinitionError, "Attribute already defined: #{name}"
-    end
-
-    @attributes << attribute
-  end
-
-  # Calls add_attribute using the missing method name as the name of the
-  # attribute, so that:
-  #
-  #   Factory.define :user do |f|
-  #     f.name 'Billy Idol'
-  #   end
-  #
-  # and:
-  #
-  #   Factory.define :user do |f|
-  #     f.add_attribute :name, 'Billy Idol'
-  #   end
-  #
-  # are equivilent. 
-  def method_missing (name, *args, &block)
-    add_attribute(name, *args, &block)
-  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.define :user do |f|
-  #     f.name 'Joey'
-  #   end
-  #
-  #   Factory.define :post do |f|
-  #     f.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 = {})
-    factory_name = options.delete(:factory) || name
-    if factory_name_for(factory_name) == self.factory_name
-      raise AssociationDefinitionError, "Self-referencing association '#{name}' in factory '#{self.factory_name}'"
-    end
-    @attributes << Attribute::Association.new(name, factory_name, options)
-  end
-
-  # Adds an attribute that will have unique values generated by a sequence with
-  # a specified format.
-  #
-  # The result of:
-  #   Factory.define :user do |f|
-  #    f.sequence(:email) { |n| "person#{n}@example.com" }
-  #   end
-  #
-  # Is equal to:
-  #   Factory.sequence(:email) { |n| "person#{n}@example.com" }
-  #
-  #   Factory.define :user do |f|
-  #    f.email { Factory.next(:email) }
-  #   end
-  #
-  # Except that no globally available sequence will be defined.
-  def sequence (name, &block)
-    s = Sequence.new(&block)
-    add_attribute(name) { s.next }
-  end
-  
-  def after_build(&block)
-    callback(:after_build, &block)
-  end
-  
-  def after_create(&block)
-    callback(:after_create, &block)
-  end
-  
-  def after_stub(&block)
-    callback(:after_stub, &block)
-  end
-  
-  def callback(name, &block)
-    unless [:after_build, :after_create, :after_stub].include?(name.to_sym)
-      raise InvalidCallbackNameError, "#{name} is not a valid callback name. Valid callback names are :after_build, :after_create, and :after_stub"
-    end
-    @attributes << Attribute::Callback.new(name.to_sym, block)
-  end
-  
-  # 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.
-  # * overrides: +Hash+
-  #   Attributes to overwrite for this set.
-  #
-  # Returns: +Hash+
-  # A set of attributes that can be used to build an instance of the class
-  # this factory generates. 
-  def self.attributes_for (name, overrides = {})
-    factory_by_name(name).run(Proxy::AttributesFor, overrides)
-  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.
-  # * overrides: +Hash+
-  #   Attributes to overwrite for this instance.
-  #
-  # Returns: +Object+
-  # An instance of the class this factory generates, with generated attributes
-  # assigned.
-  def self.build (name, overrides = {})
-    factory_by_name(name).run(Proxy::Build, overrides)
-  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.
-  # * overrides: +Hash+
-  #   Attributes to overwrite for this instance.
-  #
-  # Returns: +Object+
-  # A saved instance of the class this factory generates, with generated
-  # attributes assigned.
-  def self.create (name, overrides = {})
-    factory_by_name(name).run(Proxy::Create, overrides)
-  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.
-  # * overrides: +Hash+
-  #   Attributes to overwrite for this instance.
-  #
-  # Returns: +Object+
-  # An object with generated attributes stubbed out.
-  def self.stub (name, overrides = {})
-    factory_by_name(name).run(Proxy::Stub, overrides)
-  end
-  
-  # Executes the default strategy for the given factory. This is usually create,
-  # but it can be overridden for each factory.
-  #
-  # Arguments:
-  # * name: +Symbol+ or +String+
-  #   The name of the factory that should be used.
-  # * overrides: +Hash+
-  #   Attributes to overwrite for this instance.
-  #
-  # Returns: +Object+
-  # The result of the default strategy.
-  def self.default_strategy (name, overrides = {})  
-    self.send(factory_by_name(name).default_strategy, name, overrides)
-  end
-
-  def self.find_definitions #:nodoc:
-    definition_file_paths.each do |path|
-      require("#{path}.rb") if File.exists?("#{path}.rb")
-
-      if File.directory? path
-        Dir[File.join(path, '*.rb')].each do |file|
-          require file
-        end
-      end
-    end
-  end
-
-  def run (proxy_class, overrides) #:nodoc:
-    proxy = proxy_class.new(build_class)
-    overrides = symbolize_keys(overrides)
-    overrides.each {|attr, val| proxy.set(attr, val) }
-    passed_keys = overrides.keys.collect {|k| Factory.aliases_for(k) }.flatten
-    @attributes.each do |attribute|
-      unless passed_keys.include?(attribute.name)
-        attribute.add_to(proxy)
-      end
-    end
-    proxy.result
-  end
-
-  def self.factory_by_name (name)
-    factories[name.to_sym] or raise ArgumentError.new("No such factory: #{name.to_s}")
-  end
-
-  def human_name(*args, &block)
-    if args.size == 0 && block.nil?
-      factory_name.to_s.gsub('_', ' ')
-    else
-      add_attribute(:human_name, *args, &block)
-    end
-  end
-
-  def associations
-    attributes.select {|attribute| attribute.is_a?(Attribute::Association) }
-  end
-
-  private
-
-  def class_for (class_or_to_s)
-    if class_or_to_s.respond_to?(:to_sym)
-      Object.const_get(variable_name_to_class_name(class_or_to_s))
-    else
-      class_or_to_s
-    end
-  end
-
-  def factory_name_for (class_or_to_s)
-    if class_or_to_s.respond_to?(:to_sym)
-      class_or_to_s.to_sym
-    else
-      class_name_to_variable_name(class_or_to_s).to_sym
-    end
-  end
-
-  def attribute_defined? (name)
-    !@attributes.detect {|attr| attr.name == name && !attr.is_a?(Factory::Attribute::Callback) }.nil?
-  end
-
-  def assert_valid_options(options)
-    invalid_keys = options.keys - [:class, :parent, :default_strategy] 
-    unless invalid_keys == []
-      raise ArgumentError, "Unknown arguments: #{invalid_keys.inspect}"
-    end
-    assert_valid_strategy(options[:default_strategy]) if options[:default_strategy]
-  end
-  
-  def assert_valid_strategy(strategy)
-    unless Factory::Proxy.const_defined? variable_name_to_class_name(strategy)
-      raise ArgumentError, "Unknown strategy: #{strategy}"
-    end
-  end
-
-  # Based on ActiveSupport's underscore inflector
-  def class_name_to_variable_name(name)
-    name.to_s.gsub(/::/, '/').
-      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-      gsub(/([a-z\d])([A-Z])/,'\1_\2').
-      tr("-", "_").
-      downcase
-  end
-
-  # Based on ActiveSupport's camelize inflector
-  def variable_name_to_class_name(name)
-    name.to_s.
-      gsub(/\/(.?)/) { "::#{$1.upcase}" }.
-      gsub(/(?:^|_)(.)/) { $1.upcase }
-  end
-
-  # From ActiveSupport
-  def symbolize_keys(hash)
-    hash.inject({}) do |options, (key, value)|
-      options[(key.to_sym rescue key) || key] = value
-      options
-    end
-  end
-
-end

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

@@ -1,21 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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/proxy.rb

@@ -1,79 +0,0 @@
-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/sequence.rb

@@ -1,63 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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
-