gem_repackager 0.1.0

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

@@ -0,0 +1 @@
+require 'rspec/rails/extensions/active_record/base'

data/support/gems/rspec-rails-2.11.0/lib/rspec/rails/extensions/active_record/base.rb

@@ -0,0 +1,45 @@
+module RSpec
+  module Rails
+    if defined?(ActiveRecord)
+      module Extensions
+        module ActiveRecord
+          # Extension to enhance `should have` on AR Model classes
+          #
+          # @example
+          #
+          #     ModelClass.should have(:no).records
+          #     ModelClass.should have(1).record
+          #     ModelClass.should have(n).records
+          def records
+            find(:all)
+          end
+          alias :record :records
+        end
+
+        class ::ActiveRecord::Base
+          extend RSpec::Rails::Extensions::ActiveRecord
+        end
+      end
+    end
+  end
+end
+
+module ::ActiveModel::Validations
+  # Extension to enhance `should have` on AR Model instances.  Calls
+  # model.valid? in order to prepare the object's errors object. 
+  #
+  # You can also use this to specify the content of the error messages.
+  #
+  # @example
+  #
+  #     model.should have(:no).errors_on(:attribute)
+  #     model.should have(1).error_on(:attribute)
+  #     model.should have(n).errors_on(:attribute)
+  #
+  #     model.errors_on(:attribute).should include("can't be blank")
+  def errors_on(attribute)
+    self.valid?
+    [self.errors[attribute]].flatten.compact
+  end
+  alias :error_on :errors_on
+end

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

@@ -0,0 +1,40 @@
+module RSpec
+  module Rails
+    if defined?(ActiveRecord::TestFixtures)
+      module FixtureSupport
+        extend ActiveSupport::Concern
+
+        include RSpec::Rails::SetupAndTeardownAdapter
+        include RSpec::Rails::TestUnitAssertionAdapter
+        include ActiveRecord::TestFixtures
+
+        included do
+          # TODO (DC 2011-06-25) this is necessary because fixture_file_upload
+          # accesses fixture_path directly on ActiveSupport::TestCase. This is
+          # fixed in rails by https://github.com/rails/rails/pull/1861, which
+          # should be part of the 3.1 release, at which point we can include
+          # these lines for rails < 3.1.
+          ActiveSupport::TestCase.class_eval do
+            include ActiveRecord::TestFixtures
+            self.fixture_path = RSpec.configuration.fixture_path
+          end
+          # /TODO
+
+          self.fixture_path = RSpec.configuration.fixture_path
+          self.use_transactional_fixtures = RSpec.configuration.use_transactional_fixtures
+          self.use_instantiated_fixtures  = RSpec.configuration.use_instantiated_fixtures
+          fixtures RSpec.configuration.global_fixtures if RSpec.configuration.global_fixtures
+        end
+      end
+
+      RSpec.configure do |c|
+        c.include RSpec::Rails::FixtureSupport
+        c.add_setting :use_transactional_fixtures, :alias_with => :use_transactional_examples
+        c.add_setting :use_instantiated_fixtures
+        c.add_setting :global_fixtures
+        c.add_setting :fixture_path
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,26 @@
+require 'rspec/core/deprecation'
+require 'rspec/expectations'
+
+module RSpec::Rails
+  module Matchers
+  end
+end
+
+begin
+  require 'test/unit/assertionfailederror'
+rescue LoadError
+  module Test
+    module Unit
+      class AssertionFailedError < StandardError
+      end
+    end
+  end
+end
+
+require 'rspec/rails/matchers/have_rendered'
+require 'rspec/rails/matchers/redirect_to'
+require 'rspec/rails/matchers/routing_matchers'
+require 'rspec/rails/matchers/be_new_record'
+require 'rspec/rails/matchers/be_a_new'
+require 'rspec/rails/matchers/have_extension'
+require 'rspec/rails/matchers/relation_match_array'

data/support/gems/rspec-rails-2.11.0/lib/rspec/rails/matchers/be_a_new.rb

@@ -0,0 +1,76 @@
+module RSpec::Rails::Matchers
+  class BeANew < RSpec::Matchers::BuiltIn::BaseMatcher
+
+    def initialize(expected)
+      @expected = expected
+    end
+
+    # @api private
+    def matches?(actual)
+      @actual = actual
+      actual.is_a?(expected) && actual.new_record? && attributes_match?(actual)
+    end
+
+    # Use this to specify the specific attributes to match on the new record.
+    #
+    # @example
+    #
+    #     it "assigns a new Thing with the submitted attributes" do
+    #       post :create, :thing => { :name => "Illegal Value" }
+    #       assigns(:thing).should be_a_new(Thing).with(:name => nil)
+    #     end
+    def with(expected_attributes)
+      attributes.merge!(expected_attributes)
+      self
+    end
+
+    # @api private
+    def failure_message_for_should
+      [].tap do |message|
+        unless actual.is_a?(expected) && actual.new_record?
+          message << "expected #{actual.inspect} to be a new #{expected.inspect}"
+        end
+        unless attributes_match?(actual)
+          if unmatched_attributes.size > 1
+            message << "attributes #{unmatched_attributes.inspect} were not set on #{actual.inspect}"
+          else
+            message << "attribute #{unmatched_attributes.inspect} was not set on #{actual.inspect}"
+          end
+        end
+      end.join(' and ')
+    end
+
+    private
+
+    def attributes
+      @attributes ||= {}
+    end
+
+    def attributes_match?(actual)
+      attributes.stringify_keys.all? do |key, value|
+        actual.attributes[key].eql?(value)
+      end
+    end
+
+    def unmatched_attributes
+      attributes.stringify_keys.reject do |key, value|
+        actual.attributes[key].eql?(value)
+      end
+    end
+  end
+
+  # Passes if actual is an instance of `model_class` and returns `false` for
+  # `persisted?`. Typically used to specify instance variables assigned to
+  # views by controller actions
+  #
+  # @example
+  #
+  #     get :new
+  #     assigns(:thing).should be_a_new(Thing)
+  #
+  #     post :create, :thing => { :name => "Illegal Value" }
+  #     assigns(:thing).should be_a_new(Thing).with(:name => nil)
+  def be_a_new(model_class)
+    BeANew.new(model_class)
+  end
+end

data/support/gems/rspec-rails-2.11.0/lib/rspec/rails/matchers/be_new_record.rb

@@ -0,0 +1,19 @@
+module RSpec::Rails::Matchers
+  class BeANewRecord < RSpec::Matchers::BuiltIn::BaseMatcher
+
+    # @api private
+    def matches?(actual)
+      !actual.persisted?
+    end
+  end
+
+  # Passes if actual returns `false` for `persisted?`.
+  #
+  # @example
+  #
+  #     get :new
+  #     assigns(:thing).should be_new_record
+  def be_new_record
+    BeANewRecord.new
+  end
+end

data/support/gems/rspec-rails-2.11.0/lib/rspec/rails/matchers/have_extension.rb

@@ -0,0 +1,35 @@
+require 'active_support/core_ext/module/aliasing'
+require 'rspec/matchers/built_in/have'
+
+module RSpec::Rails::Matchers
+  module HaveExtensions
+    extend ActiveSupport::Concern
+
+    # @api private
+    #
+    # Enhances the failure message for `should have(n)` matchers
+    def failure_message_for_should_with_errors_on_extensions
+      return "expected #{relativities[@relativity]}#{@expected} errors on :#{@args[0]}, got #{@actual}" if @collection_name == :errors_on
+      return "expected #{relativities[@relativity]}#{@expected} error on :#{@args[0]}, got #{@actual}"  if @collection_name == :error_on
+      return failure_message_for_should_without_errors_on_extensions
+    end
+
+    # @api private
+    #
+    # Enhances the description for `should have(n)` matchers
+    def description_with_errors_on_extensions
+      return "have #{relativities[@relativity]}#{@expected} errors on :#{@args[0]}" if @collection_name == :errors_on
+      return "have #{relativities[@relativity]}#{@expected} error on :#{@args[0]}"  if @collection_name == :error_on
+      return description_without_errors_on_extensions
+    end
+
+    included do
+      alias_method_chain :failure_message_for_should, :errors_on_extensions
+      alias_method_chain :description, :errors_on_extensions
+    end
+  end
+end
+
+RSpec::Matchers::BuiltIn::Have.class_eval do
+  include RSpec::Rails::Matchers::HaveExtensions
+end

data/support/gems/rspec-rails-2.11.0/lib/rspec/rails/matchers/have_rendered.rb

@@ -0,0 +1,40 @@
+module RSpec::Rails::Matchers
+  module RenderTemplate
+    class RenderTemplateMatcher < RSpec::Matchers::BuiltIn::BaseMatcher
+
+      def initialize(scope, expected, message=nil)
+        @expected = Symbol === expected ? expected.to_s : expected
+        @message = message
+        @scope = scope
+      end
+
+      # @api private
+      def matches?(*)
+        match_unless_raises ActiveSupport::TestCase::Assertion do
+          @scope.assert_template expected, @message
+        end
+      end
+
+      # @api private
+      def failure_message_for_should
+        rescued_exception.message
+      end
+
+      # @api private
+      def failure_message_for_should_not
+        "expected not to render #{expected.inspect}, but did"
+      end
+    end
+
+    # Delegates to `assert_template`
+    #
+    # @example
+    #
+    #     response.should have_rendered("new")
+    def have_rendered(options, message=nil)
+      RenderTemplateMatcher.new(self, options, message)
+    end
+
+    alias_method :render_template, :have_rendered
+  end
+end

data/support/gems/rspec-rails-2.11.0/lib/rspec/rails/matchers/redirect_to.rb

@@ -0,0 +1,37 @@
+module RSpec::Rails::Matchers
+  module RedirectTo
+    class RedirectTo < RSpec::Matchers::BuiltIn::BaseMatcher
+
+      def initialize(scope, expected)
+        @expected = expected
+        @scope = scope
+      end
+
+      # @api private
+      def matches?(_)
+        match_unless_raises ActiveSupport::TestCase::Assertion do
+          @scope.assert_redirected_to(@expected)
+        end
+      end
+
+      # @api private
+      def failure_message_for_should
+        rescued_exception.message
+      end
+
+      # @api private
+      def failure_message_for_should_not
+        "expected not to redirect to #{@expected.inspect}, but did"
+      end
+    end
+
+    # Delegates to `assert_redirected_to`
+    #
+    # @example
+    #
+    #     response.should redirect_to(:action => "new")
+    def redirect_to(target)
+      RedirectTo.new(self, target)
+    end
+  end
+end

data/support/gems/rspec-rails-2.11.0/lib/rspec/rails/matchers/relation_match_array.rb

@@ -0,0 +1,3 @@
+if defined?(ActiveRecord::Relation)
+  RSpec::Matchers::OperatorMatcher.register(ActiveRecord::Relation, '=~', RSpec::Matchers::BuiltIn::MatchArray)
+end

data/support/gems/rspec-rails-2.11.0/lib/rspec/rails/matchers/routing_matchers.rb

@@ -0,0 +1,107 @@
+module RSpec::Rails::Matchers
+  module RoutingMatchers
+    extend RSpec::Matchers::DSL
+
+    class RouteToMatcher < RSpec::Matchers::BuiltIn::BaseMatcher
+
+      def initialize(scope, *expected)
+        @scope = scope
+        @expected = expected[1] || {}
+        if Hash === expected[0]
+          @expected.merge!(expected[0])
+        else
+          controller, action = expected[0].split('#')
+          @expected.merge!(:controller => controller, :action => action)
+        end
+      end
+      
+      # @api private
+      def matches?(verb_to_path_map)
+        @actual = @verb_to_path_map = verb_to_path_map
+        # assert_recognizes does not consider ActionController::RoutingError an
+        # assertion failure, so we have to capture that and Assertion here.
+        match_unless_raises ActiveSupport::TestCase::Assertion, ActionController::RoutingError do
+          path, query = *verb_to_path_map.values.first.split('?')
+          @scope.assert_recognizes(
+            @expected,
+            {:method => verb_to_path_map.keys.first, :path => path},
+            Rack::Utils::parse_query(query)
+          )
+        end
+      end
+
+      # @api private
+      def failure_message_for_should
+        rescued_exception.message
+      end
+
+      def description
+        "route #{@actual.inspect} to #{@expected.inspect}"
+      end
+    end
+
+    # Delegates to `assert_recognizes`. Supports short-hand controller/action
+    # declarations (e.g. `"controller#action"`).
+    #
+    # @example
+    #
+    #     { :get => "/things/special" }.should route_to(
+    #       :controller => "things",
+    #       :action     => "special"
+    #     )
+    #
+    #     { :get => "/things/special" }.should route_to("things#special")
+    #
+    # @see http://api.rubyonrails.org/classes/ActionDispatch/Assertions/RoutingAssertions.html#method-i-assert_recognizes
+    def route_to(*expected)
+      RouteToMatcher.new(self, *expected)
+    end
+
+    class BeRoutableMatcher < RSpec::Matchers::BuiltIn::BaseMatcher
+
+      def initialize(scope)
+        @scope = scope
+      end
+
+      # @api private
+      def matches?(path)
+        @actual = path
+        match_unless_raises ActionController::RoutingError do
+          @routing_options = @scope.routes.recognize_path(
+            path.values.first, :method => path.keys.first
+          )
+        end
+      end
+
+      def failure_message_for_should
+        "expected #{@actual.inspect} to be routable"
+      end
+
+      def failure_message_for_should_not
+        "expected #{@actual.inspect} not to be routable, but it routes to #{@routing_options.inspect}"
+      end
+    end
+
+    # Passes if the route expression is recognized by the Rails router based on
+    # the declarations in `config/routes.rb`. Delegates to
+    # `RouteSet#recognize_path`.
+    #
+    # @example
+    #
+    # You can use route helpers provided by rspec-rails.
+    #     {:get =>  "/a/path"}.should be_routable
+    #     {:post => "/another/path"}.should be_routable
+    #     {:put => "/yet/another/path"}.should_not be_routable
+    def be_routable
+      BeRoutableMatcher.new(self)
+    end
+
+    module RouteHelpers
+      %w(get post put delete options head).each do |method|
+        define_method method do |path|
+          { method.to_sym => path }
+        end
+      end
+    end
+  end
+end