rspec-given 2.4.5 → 3.0.0.beta.2

data/lib/rspec/given/line_extractor.rb

@@ -1,43 +0,0 @@
-require 'rspec/given/file_cache'
-
-module RSpec
-  module Given
-    class LineExtractor
-      def initialize(file_cache=nil)
-        @files = file_cache || FileCache.new
-      end
-
-      def line(file_name, line)
-        lines = @files.get(file_name)
-        extract_lines_from(lines, line-1)
-      end
-
-      def to_s
-        "<LineExtractor>"
-      end
-
-      private
-
-      def extract_lines_from(lines, line_index)
-        result = lines[line_index]
-        if continued?(result)
-          level = indentation_level(result)
-          begin
-            line_index += 1
-            result << lines[line_index]
-          end while indentation_level(lines[line_index]) > level
-        end
-        result
-      end
-
-      def continued?(string)
-        string =~ /(\{|do) *$/
-      end
-
-      def indentation_level(string)
-        string =~ /^(\s*)\S/
-        $1.nil? ? 1000000 : $1.size
-      end
-    end
-  end
-end

data/lib/rspec/given/module_methods.rb

@@ -1,70 +0,0 @@
-module RSpec
-  module Given
-    # Does this platform support natural assertions?
-    RBX_IN_USE = (defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx')
-    JRUBY_IN_USE = defined?(JRUBY_VERSION)
-
-    NATURAL_ASSERTIONS_SUPPORTED = ! (JRUBY_IN_USE || RBX_IN_USE)
-
-    def self.matcher_called
-      @_matcher_called
-    end
-
-    def self.matcher_called=(value)
-      @_matcher_called = value
-    end
-
-    def self.source_caching_disabled
-      @_rg_source_caching_disabled
-    end
-
-    def self.source_caching_disabled=(value)
-      @_rg_source_caching_disabled = value
-    end
-
-    # Detect the formatting requested in the given configuration object.
-    #
-    # If the format requires it, source caching will be enabled.
-    def self.detect_formatters(c)
-      format_active = c.formatters.any? { |f| f.class.name !~ /ProgressFormatter/ }
-      RSpec::Given.source_caching_disabled = ! format_active
-    end
-
-    # Globally enable/disable natural assertions.
-    #
-    # There is a similar function in Extensions that works at a
-    # describe or context scope.
-    def self.use_natural_assertions(enabled=true)
-      ok_to_use_natural_assertions(enabled)
-      @natural_assertions_enabled = enabled
-    end
-
-    # TRUE if natural assertions are globally enabled?
-    def self.natural_assertions_enabled?
-      @natural_assertions_enabled
-    end
-
-    # Is is OK to use natural assertions on this platform.
-    #
-    # An error is raised if the the platform does not support natural
-    # assertions and the flag is attempting to enable them.
-    def self.ok_to_use_natural_assertions(enabled)
-      if enabled && ! NATURAL_ASSERTIONS_SUPPORTED
-        fail ArgumentError, "Natural Assertions are disabled for JRuby"
-      end
-    end
-
-    # Fail an example with the given messages.
-    #
-    # This should be the only place we reference the RSpec function.
-    # Everywhere else in rspec-given should be calling this function.
-    def self.fail_with(*args)
-      ::RSpec::Expectations.fail_with(*args)
-    end
-
-    # Error object used by RSpec to indicate a pending example.
-    def self.pending_error
-      RSpec::Core::Pending::PendingDeclaredInExample
-    end
-  end
-end

data/lib/rspec/given/monkey.rb

@@ -1,42 +0,0 @@
-require 'rspec'
-require 'rspec/expectations'
-require 'rspec/given/module_methods'
-
-# Monkey patch RSpec to detect matchers used in expectations.
-
-unless defined?(RSpec::Given::MONKEY)
-
-  if defined?(RSpec::Expectations::PositiveExpectationHandler) &&
-      defined?(RSpec::Expectations::NegativeExpectationHandler)
-
-    RSpec::Given::MONKEY = true
-
-    module RSpec
-      module Expectations
-        class PositiveExpectationHandler
-          class << self
-            alias _rg_rspec_original_handle_matcher handle_matcher
-            def handle_matcher(actual, matcher, message=nil, &block)
-              RSpec::Given.matcher_called = true
-              _rg_rspec_original_handle_matcher(actual, matcher, message, &block)
-            end
-          end
-        end
-
-        class NegativeExpectationHandler
-          class << self
-            alias _rg_rspec_original_handle_matcher handle_matcher
-            def handle_matcher(actual, matcher, message=nil, &block)
-              RSpec::Given.matcher_called = true
-              _rg_rspec_original_handle_matcher(actual, matcher, message, &block)
-            end
-          end
-        end
-      end
-    end
-
-  else
-    RSpec::Given::MONKEY = false
-  end
-
-end

data/lib/rspec/given/natural_assertion.rb

@@ -1,193 +0,0 @@
-require 'rspec'
-require 'rspec/given/module_methods'
-require 'rspec/given/evaluator'
-
-if RSpec::Given::NATURAL_ASSERTIONS_SUPPORTED
-  require 'ripper'
-  require 'sorcerer'
-  require 'rspec/given/monkey'
-end
-
-module RSpec
-  module Given
-
-    InvalidThenError = Class.new(StandardError)
-
-    class NaturalAssertion
-
-      def initialize(clause_type, block, example, line_extractor)
-        @clause_type = clause_type
-        @evaluator = Evaluator.new(example, block)
-        @line_extractor = line_extractor
-        set_file_and_line(block)
-      end
-
-      VOID_SEXP = [:void_stmt]
-
-      def using_rspec_assertion?
-        using_should? || using_expect?
-      end
-
-      def has_content?
-        assertion_sexp != VOID_SEXP
-      end
-
-      def message
-        @output = "#{@clause_type} expression failed at #{source_line}\n"
-        @output << "Failing expression: #{source.strip}\n" if @clause_type != "Then"
-        explain_failure
-        display_pairs(expression_value_pairs)
-        @output << "\n"
-        @output
-      end
-
-      private
-
-      def using_should?
-        source =~ /\.\s*should(_not)?\b/
-      end
-
-      def using_expect?
-        source =~ /\bexpect\s*[({].*[)}]\s*\.\s*(not_)?to\b/
-      end
-
-      BINARY_EXPLAINATIONS = {
-        :== => "to equal",
-        :!= => "to not equal",
-        :<  => "to be less than",
-        :<= => "to be less or equal to",
-        :>  => "to be greater than",
-        :>= => "to be greater or equal to",
-        :=~ => "to match",
-        :!~ => "to not match",
-      }
-
-      def explain_failure
-        if assertion_sexp.first == :binary && msg = BINARY_EXPLAINATIONS[assertion_sexp[2]]
-          @output << explain_expected("expected", assertion_sexp[1], msg, assertion_sexp[3])
-        end
-      end
-
-      def explain_expected(expect_msg, expect_sexp, got_msg, got_sexp)
-        width = [expect_msg.size, got_msg.size].max
-        sprintf("%#{width}s: %s\n%#{width}s: %s\n",
-          expect_msg, eval_sexp(expect_sexp),
-          got_msg, eval_sexp(got_sexp))
-      end
-
-      def expression_value_pairs
-        assertion_subexpressions.map { |exp|
-          [exp, @evaluator.eval_string(exp)]
-        }
-      end
-
-      def assertion_subexpressions
-        Sorcerer.subexpressions(assertion_sexp).reverse.uniq.reverse
-      end
-
-      def assertion_sexp
-        @assertion_sexp ||= extract_test_expression(Ripper::SexpBuilder.new(source).parse)
-      end
-
-      def source
-        @source ||= @line_extractor.line(@code_file, @code_line)
-      end
-
-      def set_file_and_line(block)
-        @code_file, @code_line = eval "[__FILE__, __LINE__]", block.binding
-        @code_line = @code_line.to_i
-      end
-
-      def extract_test_expression(sexp)
-        brace_block = extract_brace_block(sexp)
-        extract_first_statement(brace_block)
-      end
-
-      def extract_brace_block(sexp)
-        unless then_block?(sexp)
-          source = Sorcerer.source(sexp)
-          fail InvalidThenError, "Unexpected code at #{source_line}\n#{source}"
-        end
-        sexp[1][2][2]
-      end
-
-      def then_block?(sexp)
-        delve(sexp,0) == :program &&
-          delve(sexp,1,0) == :stmts_add &&
-          delve(sexp,1,2,0) == :method_add_block &&
-          (delve(sexp,1,2,2,0) == :brace_block || delve(sexp,1,2,2,0) == :do_block)
-      end
-
-      def extract_first_statement(block_sexp)
-        if contains_multiple_statements?(block_sexp)
-          source = Sorcerer.source(block_sexp)
-          fail InvalidThenError, "Multiple statements in Then block at #{source_line}\n#{source}"
-        end
-        extract_statement_from_block(block_sexp)
-      end
-
-      def contains_multiple_statements?(block_sexp)
-        !(delve(block_sexp,2,0) == :stmts_add &&
-          delve(block_sexp,2,1,0) == :stmts_new)
-      end
-
-      def extract_statement_from_block(block_sexp)
-        delve(block_sexp,2,2)
-      end
-
-      # Safely dive into an array with a list of indicies. Return nil
-      # if the element doesn't exist, or if the intermediate result is
-      # not indexable.
-      def delve(ary, *indicies)
-        result = ary
-        while !indicies.empty? && result
-          return nil unless result.respond_to?(:[])
-          i = indicies.shift
-          result = result[i]
-        end
-        result
-      end
-
-      def eval_sexp(sexp)
-        expr_string = Sorcerer.source(sexp)
-        @evaluator.eval_string(expr_string)
-      end
-
-      WRAP_WIDTH = 20
-
-      def display_pairs(pairs)
-        width = suggest_width(pairs) + 4
-        pairs.each do |x, v|
-          v = adjust_indentation(v)
-          fmt = multi_line?(v) ?
-            "%-#{width}s\n#{' '*width} <- %s\n" :
-            "%-#{width}s <- %s\n"
-          @output << sprintf(fmt, v, x)
-        end
-      end
-
-      def adjust_indentation(string)
-        string.to_s.gsub(/^/, '  ')
-      end
-
-      def multi_line?(string)
-        (string.size > WRAP_WIDTH) || (string =~ /\n/)
-      end
-
-      def suggest_width(pairs)
-        pairs.map { |x,v|
-          max_line_length(v)
-        }.select { |n| n < WRAP_WIDTH }.max || 10
-      end
-
-      def max_line_length(string)
-        string.to_s.split(/\n/).map { |s| s.size }.max
-      end
-
-      def source_line
-        "#{@code_file}:#{@code_line}"
-      end
-    end
-
-  end
-end

data/lib/rspec/given/rspec1_given.rb

@@ -1,11 +0,0 @@
-require 'rspec/given/version'
-require 'rspec/given/extensions'
-
-class Spec::ExampleGroup
-  extend RSpec::Given::ClassExtensions
-  include RSpec::Given::InstanceExtensions
-
-  class << self
-    alias Then specify
-  end
-end

data/lib/rspec/given/version.rb

@@ -1,10 +0,0 @@
-module RSpec
-  module Given
-    VERSION_NUMBERS = [
-      VERSION_MAJOR = 2,
-      VERSION_MINOR = 4,
-      VERSION_BUILD = 5,
-    ]
-    VERSION = VERSION_NUMBERS.join(".")
-  end
-end

data/spec/lib/rspec/given/failure_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-require 'rspec/given/failure'
-
-describe RSpec::Given::Failure do
-  Given(:exception) { StandardError.new("Oops") }
-  Given(:failure) { RSpec::Given::Failure.new(exception) }
-
-  Then { lambda { failure.to_s }.should raise_error(StandardError, "Oops") }
-  Then { lambda { failure.call }.should raise_error(StandardError, "Oops") }
-  Then { lambda { failure.nil? }.should raise_error(StandardError, "Oops") }
-  Then { lambda { failure == 0 }.should raise_error(StandardError, "Oops") }
-  Then { lambda { failure != 0 }.should raise_error(StandardError, "Oops") }
-  Then { lambda { failure =~ 0 }.should raise_error(StandardError, "Oops") }
-  Then { lambda { ! failure }.should raise_error(StandardError, "Oops") }
-
-  Then { failure.is_a?(RSpec::Given::Failure).should be_true }
-end

data/spec/lib/rspec/given/file_cache_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Given
-
-    DESCRIBE_LINE = __LINE__
-    describe FileCache do
-      Given(:file_name) { __FILE__ }
-      Given(:cache) { FileCache.new }
-
-      When(:result) { cache.get(file_name) }
-
-      context "when reading the file" do
-        Then { result[DESCRIBE_LINE].should =~ /describe FileCache do/ }
-        Then { result.size.should == MAX_LINE }
-      end
-
-      context "when getting the same file twice" do
-        Given { cache.should_receive(:read_lines).once.and_return(["A"]) }
-        When(:result2) { cache.get(file_name) }
-        Then { result.should == ["A"] }
-        Then { result2.should == ["A"] }
-      end
-    end
-  end
-end
-
-MAX_LINE = __LINE__

data/spec/lib/rspec/given/line_extractor_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Given
-
-    describe LineExtractor do
-
-      class FauxFileCache
-        def initialize(lines)
-          @lines = lines.split(/\n/).map { |ln| ln + "\n" }
-        end
-        def get(file_name)
-          @lines
-        end
-      end
-
-      Given(:line) { 2 }
-      Given(:file_cache) { FauxFileCache.new(input) }
-      Given(:extractor) { LineExtractor.new(file_cache) }
-
-      When(:result) { extractor.line("FILENAME", line) }
-
-      describe "reading a line" do
-        Given(:input) {
-          "  Now is the time\n" +
-          "  for all good men\n" +
-          "  to come to the aid\n" +
-          "  of their fellowmen\n"
-        }
-        Given(:expected_line) { "  for all good men\n" }
-        Then { result.should == expected_line }
-      end
-
-      context "when the line doesn't exist" do
-        Given(:input) { "" }
-        Then { result.should be_nil }
-      end
-
-      context "when the line has leading and trailing white space" do
-        Given(:input) {
-          "  Then { y } \n" +
-          "  Then { x }\n"
-        }
-        Then { result.should == "  Then { x }\n" }
-      end
-
-      context "when the Then is split over several lines with {}" do
-        Given(:input) {
-          "describe 'foobar' do\n" +
-          "  Then {\n" +
-          "    x\n" +
-          "  }\n" +
-          "end\n"
-        }
-        Then { result.should == "  Then {\n    x\n  }\n" }
-      end
-
-      context "when the Then is has blank lines" do
-        Given(:input) {
-          "describe 'foobar' do\n" +
-          "  Then {\n\n" +
-          "    x\n" +
-          "  }\n" +
-          "end\n"
-        }
-        Then { result.should == "  Then {\n\n    x\n  }\n" }
-      end
-
-      context "when the Then is split over several lines with do/end" do
-        Given(:input) {
-          "describe 'foobar' do\n" +
-          "  Then do\n" +
-          "    x\n" +
-          "  end\n" +
-          "end\n"
-        }
-        Then { result.should == "  Then do\n    x\n  end\n" }
-      end
-
-      describe "converting to a string" do
-        Given(:input) { "" }
-        Then { extractor.to_s.should =~ /line *extractor/i }
-      end
-    end
-  end
-end