has_finder 0.1.1

data/spec/rails/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/behaviour/view.rb

@@ -0,0 +1,185 @@
+module Spec
+  module Rails
+    module DSL
+      module ViewBehaviourHelpers
+        class << self
+          def included(mod)
+            mod.send :include, ExampleMethods
+          end
+        end
+        
+        module ExampleMethods
+          # Renders a template for a View Spec, which then provides access to the result
+          # through the +response+.
+          # 
+          # == Examples
+          # 
+          #   render('/people/list')
+          #   render('/people/list', :helper => MyHelper)
+          #   render('/people/list', :helpers => [MyHelper, MyOtherHelper])
+          #   render(:partial => '/people/_address')
+          #
+          # See Spec::Rails::DSL::ViewBehaviour 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 = {
+              :controller => derived_controller_name(options),
+              :action => derived_action_name(options)
+            }
+
+            defaults = { :layout => false }
+            options = defaults.merge options
+
+            @controller.instance_variable_set :@params, @request.parameters
+            
+            @controller.send :initialize_current_url
+
+            @controller.class.instance_eval %{
+              def controller_path
+                "#{derived_controller_name(options)}"
+              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
+        end
+      end
+
+      class ViewExampleController < ActionController::Base #:nodoc:
+        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
+          template.metaclass.class_eval do
+            include helper_module
+          end
+        end
+      
+      end
+      
+      class ViewEvalContext < Spec::Rails::DSL::FunctionalEvalContext
+        include Spec::Rails::DSL::ViewBehaviourHelpers
+        def setup #:nodoc:
+          super
+          # these go here so that flash and session work as they should.
+          @controller.send :initialize_template_class, @response
+          @controller.send :assign_shortcuts, @request, @response
+          @session = @controller.session
+          @controller.class.send :public, :flash # make flash accessible to the spec
+        end
+      
+        def teardown #:nodoc:
+          super
+          #necessary to ensure that base_view_path is not set across contexts
+          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}"
+        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
+          raise Exception.new("Unhandled render type in view spec.")
+        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
+
+
+      end
+
+      # View Specs live in $RAILS_ROOT/spec/views/.
+      #
+      # View Specs use Spec::Rails::DSL::ViewBehaviour,
+      # 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 ViewBehaviour < Spec::DSL::Behaviour
+        def execution_context(specification=nil) # :nodoc:
+          instance = execution_context_class.new(specification)
+          instance.instance_eval { @controller_class_name = "Spec::Rails::DSL::ViewExampleController" }
+          instance
+        end
+        def before_eval # :nodoc:
+          inherit Spec::Rails::DSL::ViewEvalContext
+          prepend_before {setup}
+          append_after {teardown}
+          configure
+        end
+
+        Spec::DSL::BehaviourFactory.add_behaviour_class(:view, self)
+      end
+    end
+  end
+end

data/spec/rails/vendor/plugins/rspec_on_rails/lib/spec/rails/dsl/ivar_proxy.rb

@@ -0,0 +1,62 @@
+##
+# A wrapper that allows instance variables to be manipulated using +[]+ and
+# +[]=+
+
+module Spec
+  module Rails
+    module DSL
+      class IvarProxy #:nodoc:
+
+        ##
+        # Wraps +object+ allowing its instance variables to be manipulated.
+
+        def initialize(object)
+          @object = object
+        end
+
+        ##
+        # Retrieves +ivar+ from the wrapped object.
+
+        def [](ivar)
+          get_variable "@#{ivar}"
+        end
+
+        ##
+        # Sets +ivar+ to +val+ on the wrapped object.
+
+        def []=(ivar, val)
+          set_variable "@#{ivar}", val
+        end
+
+        def each
+          @object.instance_variables.each do |variable_full_name|
+            variable_name = variable_full_name[1...variable_full_name.length]
+            yield variable_name, get_variable(variable_full_name)
+          end
+        end
+
+        def delete(key)
+          var_name = "@#{key}"
+          if @object.instance_variables.include?(var_name)
+            @object.send(:remove_instance_variable, var_name)
+          else
+            return nil
+          end
+        end
+
+        def has_key?(key)
+          @object.instance_variables.include?("@#{key}")
+        end
+
+        protected
+        def get_variable(name)
+          @object.instance_variable_get name
+        end
+
+        def set_variable(name, value)
+          @object.instance_variable_set name, value
+        end
+      end
+    end
+  end
+end

data/spec/rails/vendor/plugins/rspec_on_rails/lib/spec/rails/extensions.rb

@@ -0,0 +1,7 @@
+dir = File.dirname(__FILE__)
+require File.expand_path("#{dir}/extensions/object")
+require File.expand_path("#{dir}/extensions/active_record/base")
+require File.expand_path("#{dir}/extensions/action_controller/base")
+require File.expand_path("#{dir}/extensions/action_controller/rescue")
+require File.expand_path("#{dir}/extensions/action_controller/test_response")
+require File.expand_path("#{dir}/extensions/action_view/base")

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

@@ -0,0 +1,11 @@
+module ActionController
+  class Base
+    class << self
+      def set_view_path(path)
+        method = respond_to?(:view_paths=) ? :view_paths= : :template_root=
+        send(method, path)
+      end
+    end
+  end
+end
+        

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

@@ -0,0 +1,10 @@
+module ActionController
+  module Rescue
+    protected
+    alias old_rescue_action rescue_action
+    def rescue_action(exception)
+      raise exception if exception.is_a?(Spec::Mocks::MockExpectationError)
+      old_rescue_action(exception)
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module ActionController #:nodoc:
+  class TestResponse #:nodoc:
+    attr_writer :controller_path
+  end
+end

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

@@ -0,0 +1,26 @@
+module ActionView #:nodoc:
+  class Base #:nodoc:
+    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
+  end
+end
+
+
+
+
+
+
+
+
+
+
+

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

@@ -0,0 +1,29 @@
+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
+

data/spec/rails/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/spec/rails/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers.rb

@@ -0,0 +1,29 @@
+dir = File.dirname(__FILE__)
+require File.expand_path("#{dir}/matchers/assert_select")
+require File.expand_path("#{dir}/matchers/have_text")
+require File.expand_path("#{dir}/matchers/redirect_to")
+require File.expand_path("#{dir}/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/spec/rails/vendor/plugins/rspec_on_rails/lib/spec/rails/matchers/assert_select.rb

@@ -0,0 +1,131 @@
+# This is a wrapper of assert_select for rspec.
+
+module Spec # :nodoc:
+  module Rails
+    module Matchers
+      
+      class AssertSelect #:nodoc:
+        
+        def initialize(*args, &block)
+          @assertion = args.shift
+          @spec_scope = args.shift
+          @args = args
+          @block = block
+        end
+        
+        def matches?(response_or_text, &block)
+          @args.unshift(HTML::Document.new(response_or_text).root) if String === response_or_text
+          @block = block if block
+          begin
+            @spec_scope.send(@assertion, *@args, &@block)
+          rescue Exception => @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)
+        args.unshift(self)
+        args.unshift(:assert_select)
+        AssertSelect.new(*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)
+        response.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)
+        args.unshift(self)
+        args.unshift(:assert_select_rjs)
+        AssertSelect.new(*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)
+        args.unshift(self)
+        args.unshift(:assert_select_email)
+        AssertSelect.new(*args, &block)
+      end
+      
+      # wrapper for assert_select_encoded
+      #
+      # see documentation for assert_select_encoded at http://api.rubyonrails.org/
+      def with_encoded(*args, &block)
+        args.unshift(self)
+        args.unshift(:assert_select_encoded)
+        should AssertSelect.new(*args, &block)
+      end
+    end
+  end
+end