rspec-given 2.4.5 → 3.0.0.beta.2

data/lib/rspec/given/extensions.rb

@@ -1,262 +0,0 @@
-require 'rspec/given/failure'
-require 'rspec/given/module_methods'
-require 'rspec/given/natural_assertion'
-
-module RSpec
-  module Given
-
-    # Provide run-time methods to support RSpec/Given infrastructure.
-    # All the methods in this module are considered private and
-    # implementation-specific.
-    module InstanceExtensions   # :nodoc:
-
-      # List of containing contexts in order from innermost to
-      # outermost.
-      def _rg_inner_contexts    # :nodoc:
-        self.class.ancestors.select { |context|
-          context.respond_to?(:_rgc_givens)
-        }
-      end
-
-      # List of containing contexts in order from outermost to
-      # innermost.
-      def _rg_contexts          # :nodoc:
-        _rg_inner_contexts.reverse
-      end
-
-      # Return the context information for keyword from the innermost
-      # defining context.
-      def _rg_info(keyword)     # :nodoc:
-        _rg_inner_contexts.each do |context|
-          h = context._rgc_context_info
-          if h.has_key?(keyword)
-            return h[keyword]
-          end
-        end
-        nil
-      end
-
-      # Should a natural assertion failure message be generated?
-      #
-      # A natural assertion failure message is generated if the
-      # assertion has non-empty content that doesn't use rspec
-      # assertions. The configuration options for natural assertions
-      # are checked and applied accordingly.
-      #
-      def _rg_need_na_message?(nassert) # :nodoc:
-        return false unless nassert.has_content?
-        use_na = _rg_na_configured?
-        return true if use_na == :always
-        return false if !RSpec::Given::MONKEY && nassert.using_rspec_assertion?
-        use_na
-      end
-
-      # Return the configuration value for natural assertions.
-      #
-      # If natural assertions are not configured in the contexts, use
-      # the global configuration value.
-      def _rg_na_configured?    # :nodoc:
-        info_value = _rg_info(:natural_assertions_enabled)
-        info_value.nil? ? RSpec::Given.natural_assertions_enabled? : info_value
-      end
-
-      # Establish all the Given preconditions the current and
-      # surrounding describe/context blocks, starting with the
-      # outermost context.
-      def _rg_establish_givens  # :nodoc:
-        return if defined?(@_rg_ran) && @_rg_ran
-        @_rg_ran = true
-        _rg_contexts.each do |context|
-          context._rgc_givens.each do |block|
-            instance_eval(&block)
-          end
-        end
-      end
-
-      # Check all the invariants in the current and surrounding
-      # describe/context blocks, starting with the outermost context.
-      def _rg_check_invariants  # :nodoc:
-        _rg_contexts.each do |context|
-          context._rgc_invariants.each do |block|
-            _rg_evaluate("Invariant", block)
-          end
-        end
-      end
-
-      def _rg_check_ands  # :nodoc:
-        return if self.class._rgc_context_info[:and_ran]
-        self.class._rgc_and_blocks.each do |block|
-          _rg_evaluate("And", block)
-        end
-        self.class._rgc_context_info[:and_ran] = true
-      end
-
-      # Implement the run-time semantics of the Then clause.
-      def _rg_then(&block)      # :nodoc:
-        _rg_establish_givens
-        _rg_check_invariants
-        _rg_evaluate("Then", block)
-        _rg_check_ands
-      end
-
-      # Evaluate a Then, And, or Invariant assertion.
-      def _rg_evaluate(clause_type, block)   # :nodoc:
-        RSpec::Given.matcher_called = false
-        passed = instance_eval(&block)
-        if ! passed && _rg_na_configured? && ! RSpec::Given.matcher_called
-          nassert = NaturalAssertion.new(clause_type, block, self, self.class._rgc_lines)
-          RSpec::Given.fail_with nassert.message if _rg_need_na_message?(nassert)
-        end
-      end
-    end
-
-    module ClassExtensions
-
-      # List of all givens directly in the current describe/context
-      # block.
-      def _rgc_givens            # :nodoc:
-        @_rgc_givens ||= []
-      end
-
-      # List of all invariants directly in the current
-      # describe/context block.
-      def _rgc_invariants        # :nodoc:
-        @_rgc_invariants ||= []
-      end
-
-      def _rgc_and_blocks
-        @_rgc_and_blocks ||= []
-      end
-
-      def _rgc_context_info
-        @_rgc_context_info ||= {}
-      end
-
-      def _rgc_lines
-        @_rgc_lines ||= LineExtractor.new
-      end
-
-      # Trigger the evaluation of a Given! block by referencing its
-      # name.
-      def _rgc_trigger_given(name) # :nodoc:
-        Proc.new { send(name) }
-      end
-
-      # *DEPRECATED:*
-      #
-      # The Scenario command is deprecated. Using Scenario in an
-      # example will result in a warning message. Eventually the
-      # command will be removed.
-      #
-      # Declare a scenario to contain Given/When/Then declarations.  A
-      # Scenario is essentially an RSpec context, with the additional
-      # expectations:
-      #
-      # * There is a single When declaration in a Scenario.
-      # * Scenarios do not nest.
-      #
-      # :call-seq:
-      #    Scenario "a scenario description" do ... end
-      #
-      def Scenario(description, &block)
-        file, line = eval("[__FILE__, __LINE__]", block.binding)
-        puts "WARNING: Scenario is deprecated, please use either describe or context (#{file}:#{line})"
-        context(description, &block)
-      end
-
-      # Declare a "given" of the current specification.  If the given
-      # is named, the block will be lazily evaluated the first time
-      # the given is mentioned by name in the specification.  If the
-      # given is unnamed, the block is evaluated for side effects
-      # every time the specification is executed.
-      #
-      # :call-seq:
-      #   Given(:name) { ... code ... }
-      #   Given { ... code ... }
-      #
-      def Given(*args, &block)
-        if args.first.is_a?(Symbol)
-          let(args.first, &block)
-        else
-          _rgc_givens << block
-        end
-      end
-
-      # Declare a named given of the current specification.  Similar
-      # to the named version of the "Given" command, except that the
-      # block is always evaluated.
-      #
-      # :call-seq:
-      #   Given!(:name) { ... code ... }
-      #
-      def Given!(name, &block)
-        let(name, &block)
-        _rgc_givens << _rgc_trigger_given(name)
-      end
-
-      # Declare the code that is under test.
-      #
-      # :call-seq:
-      #   When(:named_result) { ... code_under_test ... }
-      #   When { ... code_under_test ... }
-      #
-      def When(*args, &block)
-        if args.first.is_a?(Symbol)
-          let!(args.first) do
-            begin
-              _rg_establish_givens
-              instance_eval(&block)
-            rescue RSpec::Given.pending_error => ex
-              raise
-            rescue Exception => ex
-              Failure.new(ex)
-            end
-          end
-        else
-          before do
-            _rg_establish_givens
-            instance_eval(&block)
-          end
-        end
-      end
-
-      # Provide an assertion about the specification.
-      #
-      # Then supplies an assertion that should be true after all the
-      # Given and When blocks have been run. All invariants in scope
-      # will be checked before the Then block is run.
-      #
-      # :call-seq:
-      #   Then { ... assertion ... }
-      #
-      def Then(&block)
-        env = block.binding
-        file, line = eval "[__FILE__, __LINE__]", env
-        description = _rgc_lines.line(file, line) unless RSpec::Given.source_caching_disabled
-        if description
-          cmd = "it(description)"
-        else
-          cmd = "specify"
-        end
-        eval %{#{cmd} do _rg_then(&block) end}, binding, file, line
-        _rgc_context_info[:then_defined] = true
-      end
-
-      # Establish an invariant that must be true for all Then blocks
-      # in the current (and nested) scopes.
-      def Invariant(&block)
-        _rgc_invariants << block
-      end
-
-      def And(&block)
-        fail "And defined without a Then" unless _rgc_context_info[:then_defined]
-        _rgc_and_blocks << block
-      end
-
-      def use_natural_assertions(enabled=true)
-        RSpec::Given.ok_to_use_natural_assertions(enabled)
-        _rgc_context_info[:natural_assertions_enabled] = enabled
-      end
-    end
-  end
-end

data/lib/rspec/given/failure.rb

@@ -1,53 +0,0 @@
-module RSpec
-  module Given
-
-    # Failure objects will raise the given exception whenever you try
-    # to send it *any* message.
-    class Failure < BasicObject
-      undef_method :==, :!=, :!
-
-      def initialize(exception)
-        @exception = exception
-      end
-
-      def is_a?(klass)
-        klass == Failure
-      end
-
-      def ==(other)
-        if failed_matcher?(other)
-          other.matches?(self)
-        else
-          die
-        end
-      end
-
-      def !=(other)
-        if failed_matcher?(other)
-          ! other.matches?(self)
-        else
-          die
-        end
-      end
-
-      def method_missing(sym, *args, &block)
-        die
-      end
-
-      def respond_to?(method_name)
-        method_name == :call
-      end
-
-      private
-
-      def die
-        ::Kernel.raise @exception
-      end
-
-      def failed_matcher?(other)
-        other.is_a?(::RSpec::Given::HaveFailed::HaveFailedMatcher)
-      end
-
-    end
-  end
-end

data/lib/rspec/given/file_cache.rb

@@ -1,19 +0,0 @@
-module RSpec
-  module Given
-    class FileCache
-      def initialize
-        @lines = {}
-      end
-
-      def get(file_name)
-        @lines[file_name] ||= read_lines(file_name)
-      end
-
-      private
-
-      def read_lines(file_name)
-        open(file_name) { |f| f.readlines }
-      end
-    end
-  end
-end

data/lib/rspec/given/fuzzy_number.rb

@@ -1,70 +0,0 @@
-
-module RSpec
-  module Given
-    module Fuzzy
-      class FuzzyNumber
-
-        DEFAULT_EPSILON = 10 * Float::EPSILON
-
-        attr_reader :exact_value, :delta_amount
-
-        def initialize(exact_value)
-          @exact_value = exact_value
-          @delta_amount = exact_value * DEFAULT_EPSILON
-        end
-
-        def exactly_equals?(other)
-          other.is_a?(self.class) &&
-            exact_value == other.exact_value &&
-            delta_amount == other.delta_amount
-        end
-
-        # Low limit of the fuzzy number.
-        def low_limit
-          exact_value - delta_amount
-        end
-
-        # High limit of the fuzzy number.
-        def high_limit
-          exact_value + delta_amount
-        end
-
-        # True if the other number is in range of the fuzzy number.
-        def ==(other)
-          (other - exact_value).abs <= delta_amount
-        end
-
-        def to_s
-          "<Approximately #{exact_value} +/- #{delta_amount}>"
-        end
-
-        # Set the delta for a fuzzy number.
-        def delta(delta)
-          @delta_amount = delta.abs
-          self
-        end
-
-        # Specifying a percentage of the exact number to be used in
-        # setting the delta.
-        def percent(percentage)
-          delta(exact_value * (percentage / 100.0))
-        end
-
-        # Specifying the number of epsilons to be used in setting the
-        # delta.
-        def epsilon(neps)
-          delta(exact_value * (neps * Float::EPSILON))
-        end
-      end
-
-      # Create an approximate number that is approximately equal to
-      # the given number, plus or minus the delta value. If no
-      # explicit delta is given, then the default delta that is about
-      # 10X the size of the smallest possible change in the given
-      # number will be used.
-      def about(*args)
-        FuzzyNumber.new(*args)
-      end
-    end
-  end
-end

data/lib/rspec/given/fuzzy_shortcuts.rb

@@ -1 +0,0 @@
-require 'rspec/given/ext/numeric'

data/lib/rspec/given/have_failed.rb

@@ -1,77 +0,0 @@
-require 'rspec'
-
-module RSpec
-  module Given
-    module HaveFailed
-
-      # Specializes the RaiseError matcher to handle
-      # Failure/non-failure objects.
-
-      # The implementation of RaiseError changed between RSpec 2.11 and 2.12.
-      if RSpec::Matchers::BuiltIn::RaiseError.instance_methods.include?(:does_not_match?)
-
-        class HaveFailedMatcher < RSpec::Matchers::BuiltIn::RaiseError
-          def matches?(given_proc, negative_expectation = false)
-            if given_proc.is_a?(Failure)
-              super
-            else
-              super(lambda { }, negative_expectation)
-            end
-          end
-
-          def does_not_match?(given_proc)
-            if given_proc.is_a?(Failure)
-              super(given_proc)
-            else
-              super(lambda { })
-            end
-          end
-
-          def to_s
-            "<Failure matching #{@expected_error}: #{@expected_message.inspect}>"
-          end
-        end
-
-      else
-
-        class HaveFailedMatcher < RSpec::Matchers::BuiltIn::RaiseError
-          def matches?(given_proc)
-            if given_proc.is_a?(Failure)
-              super
-            else
-              super(lambda { })
-            end
-          end
-
-          def to_s
-            "<FailureMatcher on #{@expected_error}: #{@expected_message.inspect}>"
-          end
-        end
-
-      end
-
-      # Simular to raise_error(...), but reads a bit better when using
-      # a failure result from a when clause.
-      #
-      # Typical Usage:
-      #
-      #    When(:result) { fail "OUCH" }
-      #    Then { result.should have_failed(StandardError, /OUCH/) }
-      #
-      #    When(:result) { good_code }
-      #    Then { result.should_not have_failed }
-      #
-      # :call-seq:
-      #    have_failed([exception_class [, message_pattern]])
-      #    have_failed([exception_class [, message_pattern]]) { |ex| ... }
-      #
-      def have_failed(error=Exception, message=nil, &block)
-        HaveFailedMatcher.new(error, message, &block)
-      end
-      alias have_raised have_failed
-
-      def failure(error=Exception, message=nil, &block)
-      end
-    end
-  end
-end