spree 0.8.1 → 0.8.2

data/vendor/plugins/rspec-rails/lib/spec/rails/matchers/change.rb

@@ -1,11 +0,0 @@
-module Spec
-  module Matchers
-    class Change
-      def evaluate_value_proc_with_ensured_evaluation_of_proxy
-        value = evaluate_value_proc_without_ensured_evaluation_of_proxy
-        ActiveRecord::Associations::AssociationProxy === value ? value.dup : value
-      end
-      alias_method_chain :evaluate_value_proc, :ensured_evaluation_of_proxy
-    end
-  end
-end

data/vendor/plugins/rspec-rails/lib/spec/rails/matchers/have_text.rb

@@ -1,57 +0,0 @@
-module Spec
-  module Rails
-    module Matchers
-    
-      class HaveText  #:nodoc:
-
-        def initialize(expected)
-          @expected = expected
-        end
-
-        def matches?(response_or_text)
-          @actual = response_or_text.respond_to?(:body) ? response_or_text.body : response_or_text
-          return actual =~ expected if Regexp === expected
-          return actual == expected unless Regexp === expected
-        end
-      
-        def failure_message
-          "expected #{expected.inspect}, got #{actual.inspect}"
-        end
-        
-        def negative_failure_message
-          "expected not to have text #{expected.inspect}"
-        end
-        
-        def to_s
-          "have text #{expected.inspect}"
-        end
-      
-        private
-          attr_reader :expected
-          attr_reader :actual
-
-      end
-
-      # :call-seq:
-      #   response.should have_text(expected)
-      #   response.should_not have_text(expected)
-      #
-      # Accepts a String or a Regexp, matching a String using ==
-      # and a Regexp using =~.
-      #
-      # If response_or_text has a #body, then that is used as to match against
-      # else it uses response_or_text
-      #
-      # Use this instead of <tt>response.should have_tag()</tt>
-      # when you want to match the whole string or whole body
-      #
-      # == Examples
-      #
-      #   response.should have_text("This is the expected text")
-      def have_text(text)
-        HaveText.new(text)
-      end
-    
-    end
-  end
-end

data/vendor/plugins/rspec-rails/lib/spec/rails/matchers/include_text.rb

@@ -1,54 +0,0 @@
-module Spec
-  module Rails
-    module Matchers
-
-      class IncludeText  #:nodoc:
-
-        def initialize(expected)
-          @expected = expected
-        end
-
-        def matches?(response_or_text)
-          @actual = response_or_text.respond_to?(:body) ? response_or_text.body : response_or_text
-          return actual.include?(expected)
-        end
-
-        def failure_message
-          "expected to find #{expected.inspect} in #{actual.inspect}"
-        end
-
-        def negative_failure_message
-          "expected not to include text #{expected.inspect}"
-        end
-
-        def to_s
-          "include text #{expected.inspect}"
-        end
-
-        private
-          attr_reader :expected
-          attr_reader :actual
-
-      end
-
-
-      # :call-seq:
-      #   response.should include_text(expected)
-      #   response.should_not include_text(expected)
-      #
-      # Accepts a String, matching using include?
-      #
-      # Use this instead of <tt>response.should have_text()</tt>
-      # when you either don't know or don't care where on the page
-      # this text appears.
-      #
-      # == Examples
-      #
-      #   response.should include_text("This text will be in the actual string")
-      def include_text(text)
-        IncludeText.new(text)
-      end
-
-    end
-  end
-end

data/vendor/plugins/rspec-rails/lib/spec/rails/matchers/redirect_to.rb

@@ -1,134 +0,0 @@
-module Spec
-  module Rails
-    module Matchers
-
-      class RedirectTo  #:nodoc:
-
-        include ActionController::StatusCodes
-
-        def initialize(request, expected)
-          @expected = expected
-          @request = request
-        end
-
-        def matches?(response)
-          @redirected = response.redirect?
-          @actual = response.redirect_url
-          return false unless @redirected
-
-          if @expected_status
-            @actual_status = interpret_status(response.code.to_i)
-            @status_matched = @expected_status == @actual_status
-          else
-            @status_matched = true
-          end
-
-          if @expected.instance_of? Hash
-            return false unless @actual =~ %r{^\w+://#{@request.host}}
-            return false unless actual_redirect_to_valid_route
-            return actual_hash == expected_hash && @status_matched
-          else
-            return @actual == expected_url && @status_matched
-          end
-        end
-
-        def actual_hash
-          hash_from_url @actual
-        end
-
-        def expected_hash
-          hash_from_url expected_url
-        end
-
-        def actual_redirect_to_valid_route
-          actual_hash
-        end
-
-        def hash_from_url(url)
-          query_hash(url).merge(path_hash(url)).with_indifferent_access
-        end
-
-        def path_hash(url)
-          path = url.sub(%r{^\w+://#{@request.host}(?::\d+)?}, "").split("?", 2)[0]
-          ActionController::Routing::Routes.recognize_path path, { :method => :get }
-        end
-
-        def query_hash(url)
-          query = url.split("?", 2)[1] || ""
-          QueryParameterParser.parse_query_parameters(query, @request)
-        end
-
-        def with(options)
-          @expected_status = interpret_status(options[:status])
-          self
-        end
-        
-       def expected_url
-          case @expected
-            when Hash
-              return ActionController::UrlRewriter.new(@request, {}).rewrite(@expected)
-            when :back
-              return @request.env['HTTP_REFERER']
-            when %r{^\w+://.*}
-              return @expected
-            else
-              return "http://#{@request.host}" + (@expected.split('')[0] == '/' ? '' : '/') + @expected
-          end
-        end
-
-        def failure_message
-          if @redirected
-            if @status_matched
-              return %Q{expected redirect to #{@expected.inspect}, got redirect to #{@actual.inspect}}
-            else
-              return %Q{expected redirect to #{@expected.inspect} with status #{@expected_status}, got #{@actual_status}}
-            end
-          else
-            return %Q{expected redirect to #{@expected.inspect}, got no redirect}
-          end
-        end
-
-        def negative_failure_message
-            return %Q{expected not to be redirected to #{@expected.inspect}, but was} if @redirected
-        end
-
-        def description
-          "redirect to #{@expected.inspect}"
-        end
-
-        class QueryParameterParser
-          def self.parse_query_parameters(query, request)
-            if defined?(CGIMethods)
-              CGIMethods.parse_query_parameters(query)
-            elsif defined?(ActionController::RequestParser)
-              ActionController::RequestParser.parse_query_parameters(query)
-            else
-              request.class.parse_query_parameters(query)
-            end
-          end
-        end
-      end
-
-      # :call-seq:
-      #   response.should redirect_to(url)
-      #   response.should redirect_to(:action => action_name)
-      #   response.should redirect_to(:controller => controller_name, :action => action_name)
-      #   response.should_not redirect_to(url)
-      #   response.should_not redirect_to(:action => action_name)
-      #   response.should_not redirect_to(:controller => controller_name, :action => action_name)
-      #
-      # Passes if the response is a redirect to the url, action or controller/action.
-      # Useful in controller specs (integration or isolation mode).
-      #
-      # == Examples
-      #
-      #   response.should redirect_to("path/to/action")
-      #   response.should redirect_to("http://test.host/path/to/action")
-      #   response.should redirect_to(:action => 'list')
-      def redirect_to(opts)
-        RedirectTo.new(request, opts)
-      end
-    end
-
-  end
-end

data/vendor/plugins/rspec-rails/lib/spec/rails/matchers/render_template.rb

@@ -1,110 +0,0 @@
-module Spec
-  module Rails
-    module Matchers
-    
-      class RenderTemplate #:nodoc:
-    
-        def initialize(expected, controller)
-          @controller = controller
-          @expected = expected
-        end
-      
-        def matches?(response)
-          if response.respond_to?(:rendered_file)
-            @actual = response.rendered_file
-          elsif response.respond_to?(:rendered)
-            case template = response.rendered[:template]
-            when nil
-              unless response.rendered[:partials].empty?
-                @actual = path_and_file(response.rendered[:partials].keys.first).join("/_")
-              end
-            when ActionView::Template
-              @actual = template.path
-            when String
-              @actual = template
-            end
-          else
-            @actual = response.rendered_template.to_s
-          end
-          return false if @actual.blank?
-          given_controller_path, given_file = path_and_file(@actual)
-          expected_controller_path, expected_file = path_and_file(@expected)
-          given_controller_path == expected_controller_path && given_file.match(expected_file)
-        end
-        
-        def failure_message
-          "expected #{@expected.inspect}, got #{@actual.inspect}"
-        end
-        
-        def negative_failure_message
-          "expected not to render #{@expected.inspect}, but did"
-        end
-        
-        def description
-          "render template #{@expected.inspect}"
-        end
-      
-        private
-          def path_and_file(path)
-            parts = path.split('/')
-            file = parts.pop
-            controller = parts.empty? ? current_controller_path : parts.join('/')
-            return controller, file
-          end
-        
-          def controller_path_from(path)
-            parts = path.split('/')
-            parts.pop
-            parts.join('/')
-          end
-
-          def current_controller_path
-            @controller.class.to_s.underscore.gsub(/_controller$/,'')
-          end
-        
-      end
-      
-      # :call-seq:
-      #   response.should render_template(template)
-      #   response.should_not render_template(template)
-      #
-      # For use in controller code examples (integration or isolation mode).
-      #
-      # Passes if the specified template (view file) is rendered by the
-      # response. This file can be any view file, including a partial. However
-      # if it is a partial it must be rendered directly i.e. you can't detect
-      # that a partial has been rendered as part of a view using
-      # render_template. For that you should use a message expectation
-      # (mock) instead:
-      #
-      #   controller.should_receive(:render).with(:partial => 'path/to/partial')
-      #
-      # <code>template</code> can include the controller path. It can also
-      # include an optional extension, which you only need to use when there
-      # is ambiguity.
-      #
-      # Note that partials must be spelled with the preceding underscore.
-      #
-      # == Examples
-      #
-      #   response.should render_template('list')
-      #   response.should render_template('same_controller/list')
-      #   response.should render_template('other_controller/list')
-      #
-      #   # with extensions
-      #   response.should render_template('list.rjs')
-      #   response.should render_template('list.haml')
-      #   response.should render_template('same_controller/list.rjs')
-      #   response.should render_template('other_controller/list.rjs')
-      #
-      #   # partials
-      #   response.should render_template('_a_partial')
-      #   response.should render_template('same_controller/_a_partial')
-      #   response.should render_template('other_controller/_a_partial')
-      def render_template(path)
-        RenderTemplate.new(path.to_s, @controller)
-      end
-
-    end
-  end
-end

data/vendor/plugins/rspec-rails/lib/spec/rails/mocks.rb

@@ -1,135 +0,0 @@
-module Spec
-  module Rails
-
-    class IllegalDataAccessException < StandardError; end
-
-    module Mocks
-      
-      # Creates a mock object instance for a +model_class+ with common
-      # methods stubbed out. Additional methods may be easily stubbed (via
-      # add_stubs) if +stubs+ is passed.
-      def mock_model(model_class, options_and_stubs = {})
-        id = options_and_stubs[:id] || next_id
-        options_and_stubs = options_and_stubs.reverse_merge({
-          :id => id,
-          :to_param => id.to_s,
-          :new_record? => false,
-          :errors => stub("errors", :count => 0)
-        })
-        m = mock("#{model_class.name}_#{id}", options_and_stubs)
-        m.send(:__mock_proxy).instance_eval <<-CODE
-          def @target.as_new_record
-            self.stub!(:id).and_return nil
-            self.stub!(:to_param).and_return nil
-            self.stub!(:new_record?).and_return true
-            self
-          end
-          def @target.is_a?(other)
-            #{model_class}.ancestors.include?(other)
-          end
-          def @target.kind_of?(other)
-            #{model_class}.ancestors.include?(other)
-          end
-          def @target.instance_of?(other)
-            other == #{model_class}
-          end
-          def @target.class
-            #{model_class}
-          end
-        CODE
-        yield m if block_given?
-        m
-      end
-      
-      module ModelStubber
-        def connection
-          raise Spec::Rails::IllegalDataAccessException.new("stubbed models are not allowed to access the database")
-        end
-        def new_record?
-          id.nil?
-        end
-        def as_new_record
-          self.id = nil
-          self
-        end
-      end
-
-      # :call-seq:
-      #   stub_model(Model)
-      #   stub_model(Model).as_new_record
-      #   stub_model(Model, hash_of_stubs)
-      #   stub_model(Model, instance_variable_name, hash_of_stubs)
-      #
-      # Creates an instance of +Model+ that is prohibited from accessing the
-      # database*. For each key in +hash_of_stubs+, if the model has a
-      # matching attribute (determined by asking it) are 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>new_record?</tt> is overridden to return the result of id.nil?
-      # This means that by default new_record? will return false. 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 new_record? will return true, 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.
-      #
-      # == Database Independence
-      #
-      # +stub_model+ does not make your examples entirely
-      # database-independent. It does not stop the model class itself from
-      # loading up its columns from the database. It just prevents data access
-      # from the object itself. To completely decouple from the database, take
-      # a look at libraries like unit_record or NullDB.
-      #
-      # == Examples
-      #
-      #   stub_model(Person)
-      #   stub_model(Person).as_new_record
-      #   stub_model(Person, :id => 37)
-      #   stub_model(Person) do |person|
-      #     person.first_name = "David"
-      #   end
-      def stub_model(model_class, stubs={})
-        stubs = {:id => next_id}.merge(stubs)
-        returning model_class.new do |model|
-          model.id = stubs.delete(:id)
-          model.extend ModelStubber
-          stubs.each do |k,v|
-            if model.has_attribute?(k)
-              model[k] = stubs.delete(k)
-            end
-          end
-          model.stub!(stubs)
-          yield model if block_given?
-        end
-      end
-      
-      # DEPRECATED - use object.stub!(:method => value, :method2 => value)
-      #
-      # Stubs methods on +object+ (if +object+ is a symbol or string a new mock
-      # with that name will be created). +stubs+ is a Hash of +method=>value+
-      def add_stubs(object, stubs = {}) #:nodoc:
-        Kernel.warn <<-WARNING
-DEPRECATION NOTICE: add_stubs is deprecated and will be removed
-from a future version of rspec-rails. Use this instead:
-  
-  object.stub!(:method => value, :method2 => value)
-  
-WARNING
-        object.stub!(stubs)
-      end
-
-      private
-        @@model_id = 1000
-        def next_id
-          @@model_id += 1
-        end
-
-    end
-  end
-end