spree 0.0.7 → 0.0.8

data/starter-app/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions.rb

@@ -0,0 +1,12 @@
+require 'spec'
+
+require 'spec/rails/extensions/object'
+
+require 'spec/rails/extensions/spec/example/configuration'
+require 'spec/rails/extensions/spec/matchers/have'
+
+require 'spec/rails/extensions/active_record/base'
+require 'spec/rails/extensions/action_controller/base'
+require 'spec/rails/extensions/action_controller/rescue'
+require 'spec/rails/extensions/action_controller/test_response'
+require 'spec/rails/extensions/action_view/base'

data/starter-app/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/action_controller/base.rb

@@ -0,0 +1,14 @@
+module ActionController
+  class Base
+    class << self
+      def set_view_path(path)
+        [:append_view_path, :view_paths=, :template_root=].each do |method|
+          if respond_to?(method)
+            return send(method, path)
+          end
+        end
+      end
+    end
+  end
+end
+        

data/starter-app/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/action_controller/rescue.rb

@@ -0,0 +1,21 @@
+module ActionController
+  module Rescue
+    def use_rails_error_handling!
+      @use_rails_error_handling = true
+    end
+
+    def use_rails_error_handling?
+      @use_rails_error_handling ||= false
+    end
+
+    protected
+    def rescue_action_with_fast_errors(exception)
+      if use_rails_error_handling?
+        rescue_action_without_fast_errors exception
+      else
+        raise exception
+      end
+    end
+    alias_method_chain :rescue_action, :fast_errors
+  end
+end

data/starter-app/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/action_controller/test_response.rb

@@ -0,0 +1,11 @@
+module ActionController #:nodoc:
+  class TestResponse #:nodoc:
+    attr_writer :controller_path
+
+    def capture(name)
+      template.instance_variable_get "@content_for_#{name.to_s}"
+    end
+    alias [] capture
+
+  end
+end

data/starter-app/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/action_view/base.rb

@@ -0,0 +1,27 @@
+module ActionView #:nodoc:
+  class Base #:nodoc:
+    include Spec::Rails::Example::RenderObserver
+    cattr_accessor :base_view_path
+    def render_partial(partial_path, local_assigns = nil, deprecated_local_assigns = nil) #:nodoc:
+      if partial_path.is_a?(String)
+        unless partial_path.include?("/")
+          unless self.class.base_view_path.nil?
+            partial_path = "#{self.class.base_view_path}/#{partial_path}"
+          end
+        end
+      end
+      super(partial_path, local_assigns, deprecated_local_assigns)
+    end
+
+    alias_method :orig_render, :render
+    def render(options = {}, old_local_assigns = {}, &block)
+      if expect_render_mock_proxy.send(:__mock_proxy).send(:find_matching_expectation, :render, options)
+        expect_render_mock_proxy.render(options)
+      else
+        unless expect_render_mock_proxy.send(:__mock_proxy).send(:find_matching_method_stub, :render, options)
+          orig_render(options, old_local_assigns, &block)
+        end
+      end
+    end
+  end
+end

data/starter-app/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/active_record/base.rb

@@ -0,0 +1,30 @@
+if defined?(ActiveRecord::Base)
+  module ActiveRecord #:nodoc:
+    class Base
+
+      (class << self; self; end).class_eval do
+        # Extension for <tt>should have</tt> on AR Model classes
+        #
+        #   ModelClass.should have(:no).records
+        #   ModelClass.should have(1).record
+        #   ModelClass.should have(n).records
+        def records
+          find(:all)
+        end
+        alias :record :records
+      end
+
+      # Extension for <tt>should have</tt> on AR Model instances
+      #
+      #   model.should have(:no).errors_on(:attribute)
+      #   model.should have(1).error_on(:attribute)
+      #   model.should have(n).errors_on(:attribute)
+      def errors_on(attribute)
+        self.valid?
+        [self.errors.on(attribute)].flatten.compact
+      end
+      alias :error_on :errors_on
+
+    end
+  end
+end

data/starter-app/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/object.rb

@@ -0,0 +1,5 @@
+class Object # :nodoc:
+  def self.path2class(klassname)
+    klassname.split('::').inject(Object) { |k,n| k.const_get n }
+  end
+end

data/starter-app/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/spec/example/configuration.rb

@@ -0,0 +1,66 @@
+require 'spec/example/configuration'
+
+module Spec
+  module Example
+    class Configuration
+      # Rails 1.2.3 does a copy of the @inheritable_attributes to the subclass when the subclass is
+      # created. This causes an ordering issue when setting state on Configuration because the data is
+      # already copied.
+      # Iterating over EXAMPLE_GROUP_CLASSES causes the base ExampleGroup classes to have their
+      # @inheritable_attributes updated.
+      # TODO: BT - When we no longer support Rails 1.2.3, we can remove this functionality
+      EXAMPLE_GROUP_CLASSES = [
+        ::Test::Unit::TestCase,
+        ::Spec::Rails::Example::RailsExampleGroup,
+        ::Spec::Rails::Example::FunctionalExampleGroup,
+        ::Spec::Rails::Example::ControllerExampleGroup,
+        ::Spec::Rails::Example::ViewExampleGroup,
+        ::Spec::Rails::Example::HelperExampleGroup,
+        ::Spec::Rails::Example::ModelExampleGroup
+      ]
+      # All of this is ActiveRecord related and makes no sense if it's not used by the app
+      if defined?(ActiveRecord::Base)
+        def initialize
+          super
+          self.fixture_path = RAILS_ROOT + '/spec/fixtures'
+        end
+
+        def use_transactional_fixtures
+          Test::Unit::TestCase.use_transactional_fixtures
+        end
+        def use_transactional_fixtures=(value)
+          EXAMPLE_GROUP_CLASSES.each do |example_group|
+            example_group.use_transactional_fixtures = value
+          end
+        end
+
+        def use_instantiated_fixtures
+          Test::Unit::TestCase.use_instantiated_fixtures
+        end
+        def use_instantiated_fixtures=(value)
+          EXAMPLE_GROUP_CLASSES.each do |example_group|
+            example_group.use_instantiated_fixtures = value
+          end
+        end
+
+        def fixture_path
+          Test::Unit::TestCase.fixture_path
+        end
+        def fixture_path=(path)
+          EXAMPLE_GROUP_CLASSES.each do |example_group|
+            example_group.fixture_path = path
+          end
+        end
+
+        def global_fixtures
+          ::Test::Unit::TestCase.fixture_table_names
+        end
+        def global_fixtures=(fixtures)
+          EXAMPLE_GROUP_CLASSES.each do |example_group|
+            example_group.fixtures(*fixtures)
+          end
+        end
+      end
+    end
+  end
+end

data/starter-app/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions/spec/matchers/have.rb

@@ -0,0 +1,21 @@
+require 'spec/matchers/have'
+
+module Spec #:nodoc:
+  module Matchers #:nodoc:
+    class Have #:nodoc:
+      alias_method :__original_failure_message, :failure_message
+      def failure_message
+        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 __original_failure_message
+      end
+      
+      alias_method :__original_description, :description
+      def description
+        return "should have #{relativities[@relativity]}#{@expected} errors on :#{@args[0]}" if @collection_name == :errors_on
+        return "should have #{relativities[@relativity]}#{@expected} error on :#{@args[0]}" if @collection_name == :error_on
+        return __original_description
+      end
+    end
+  end
+end

data/starter-app/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers.rb

@@ -0,0 +1,29 @@
+dir = File.dirname(__FILE__)
+require 'spec/rails/matchers/assert_select'
+require 'spec/rails/matchers/have_text'
+require 'spec/rails/matchers/redirect_to'
+require 'spec/rails/matchers/render_template'
+
+module Spec
+  module Rails
+    # Spec::Rails::Expectations::Matchers provides several expectation matchers
+    # intended to work with Rails components like models and responses. For example:
+    #
+    #   response.should redirect_to("some/url") #redirect_to(url) is the matcher.
+    #
+    # In addition to those you see below, the arbitrary predicate feature of RSpec
+    # makes the following available as well:
+    #
+    #   response.should be_success #passes if response.success?
+    #   response.should be_redirect #passes if response.redirect?
+    #
+    # Note that many of these matchers are part of a wrapper of <tt>assert_select</tt>, so
+    # the documentation comes straight from that with some slight modifications.
+    # <tt>assert_select</tt> is a Test::Unit extension originally contributed to the
+    # Rails community as a plugin by Assaf Arkin and eventually shipped as part of Rails.
+    #
+    # For more info on <tt>assert_select</tt>, see the relevant Rails documentation.
+    module Matchers
+    end
+  end
+end

data/starter-app/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers/assert_select.rb

@@ -0,0 +1,130 @@
+# This is a wrapper of assert_select for rspec.
+
+module Spec # :nodoc:
+  module Rails
+    module Matchers
+
+      class AssertSelect #:nodoc:
+
+        def initialize(assertion, spec_scope, *args, &block)
+          @assertion = assertion
+          @spec_scope = spec_scope
+          @args = args
+          @block = block
+        end
+        
+        def matches?(response_or_text, &block)
+          if ActionController::TestResponse === response_or_text and
+                   response_or_text.headers.key?('Content-Type') and
+                   response_or_text.headers['Content-Type'].to_sym == :xml
+            @args.unshift(HTML::Document.new(response_or_text.body, false, true).root)           
+          elsif String === response_or_text
+            @args.unshift(HTML::Document.new(response_or_text).root)
+          end
+          @block = block if block
+          begin
+            @spec_scope.send(@assertion, *@args, &@block)
+          rescue ::Test::Unit::AssertionFailedError => @error
+          end
+          
+          @error.nil?
+        end
+
+        def failure_message; @error.message; end
+        def negative_failure_message; "should not #{description}, but did"; end
+
+        def description
+          {
+            :assert_select => "have tag#{format_args(*@args)}",
+            :assert_select_email => "send email#{format_args(*@args)}",
+          }[@assertion]
+        end
+
+      private
+
+        def format_args(*args)
+          return "" if args.empty?
+          return "(#{arg_list(*args)})"
+        end
+
+        def arg_list(*args)
+          args.collect do |arg|
+            arg.respond_to?(:description) ? arg.description : arg.inspect
+          end.join(", ")
+        end
+        
+      end
+      
+      # :call-seq:
+      #   response.should have_tag(*args, &block)
+      #   string.should have_tag(*args, &block)
+      #
+      # wrapper for assert_select with additional support for using
+      # css selectors to set expectation on Strings. Use this in
+      # helper specs, for example, to set expectations on the results
+      # of helper methods.
+      #
+      # == Examples
+      #
+      #   # in a controller spec
+      #   response.should have_tag("div", "some text")
+      #
+      #   # in a helper spec (person_address_tag is a method in the helper)
+      #   person_address_tag.should have_tag("input#person_address")
+      #
+      # see documentation for assert_select at http://api.rubyonrails.org/
+      def have_tag(*args, &block)
+        AssertSelect.new(:assert_select, self, *args, &block)
+      end
+    
+      # wrapper for a nested assert_select
+      #
+      #   response.should have_tag("div#form") do
+      #     with_tag("input#person_name[name=?]", "person[name]")
+      #   end
+      #
+      # see documentation for assert_select at http://api.rubyonrails.org/
+      def with_tag(*args, &block)
+        should have_tag(*args, &block)
+      end
+    
+      # wrapper for a nested assert_select with false
+      #
+      #   response.should have_tag("div#1") do
+      #     without_tag("span", "some text that shouldn't be there")
+      #   end
+      #
+      # see documentation for assert_select at http://api.rubyonrails.org/
+      def without_tag(*args, &block)
+        should_not have_tag(*args, &block)
+      end
+    
+      # :call-seq:
+      #   response.should have_rjs(*args, &block)
+      #
+      # wrapper for assert_select_rjs
+      #
+      # see documentation for assert_select_rjs at http://api.rubyonrails.org/
+      def have_rjs(*args, &block)
+        AssertSelect.new(:assert_select_rjs, self, *args, &block)
+      end
+      
+      # :call-seq:
+      #   response.should send_email(*args, &block)
+      #
+      # wrapper for assert_select_email
+      #
+      # see documentation for assert_select_email at http://api.rubyonrails.org/
+      def send_email(*args, &block)
+        AssertSelect.new(:assert_select_email, self, *args, &block)
+      end
+      
+      # wrapper for assert_select_encoded
+      #
+      # see documentation for assert_select_encoded at http://api.rubyonrails.org/
+      def with_encoded(*args, &block)
+        should AssertSelect.new(:assert_select_encoded, self, *args, &block)
+      end
+    end
+  end
+end

data/starter-app/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers/have_text.rb

@@ -0,0 +1,55 @@
+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 =~.
+      #
+      # Use this instead of <tt>response.should have_tag()</tt>
+      # when you either don't know or don't care where on the page
+      # this text appears.
+      #
+      # == Examples
+      #
+      #   response.should have_text("This is the expected text")
+      def have_text(text)
+        HaveText.new(text)
+      end
+    
+    end
+  end
+end

data/starter-app/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers/redirect_to.rb

@@ -0,0 +1,113 @@
+module Spec
+  module Rails
+    module Matchers
+
+      class RedirectTo  #:nodoc:
+
+        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.instance_of? Hash
+            return false unless @actual =~ %r{^\w+://#{@request.host}}
+            return false unless actual_redirect_to_valid_route
+            return actual_hash == expected_hash
+          else
+            return @actual == expected_url
+          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}}, "").split("?", 2)[0]
+          ActionController::Routing::Routes.recognize_path path
+        end
+
+        def query_hash(url)
+          query = url.split("?", 2)[1] || ""
+          QueryParameterParser.parse_query_parameters(query, @request)
+        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
+            return %Q{expected redirect to #{@expected.inspect}, got redirect to #{@actual.inspect}}
+          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 #{@actual.inspect}"
+        end
+
+        class QueryParameterParser
+          def self.parse_query_parameters(query, request)
+            if defined?(CGIMethods)
+              CGIMethods.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