typo 5.2 → 5.2.98

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,113 +0,0 @@
-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}(?::\d+)?}, "").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

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

@@ -1,90 +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
-          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(path)
-      #   response.should_not render_template(path)
-      #
-      # Passes if the specified template is rendered by the response.
-      # Useful in controller specs (integration or isolation mode).
-      #
-      # <code>path</code> can include the controller path or not. It
-      # can also include an optional extension (no extension assumes .rhtml).
-      #
-      # 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')
-      #
-      #   #rjs
-      #   response.should render_template('list.rjs')
-      #   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,132 +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
-          add_stubs(model, stubs)
-          yield model if block_given?
-        end
-      end
-      
-      #--
-      # TODO - Shouldn't this just be an extension of stub! ??
-      # - object.stub!(:method => return_value, :method2 => return_value2, :etc => etc)
-      #++
-      # 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:
-        m = [String, Symbol].index(object.class) ? mock(object.to_s) : object
-        stubs.each {|k,v| m.stub!(k).and_return(v)}
-        m
-      end
-
-      private
-        @@model_id = 1000
-        def next_id
-          @@model_id += 1
-        end
-
-    end
-  end
-end

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

@@ -1,79 +0,0 @@
-# WARNING - THIS IS PURELY EXPERIMENTAL AT THIS POINT
-# Courtesy of Brian Takita and Yurii Rashkovskii
-
-$:.unshift File.join(File.dirname(__FILE__), *%w[.. .. .. .. rspec lib])
-if defined?(ActiveRecord::Base)
-  require 'test_help' 
-else
-  require 'action_controller/test_process'
-  require 'action_controller/integration'
-end
-require 'test/unit/testresult'
-require 'spec'
-require 'spec/rails'
-
-Test::Unit.run = true
-
-ActionController::Integration::Session.send(:include, Spec::Matchers)
-ActionController::Integration::Session.send(:include, Spec::Rails::Matchers)
-
-class RailsStory < ActionController::IntegrationTest
-  if defined?(ActiveRecord::Base)
-    self.use_transactional_fixtures = true
-  else
-    def self.fixture_table_names; []; end # Workaround for projects that don't use ActiveRecord
-  end
-
-  def initialize #:nodoc:
-    # TODO - eliminate this hack, which is here to stop
-    # Rails Stories from dumping the example summary.
-    Spec::Runner::Options.class_eval do
-      def examples_should_be_run?
-        false
-      end
-    end
-    @_result = Test::Unit::TestResult.new
-  end
-end
-
-class ActiveRecordSafetyListener
-  include Singleton
-  def scenario_started(*args)
-    if defined?(ActiveRecord::Base)
-      if ActiveRecord::Base.connection.respond_to?(:increment_open_transactions)
-        ActiveRecord::Base.connection.increment_open_transactions
-      else
-        ActiveRecord::Base.send :increment_open_transactions
-      end
-    end
-    ActiveRecord::Base.connection.begin_db_transaction
-  end
-
-  def scenario_succeeded(*args)
-    if defined?(ActiveRecord::Base)
-      ActiveRecord::Base.connection.rollback_db_transaction
-      if ActiveRecord::Base.connection.respond_to?(:decrement_open_transactions)
-        ActiveRecord::Base.connection.decrement_open_transactions
-      else
-        ActiveRecord::Base.send :decrement_open_transactions
-      end
-    end
-  end
-  alias :scenario_pending :scenario_succeeded
-  alias :scenario_failed :scenario_succeeded
-end
-
-class Spec::Story::Runner::ScenarioRunner
-  def initialize
-    @listeners = [ActiveRecordSafetyListener.instance]
-  end
-end
-
-class Spec::Story::GivenScenario
-  def perform(instance, name = nil)
-    scenario = Spec::Story::Runner::StoryRunner.scenario_from_current_story @name
-    runner = Spec::Story::Runner::ScenarioRunner.new
-    runner.instance_variable_set(:@listeners,[])
-    runner.run(scenario, instance)
-  end
-end