spree 0.8.1 → 0.8.2

data/vendor/plugins/rspec-rails/lib/spec/rails/example/cookies_proxy.rb

@@ -1,29 +0,0 @@
-require 'action_controller/cookies'
-
-module Spec
-  module Rails
-    module Example
-      class CookiesProxy
-        def initialize(example)
-          @example = example
-        end
-      
-        def[]=(name, value)
-          if ::Rails::VERSION::STRING >= '2.3'
-            @example.request.cookies[name.to_s] = value
-          else
-            @example.request.cookies[name.to_s] = CGI::Cookie.new(name.to_s, value)
-          end
-        end
-        
-        def [](name)
-          @example.response.cookies[name.to_s]
-        end
-      
-        def delete(name)
-          @example.response.cookies.delete(name.to_s)
-        end
-      end
-    end
-  end
-end

data/vendor/plugins/rspec-rails/lib/spec/rails/example/functional_example_group.rb

@@ -1,90 +0,0 @@
-module Spec
-  module Rails
-    module Example
-      class FunctionalExampleGroup < RailsExampleGroup
-        include ActionController::TestProcess
-        include ActionController::Assertions
-
-        attr_reader :request, :response
-        before(:each) do
-          @controller_class = @controller_class_name.split('::').inject(Object) { |k,n| k.const_get n }
-          raise "Can't determine controller class for #{@controller_class_name}" if @controller_class.nil?
-
-          @controller = @controller_class.new
-          @request = ActionController::TestRequest.new
-          @response = ActionController::TestResponse.new
-          @response.session = @request.session
-        end
-        
-        def params
-          request.parameters
-        end
-
-        def flash
-          @controller.__send__ :flash
-        end
-
-        def session
-          response.session
-        end
-        
-        # Overrides the <tt>cookies()</tt> method in
-        # ActionController::TestResponseBehaviour, returning a proxy that
-        # accesses the requests cookies when setting a cookie and the
-        # responses cookies when reading one. This allows you to set and read
-        # cookies in examples using the same API with which you set and read
-        # them in controllers.
-        #
-        # == Examples (Rails 2.0 > 2.2)
-        #
-        #   cookies[:user_id] = {:value => '1234', :expires => 1.minute.ago}
-        #   get :index
-        #   response.should be_redirect
-        #
-        # == Examples (Rails 2.3)
-        #
-        # Rails 2.3 changes the way cookies are made available to functional
-        # tests (and therefore rspec controller specs), only making single
-        # values available with no access to other aspects of the cookie. This
-        # is backwards-incompatible, so you have to change your examples to
-        # look like this:
-        #
-        #   cookies[:foo] = 'bar'
-        #   get :index
-        #   cookies[:foo].should == 'bar'
-        def cookies
-          @cookies ||= Spec::Rails::Example::CookiesProxy.new(self)
-        end
-        
-        alias_method :orig_assigns, :assigns
-
-        # :call-seq:
-        #   assigns()
-        #
-        # Hash of instance variables to values that are made available to
-        # views. == Examples
-        #
-        #   #in thing_controller.rb
-        #   def new
-        #     @thing = Thing.new
-        #   end
-        #
-        #   #in thing_controller_spec
-        #   get 'new'
-        #   assigns[:registration].should == Thing.new
-        #--
-        # NOTE - Even though docs only use assigns[:key] format, this supports
-        # assigns(:key) for backwards compatibility.
-        #++
-        def assigns(key = nil)
-          if key.nil?
-            _assigns_hash_proxy
-          else
-            _assigns_hash_proxy[key]
-          end
-        end
-
-      end
-    end
-  end
-end

data/vendor/plugins/rspec-rails/lib/spec/rails/example/helper_example_group.rb

@@ -1,171 +0,0 @@
-module Spec
-  module Rails
-    module Example
-      # Helper Specs live in $RAILS_ROOT/spec/helpers/.
-      #
-      # Helper Specs use Spec::Rails::Example::HelperExampleGroup, which allows you to
-      # include your Helper directly in the context and write specs directly
-      # against its methods.
-      #
-      # HelperExampleGroup also includes the standard lot of ActionView::Helpers in case your
-      # helpers rely on any of those.
-      #
-      # == Example
-      #
-      #   class ThingHelper
-      #     def number_of_things
-      #       Thing.count
-      #     end
-      #   end
-      #
-      #   describe "ThingHelper example_group" do
-      #     include ThingHelper
-      #     it "should tell you the number of things" do
-      #       Thing.should_receive(:count).and_return(37)
-      #       number_of_things.should == 37
-      #     end
-      #   end
-      class HelperExampleGroup < FunctionalExampleGroup
-        attr_accessor :output_buffer
-        
-        class HelperObject < ActionView::Base
-          def protect_against_forgery?
-            false
-          end
-          
-          def session=(session)
-            @session = session
-          end
-          
-          def request=(request)
-            @request = request
-          end
-          
-          def flash=(flash)
-            @flash = flash
-          end
-          
-          def params=(params)
-            @params = params
-          end
-          
-          def controller=(controller)
-            @controller = controller
-          end
-          
-          private
-            attr_reader :session, :request, :flash, :params, :controller
-        end
-        
-        class << self
-          # The helper name....
-          def helper_name(name=nil)
-            @helper_being_described = "#{name}_helper".camelize.constantize
-            send :include, @helper_being_described
-          end
-          
-          def helper
-            @helper_object ||= returning HelperObject.new do |helper_object|
-              if @helper_being_described.nil?
-                if described_type.class == Module
-                  helper_object.extend described_type
-                end
-              else
-                helper_object.extend @helper_being_described
-              end
-            end
-          end
-        end
-        
-        # Returns an instance of ActionView::Base with the helper being spec'd
-        # included.
-        #
-        # == Example
-        #
-        #   describe PersonHelper do
-        #     it "should write a link to person with the name" do
-        #       assigns[:person] = mock_model(Person, :full_name => "Full Name", :id => 37, :new_record? => false)
-        #       helper.link_to_person.should == %{<a href="/people/37">Full Name</a>}
-        #     end
-        #   end
-        #
-        #   module PersonHelper
-        #     def link_to_person
-        #       link_to person.full_name, url_for(person)
-        #     end
-        #   end
-        #
-        def helper
-          self.class.helper
-        end
-        
-        def orig_assigns
-          helper.assigns
-        end
-        
-        # Reverse the load order so that custom helpers which are defined last
-        # are also loaded last.
-        ActionView::Base.included_modules.reverse.each do |mod|
-          include mod if mod.parents.include?(ActionView::Helpers)
-        end
-
-        before(:all) do
-          @controller_class_name = 'Spec::Rails::Example::HelperExampleGroupController'
-        end
-
-        before(:each) do
-          @controller.request = @request
-          @controller.url = ActionController::UrlRewriter.new @request, {} # url_for
-
-          @flash = ActionController::Flash::FlashHash.new
-          session['flash'] = @flash
-          
-          @output_buffer = ""
-          @template = helper
-          ActionView::Helpers::AssetTagHelper::reset_javascript_include_default
-          
-          helper.session = session
-          helper.request = @request
-          helper.flash = flash
-          helper.params = params
-          helper.controller = @controller
-        end
-
-        def flash
-          @flash
-        end
-
-        def eval_erb(text)
-          erb_args = [text]
-          if helper.respond_to?(:output_buffer)
-            erb_args += [nil, nil, '@output_buffer']
-          end
-          
-          helper.instance_eval do
-            ERB.new(*erb_args).result(binding)
-          end
-        end
-
-        # TODO: BT - Helper Examples should proxy method_missing to a Rails View instance.
-        # When that is done, remove this method
-        def protect_against_forgery?
-          false
-        end
-
-        Spec::Example::ExampleGroupFactory.register(:helper, self)
-
-        protected
-        def _assigns_hash_proxy
-          @_assigns_hash_proxy ||= AssignsHashProxy.new self do
-            helper
-          end
-        end
-
-      end
-
-      class HelperExampleGroupController < ApplicationController #:nodoc:
-        attr_accessor :request, :url
-      end
-    end
-  end
-end

data/vendor/plugins/rspec-rails/lib/spec/rails/example/model_example_group.rb

@@ -1,14 +0,0 @@
-module Spec
-  module Rails
-    module Example
-      # Model examples live in $RAILS_ROOT/spec/models/.
-      #
-      # Model examples use Spec::Rails::Example::ModelExampleGroup, which
-      # provides support for fixtures and some custom expectations via extensions
-      # to ActiveRecord::Base.
-      class ModelExampleGroup < RailsExampleGroup
-        Spec::Example::ExampleGroupFactory.register(:model, self)
-      end
-    end
-  end
-end

data/vendor/plugins/rspec-rails/lib/spec/rails/example/rails_example_group.rb

@@ -1,28 +0,0 @@
-require 'spec/interop/test'
-
-if ActionView::Base.respond_to?(:cache_template_extension)
-  ActionView::Base.cache_template_extensions = false
-end
-
-module Spec
-  module Rails
-
-    module Example
-      if ActiveSupport.const_defined?(:TestCase)
-        class RailsExampleGroup < ActiveSupport::TestCase
-          include ActionController::Assertions::SelectorAssertions
-        end
-      else
-        class RailsExampleGroup < Test::Unit::TestCase
-        end
-      end
-      
-      class RailsExampleGroup
-        include Spec::Rails::Matchers
-        include Spec::Rails::Mocks
-        Spec::Example::ExampleGroupFactory.default(self)
-      end
-      
-    end
-  end
-end

data/vendor/plugins/rspec-rails/lib/spec/rails/example/render_observer.rb

@@ -1,93 +0,0 @@
-require 'spec/mocks/framework'
-
-module Spec
-  module Rails
-    module Example
-      # Extends the #should_receive, #should_not_receive and #stub! methods in rspec's
-      # mocking framework to handle #render calls to controller in controller examples
-      # and template and view examples
-      module RenderObserver
-
-        # DEPRECATED
-        #
-        # Use should_receive(:render).with(opts) instead
-        def expect_render(opts={})
-          warn_deprecation("expect_render", "should_receive")
-          register_verify_after_each
-          render_proxy.should_receive(:render, :expected_from => caller(1)[0]).with(opts)
-        end
-
-        # DEPRECATED
-        #
-        # Use stub!(:render).with(opts) instead
-        def stub_render(opts={})
-          warn_deprecation("stub_render", "stub!")
-          register_verify_after_each
-          render_proxy.stub!(:render, :expected_from => caller(1)[0]).with(opts)
-        end
-        
-        def warn_deprecation(deprecated_method, new_method)
-          Kernel.warn <<-WARNING
-#{deprecated_method} is deprecated and will be removed from a future version of rspec-rails.
-
-Please just use object.#{new_method} instead.
-WARNING
-        end
-  
-        def verify_rendered # :nodoc:
-          render_proxy.rspec_verify
-        end
-  
-        def unregister_verify_after_each #:nodoc:
-          proc = verify_rendered_proc
-          Spec::Example::ExampleGroup.remove_after(:each, &proc)
-        end
-
-        def should_receive(*args)
-          if args[0] == :render
-            register_verify_after_each
-            render_proxy.should_receive(:render, :expected_from => caller(1)[0])
-          else
-            super
-          end
-        end
-        
-        def should_not_receive(*args)
-          if args[0] == :render
-            register_verify_after_each
-            render_proxy.should_not_receive(:render)
-          else
-            super
-          end
-        end
-        
-        def stub!(*args)
-          if args[0] == :render
-            register_verify_after_each
-            render_proxy.stub!(:render, :expected_from => caller(1)[0])
-          else
-            super
-          end
-        end
-
-        def verify_rendered_proc #:nodoc:
-          template = self
-          @verify_rendered_proc ||= Proc.new do
-            template.verify_rendered
-            template.unregister_verify_after_each
-          end
-        end
-
-        def register_verify_after_each #:nodoc:
-          proc = verify_rendered_proc
-          Spec::Example::ExampleGroup.after(:each, &proc)
-        end
-  
-        def render_proxy #:nodoc:
-          @render_proxy ||= Spec::Mocks::Mock.new("render_proxy")
-        end
-  
-      end
-    end
-  end
-end

data/vendor/plugins/rspec-rails/lib/spec/rails/example/view_example_group.rb

@@ -1,182 +0,0 @@
-module Spec
-  module Rails
-    module Example
-      # View Examples live in $RAILS_ROOT/spec/views/.
-      #
-      # View Specs use Spec::Rails::Example::ViewExampleGroup,
-      # which provides access to views without invoking any of your controllers.
-      # See Spec::Rails::Expectations::Matchers for information about specific
-      # expectations that you can set on views.
-      #
-      # == Example
-      #
-      #   describe "login/login" do
-      #     before do
-      #       render 'login/login'
-      #     end
-      # 
-      #     it "should display login form" do
-      #       response.should have_tag("form[action=/login]") do
-      #         with_tag("input[type=text][name=email]")
-      #         with_tag("input[type=password][name=password]")
-      #         with_tag("input[type=submit][value=Login]")
-      #       end
-      #     end
-      #   end
-      class ViewExampleGroup < FunctionalExampleGroup
-        before(:each) do
-          ensure_that_flash_and_session_work_properly
-        end
-
-        after(:each) do
-          ensure_that_base_view_path_is_not_set_across_example_groups
-        end
-
-        def initialize(defined_description, options={}, &implementation) #:nodoc:
-          super
-          @controller_class_name = "Spec::Rails::Example::ViewExampleGroupController"
-        end
-
-        def ensure_that_flash_and_session_work_properly #:nodoc:
-          @controller.send :initialize_template_class, @response
-          @controller.send :assign_shortcuts, @request, @response
-          @controller.send :initialize_current_url
-          @session = @controller.session
-          @controller.class.send :public, :flash
-        end
-
-        def ensure_that_base_view_path_is_not_set_across_example_groups #:nodoc:
-          ActionView::Base.base_view_path = nil
-        end
-
-        def set_base_view_path(options) #:nodoc:
-          ActionView::Base.base_view_path = base_view_path(options)
-        end
-
-        def base_view_path(options) #:nodoc:
-          "/#{derived_controller_name(options)}/"
-        end
-
-        def derived_controller_name(options) #:nodoc:
-          parts = subject_of_render(options).split('/').reject { |part| part.empty? }
-          "#{parts[0..-2].join('/')}"
-        end
-
-        def derived_action_name(options) #:nodoc:
-          parts = subject_of_render(options).split('/').reject { |part| part.empty? }
-          "#{parts.last}".split('.').first
-        end
-
-        def subject_of_render(options) #:nodoc:
-          [:template, :partial, :file].each do |render_type|
-            if options.has_key?(render_type)
-              return options[render_type]
-            end
-          end
-          return ""
-        end
-
-        def add_helpers(options) #:nodoc:
-          @controller.add_helper("application")
-          @controller.add_helper(derived_controller_name(options))
-          @controller.add_helper(options[:helper]) if options[:helper]
-          options[:helpers].each { |helper| @controller.add_helper(helper) } if options[:helpers]
-        end
-
-        # Renders a template for a View Spec, which then provides access to the result
-        # through the +response+. Also supports render with :inline, which you can
-        # use to spec custom form builders, helpers, etc, in the context of a view.
-        #
-        # == Examples
-        #
-        #   render('/people/list')
-        #   render('/people/list', :helper => MyHelper)
-        #   render('/people/list', :helpers => [MyHelper, MyOtherHelper])
-        #   render(:partial => '/people/_address')
-        #   render(:inline => "<% custom_helper 'argument', 'another argument' %>")
-        #
-        # See Spec::Rails::Example::ViewExampleGroup for more information.
-        def render(*args)
-          options = Hash === args.last ? args.pop : {}
-          options[:template] = args.first.to_s unless args.empty?
-
-          set_base_view_path(options)
-          add_helpers(options)
-
-          assigns[:action_name] = @action_name
-          
-          @request.path_parameters = @request.path_parameters.merge(
-            :controller => derived_controller_name(options),
-            :action => derived_action_name(options)
-          ).merge(options[:path_parameters] || {})
-
-          defaults = { :layout => false }
-          options = defaults.merge options
-
-          @controller.send(:params).reverse_merge! @request.parameters
-
-          @controller.class.instance_eval %{
-            def controller_path
-              "#{derived_controller_name(options)}"
-            end
-
-            def controller_name
-              "#{derived_controller_name(options).split('/').last}"
-            end
-          }
-
-          @controller.send :forget_variables_added_to_assigns
-          @controller.send :render, options
-          @controller.send :process_cleanup
-        end
-
-        # This provides the template. Use this to set mock
-        # expectations for dealing with partials
-        #
-        # == Example
-        #
-        #   describe "/person/new" do
-        #     it "should use the form partial" do
-        #       template.should_receive(:render).with(:partial => 'form')
-        #       render "/person/new"
-        #     end
-        #   end
-        def template
-          @controller.template
-        end
-
-        Spec::Example::ExampleGroupFactory.register(:view, self)
-
-        protected
-        def _assigns_hash_proxy
-          @_assigns_hash_proxy ||= AssignsHashProxy.new self do
-            @response.template
-          end
-        end
-      end
-
-      class ViewExampleGroupController < ApplicationController #:nodoc:
-        include Spec::Rails::Example::RenderObserver
-        attr_reader :template
-
-        def add_helper_for(template_path)
-          add_helper(template_path.split('/')[0])
-        end
-
-        def add_helper(name)
-          begin
-            helper_module = "#{name}_helper".camelize.constantize
-          rescue
-            return
-          end
-          (class << template; self; end).class_eval do
-            include helper_module
-          end
-        end
-        
-        def forget_variables_added_to_assigns
-        end
-      end
-    end
-  end
-end