gem_repackager 0.1.0

data/support/gems/rspec-rails-2.11.0/lib/rspec/rails/mocks.rb

@@ -0,0 +1,243 @@
+require 'active_support/core_ext'
+require 'active_model'
+
+module RSpec
+  module Rails
+
+    class IllegalDataAccessException < StandardError; end
+
+    module Mocks
+
+      module ActiveModelInstanceMethods
+        # Stubs `persisted?` to return false and `id` to return nil
+        # @return self
+        def as_new_record
+          self.stub(:persisted?) { false }
+          self.stub(:id) { nil }
+          self
+        end
+
+        # Returns true by default. Override with a stub.
+        def persisted?
+          true
+        end
+
+        # Returns false for names matching <tt>/_before_type_cast$/</tt>,
+        # otherwise delegates to super.
+        def respond_to?(message, include_private=false)
+          message.to_s =~ /_before_type_cast$/ ? false : super
+        end
+      end
+
+      module ActiveRecordInstanceMethods
+        # Stubs `persisted?` to return `false` and `id` to return `nil`.
+        def destroy
+          self.stub(:persisted?) { false }
+          self.stub(:id) { nil }
+        end
+
+        # Transforms the key to a method and calls it.
+        def [](key)
+          send(key)
+        end
+
+        # Returns the opposite of `persisted?`
+        def new_record?
+          !persisted?
+        end
+      end
+
+      # Creates a test double representing `string_or_model_class` with common
+      # ActiveModel methods stubbed out. Additional methods may be easily
+      # stubbed (via add_stubs) if `stubs` is passed. This is most useful for
+      # impersonating models that don't exist yet.
+      #
+      # NOTE that only ActiveModel's methods, plus <tt>new_record?</tt>, are
+      # stubbed out implicitly.  <tt>new_record?</tt> returns the inverse of
+      # <tt>persisted?</tt>, and is present only for compatibility with
+      # extension frameworks that have yet to update themselves to the
+      # ActiveModel API (which declares <tt>persisted?</tt>, not
+      # <tt>new_record?</tt>).
+      #
+      # `string_or_model_class` can be any of:
+      #
+      #   * A String representing a Class that does not exist
+      #   * A String representing a Class that extends ActiveModel::Naming
+      #   * A Class that extends ActiveModel::Naming
+      def mock_model(string_or_model_class, stubs = {})
+        if String === string_or_model_class
+          if Object.const_defined?(string_or_model_class)
+            model_class = Object.const_get(string_or_model_class)
+          else
+            model_class = Object.const_set(string_or_model_class, Class.new do
+              extend ActiveModel::Naming
+              def self.primary_key; :id; end
+            end)
+          end
+        else
+          model_class = string_or_model_class
+        end
+
+        unless model_class.kind_of? ActiveModel::Naming
+          raise ArgumentError.new <<-EOM
+The mock_model method can only accept as its first argument:
+  * A String representing a Class that does not exist
+  * A String representing a Class that extends ActiveModel::Naming
+  * A Class that extends ActiveModel::Naming
+
+It received #{model_class.inspect}
+EOM
+        end
+
+        stubs = stubs.reverse_merge(:id => next_id)
+        stubs = stubs.reverse_merge(:persisted? => !!stubs[:id],
+                                    :destroyed? => false,
+                                    :marked_for_destruction? => false,
+                                    :valid? => true,
+                                    :blank? => false)
+
+        mock("#{model_class.name}_#{stubs[:id]}", stubs).tap do |m|
+          m.singleton_class.class_eval do
+            include ActiveModelInstanceMethods
+            include ActiveRecordInstanceMethods if defined?(ActiveRecord)
+            include ActiveModel::Conversion
+            include ActiveModel::Validations
+          end
+          if defined?(ActiveRecord)
+            [:save, :update_attributes].each do |key|
+              if stubs[key] == false
+                m.errors.stub(:empty? => false)
+              end
+            end
+          end
+          m.__send__(:__mock_proxy).instance_eval(<<-CODE, __FILE__, __LINE__)
+            def @object.is_a?(other)
+              #{model_class}.ancestors.include?(other)
+            end unless #{stubs.has_key?(:is_a?)}
+
+            def @object.kind_of?(other)
+              #{model_class}.ancestors.include?(other)
+            end unless #{stubs.has_key?(:kind_of?)}
+
+            def @object.instance_of?(other)
+              other == #{model_class}
+            end unless #{stubs.has_key?(:instance_of?)}
+
+            def @object.__model_class_has_column?(method_name)
+              #{model_class}.respond_to?(:column_names) && #{model_class}.column_names.include?(method_name.to_s)
+            end
+
+            def @object.respond_to?(method_name, include_private=false)
+              __model_class_has_column?(method_name) ? true : super
+            end unless #{stubs.has_key?(:respond_to?)}
+
+            def @object.method_missing(m, *a, &b)
+              respond_to?(m) ? null_object? ? self : nil : super
+            end
+
+            def @object.class
+              #{model_class}
+            end unless #{stubs.has_key?(:class)}
+
+            def @object.to_s
+              "#{model_class.name}_#{to_param}"
+            end unless #{stubs.has_key?(:to_s)}
+          CODE
+          yield m if block_given?
+        end
+      end
+
+      module ActiveModelStubExtensions
+        # Stubs `persisted` to return false and `id` to return nil
+        def as_new_record
+          self.stub(:persisted?)  { false }
+          self.stub(:id)          { nil }
+          self
+        end
+
+        # Returns `true` by default. Override with a stub.
+        def persisted?
+          true
+        end
+      end
+
+      module ActiveRecordStubExtensions
+        # Stubs `id` (or other primary key method) to return nil
+        def as_new_record
+          self.__send__("#{self.class.primary_key}=", nil)
+          super
+        end
+
+        # Returns the opposite of `persisted?`.
+        def new_record?
+          !persisted?
+        end
+
+        # Raises an IllegalDataAccessException (stubbed models are not allowed to access the database)
+        # @raises IllegalDataAccessException
+        def connection
+          raise RSpec::Rails::IllegalDataAccessException.new("stubbed models are not allowed to access the database")
+        end
+      end
+
+      # Creates an instance of `Model` with `to_param` stubbed using a
+      # generated value that is unique to each object. If `Model` is an
+      # `ActiveRecord` model, it is prohibited from accessing the database*.
+      #
+      # For each key in `stubs`, if the model has a matching attribute
+      # (determined by `respond_to?`) it is simply assigned the submitted values.
+      # If the model does not have a matching attribute, the key/value pair is
+      # assigned as a stub return value using RSpec's mocking/stubbing
+      # framework.
+      #
+      # <tt>persisted?</tt> is overridden to return the result of !id.nil?
+      # This means that by default persisted? will return true. If  you want
+      # the object to behave as a new record, sending it `as_new_record` will
+      # set the id to nil. You can also explicitly set :id => nil, in which
+      # case persisted? will return false, but using `as_new_record` makes the
+      # example a bit more descriptive.
+      #
+      # While you can use stub_model in any example (model, view, controller,
+      # helper), it is especially useful in view examples, which are
+      # inherently more state-based than interaction-based.
+      #
+      # @example
+      #
+      #     stub_model(Person)
+      #     stub_model(Person).as_new_record
+      #     stub_model(Person, :to_param => 37)
+      #     stub_model(Person) {|person| person.first_name = "David"}
+      def stub_model(model_class, stubs={})
+        model_class.new.tap do |m|
+          m.extend ActiveModelStubExtensions
+          if defined?(ActiveRecord) && model_class < ActiveRecord::Base
+            m.extend ActiveRecordStubExtensions
+            primary_key = model_class.primary_key.to_sym
+            stubs = stubs.reverse_merge(primary_key => next_id)
+            stubs = stubs.reverse_merge(:persisted? => !!stubs[primary_key])
+          else
+            stubs = stubs.reverse_merge(:id => next_id)
+            stubs = stubs.reverse_merge(:persisted? => !!stubs[:id])
+          end
+          stubs = stubs.reverse_merge(:blank? => false)
+          stubs.each do |k,v|
+            m.__send__("#{k}=", stubs.delete(k)) if m.respond_to?("#{k}=")
+          end
+          m.stub(stubs)
+          yield m if block_given?
+        end
+      end
+
+    private
+
+      @@model_id = 1000
+
+      def next_id
+        @@model_id += 1
+      end
+
+    end
+  end
+end
+
+RSpec.configuration.include RSpec::Rails::Mocks

data/support/gems/rspec-rails-2.11.0/lib/rspec/rails/module_inclusion.rb

@@ -0,0 +1,29 @@
+module RSpec::Rails
+  module ModuleInclusion
+    # @deprecated No replacement.
+    #
+    # Will be removed from rspec-rails-3.0
+    #
+    # This was never intended to be a public API and is no longer needed
+    # internally. As it happens, there are a few blog posts citing its use, so
+    # I'm leaving it here, but deprecated.
+    def include_self_when_dir_matches(*path_parts)
+        instead = <<-INSTEAD
+
+
+    RSpec.configure do |c|
+      c.include self, :example_group => {
+        :file_path => /#{path_parts.join('\/')}/
+      }
+    end
+
+INSTEAD
+      lambda do |c|
+        RSpec.deprecate('include_self_when_dir_matches', instead, 'rails-3.0')
+        c.include self, :example_group => {
+          :file_path => Regexp.compile(path_parts.join('[\\\/]'))
+        }
+      end
+    end
+  end
+end

data/support/gems/rspec-rails-2.11.0/lib/rspec/rails/tasks/rspec.rake

@@ -0,0 +1,56 @@
+require 'rspec/core'
+require 'rspec/core/rake_task'
+if default = Rake.application.instance_variable_get('@tasks')['default']
+  default.prerequisites.delete('test')
+end
+
+orm_setting = Rails.configuration.generators.options[:rails][:orm]
+spec_prereq = if(orm_setting == :active_record)
+  Rails.configuration.active_record[:schema_format] == :sql ? "db:test:clone_structure" : "db:test:prepare"
+else
+  :noop	
+end
+task :noop do; end
+task :default => :spec
+
+task :stats => "spec:statsetup"
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+RSpec::Core::RakeTask.new(:spec => spec_prereq)
+
+namespace :spec do
+  [:requests, :models, :controllers, :views, :helpers, :mailers, :lib, :routing].each do |sub|
+    desc "Run the code examples in spec/#{sub}"
+    RSpec::Core::RakeTask.new(sub => spec_prereq) do |t|
+      t.pattern = "./spec/#{sub}/**/*_spec.rb"
+    end
+  end
+
+  desc "Run all specs with rcov"
+  RSpec::Core::RakeTask.new(:rcov => spec_prereq) do |t|
+    t.rcov = true
+    t.pattern = "./spec/**/*_spec.rb"
+    t.rcov_opts = '--exclude /gems/,/Library/,/usr/,lib/tasks,.bundle,config,/lib/rspec/,/lib/rspec-,spec'
+  end
+
+  task :statsetup do
+    require 'rails/code_statistics'
+    ::STATS_DIRECTORIES << %w(Model\ specs spec/models) if File.exist?('spec/models')
+    ::STATS_DIRECTORIES << %w(View\ specs spec/views) if File.exist?('spec/views')
+    ::STATS_DIRECTORIES << %w(Controller\ specs spec/controllers) if File.exist?('spec/controllers')
+    ::STATS_DIRECTORIES << %w(Helper\ specs spec/helpers) if File.exist?('spec/helpers')
+    ::STATS_DIRECTORIES << %w(Library\ specs spec/lib) if File.exist?('spec/lib')
+    ::STATS_DIRECTORIES << %w(Mailer\ specs spec/mailers) if File.exist?('spec/mailers')
+    ::STATS_DIRECTORIES << %w(Routing\ specs spec/routing) if File.exist?('spec/routing')
+    ::STATS_DIRECTORIES << %w(Request\ specs spec/requests) if File.exist?('spec/requests')
+    ::CodeStatistics::TEST_TYPES << "Model specs" if File.exist?('spec/models')
+    ::CodeStatistics::TEST_TYPES << "View specs" if File.exist?('spec/views')
+    ::CodeStatistics::TEST_TYPES << "Controller specs" if File.exist?('spec/controllers')
+    ::CodeStatistics::TEST_TYPES << "Helper specs" if File.exist?('spec/helpers')
+    ::CodeStatistics::TEST_TYPES << "Library specs" if File.exist?('spec/lib')
+    ::CodeStatistics::TEST_TYPES << "Mailer specs" if File.exist?('spec/mailers')
+    ::CodeStatistics::TEST_TYPES << "Routing specs" if File.exist?('spec/routing')
+    ::CodeStatistics::TEST_TYPES << "Request specs" if File.exist?('spec/requests')
+  end
+end
+

data/support/gems/rspec-rails-2.11.0/lib/rspec/rails/vendor/capybara.rb

@@ -0,0 +1,29 @@
+begin
+  require 'capybara/rspec'
+rescue LoadError
+end
+
+begin
+  require 'capybara/rails'
+rescue LoadError
+end
+
+RSpec.configure do |c|
+  if defined?(Capybara::RSpecMatchers)
+    c.include Capybara::RSpecMatchers, :type => :view
+    c.include Capybara::RSpecMatchers, :type => :helper
+    c.include Capybara::RSpecMatchers, :type => :mailer
+    c.include Capybara::RSpecMatchers, :type => :controller
+  end
+
+  if defined?(Capybara::DSL)
+    c.include Capybara::DSL, :type => :controller
+  end
+
+  unless defined?(Capybara::RSpecMatchers) || defined?(Capybara::DSL)
+    if defined?(Capybara)
+      c.include Capybara, :type => :request
+      c.include Capybara, :type => :controller
+    end
+  end
+end

data/support/gems/rspec-rails-2.11.0/lib/rspec/rails/vendor/webrat.rb

@@ -0,0 +1,33 @@
+begin
+  require 'webrat'
+rescue LoadError
+end
+
+RSpec.configure do |c|
+  if defined?(Webrat)
+    c.include Webrat::Matchers, :type => :request
+    c.include Webrat::Matchers, :type => :controller
+    c.include Webrat::Matchers, :type => :view
+    c.include Webrat::Matchers, :type => :helper
+    c.include Webrat::Matchers, :type => :mailer
+
+    c.include Webrat::Methods,  :type => :request
+    c.include Webrat::Methods,  :type => :controller
+
+    module RequestInstanceMethods
+      def last_response
+        @response
+      end
+    end
+
+    c.include RequestInstanceMethods, :type => :request
+
+    c.before :type => :controller do
+      Webrat.configure {|w| w.mode = :rails}
+    end
+
+    c.before :type => :request do
+      Webrat.configure {|w| w.mode = :rack}
+    end
+  end
+end

data/support/gems/rspec-rails-2.11.0/lib/rspec/rails/version.rb

@@ -0,0 +1,7 @@
+module RSpec
+  module Rails
+    module Version
+      STRING = '2.11.0'
+    end
+  end
+end

data/support/gems/rspec-rails-2.11.0/lib/rspec/rails/view_assigns.rb

@@ -0,0 +1,45 @@
+module RSpec
+  module Rails
+    module ViewAssigns
+      # Assigns a value to an instance variable in the scope of the
+      # view being rendered.
+      #
+      # @example
+      #
+      #     assign(:widget, stub_model(Widget))
+      def assign(key, value)
+        _encapsulated_assigns[key] = value
+      end
+
+      def view_assigns
+        begin
+          # TODO: _assigns was deprecated in favor of view_assigns after
+          # Rails-3.0.0 was released. Since we are not able to predict when
+          # the _assigns/view_assigns patch will be released (I thought it
+          # would have been in 3.0.1, but 3.0.1 bypassed this change for a
+          # security fix), this bit ensures that we do the right thing without
+          # knowing anything about the Rails version we are dealing with.
+          #
+          # Once that change _is_ released, this can be changed to something
+          # that checks for the Rails version when the module is being
+          # interpreted, as it was before commit dd0095.
+          super.merge(_encapsulated_assigns)
+        rescue
+          _assigns
+        end
+      end
+
+      # @api private
+      def _assigns
+        super.merge(_encapsulated_assigns)
+      end
+
+      private
+
+      def _encapsulated_assigns
+        @_encapsulated_assigns ||= {}
+      end
+
+    end
+  end
+end