rspec-given 2.4.5 → 3.0.0.beta.2

data/rakelib/metrics.rake

@@ -0,0 +1,30 @@
+require './rakelib/bundler_fix'
+
+METRICS_FILES = FileList['lib/**/*.rb']
+
+task :check_flog do
+  sh "type flog >/dev/null 2>&1", :verbose => false do |status|
+    fail "Install flog to generate complexity metrics" unless status
+  end
+end
+
+task :check_flay do
+  sh "type flay >/dev/null 2>&1", :verbose => false do |status|
+    fail "Install flay to generate complexity metrics" unless status
+  end
+end
+
+desc "Run complexity metrics"
+task :flog, [:all] => :check_flog do |t, args|
+  flags = args.all ? "--all" : ""
+  nobundle do
+    sh "flog #{flags} #{METRICS_FILES}"
+  end
+end
+
+desc "Run duplication metrics"
+task :flay => :check_flay do
+  nobundle do
+    sh "flay #{METRICS_FILES}"
+  end
+end

data/rakelib/preview.rake

@@ -0,0 +1,14 @@
+require './rakelib/bundler_fix'
+
+task :check_preview do
+  sh "type ghpreview >/dev/null 2>&1", :verbose => false do |status|
+    fail "Install ghpreview to generate a local REAMDE preview page" unless status
+  end
+end
+
+desc "Generate the GitHub readme locally"
+task :preview => :check_preview do
+  nobundle do
+    sh "ghpreview #{FileList['README.*']}"
+  end
+end

data/spec/lib/{rspec/given → given}/evaluator_spec.rb

@@ -26,6 +26,6 @@ end
 describe "Evaluator with error object" do
   FauxThen { 1 }
   When(:result) { ev.eval_string("fail 'XYZ'") }
-  Then { result.class.should == RSpec::Given::EvalErr }
+  Then { result.class.should == Given::EvalErr }
   Then { result.inspect.should == "RuntimeError: XYZ" }
 end

data/spec/lib/{rspec/given → given}/ext/numeric_spec.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 require 'spec_helper'
-require 'rspec/given'
-require 'rspec/given/fuzzy_shortcuts'
+require 'given'
+require 'given/fuzzy_shortcuts'
 
 describe "Numeric Extensions" do
   use_natural_assertions_if_supported

data/spec/lib/{rspec/given → given}/extensions_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe RSpec::Given::ClassExtensions do
+describe Given::ClassExtensions do
   let(:trace) { [] }
 
   describe "Given with var" do
@@ -195,7 +195,7 @@ describe "use_natural_assertions" do
 
     When(:result) { CONTEXT.use_natural_assertions }
 
-    if RSpec::Given::NATURAL_ASSERTIONS_SUPPORTED
+    if ::Given::NATURAL_ASSERTIONS_SUPPORTED
       Then { result.should_not have_failed }
     else
       Then { result.should have_failed(ArgumentError) }

data/spec/lib/given/failure_matcher_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+require 'given/failure_matcher'
+
+module FailureMatcherSpec
+  OtherError  = Class.new(StandardError)
+  CustomError = Class.new(StandardError)
+  SubError    = Class.new(CustomError)
+  NotMetError = RSpec::Expectations::ExpectationNotMetError
+
+  describe Given::FailureMatcher do
+    Given(:error) { CustomError.new("CUSTOM") }
+
+    Given(:failure_result) { Given::Failure.new(error) }
+
+    context "with matching failure results" do
+      Then { Failure(CustomError, "CUSTOM").matches?(failure_result) }
+      Then { Failure(CustomError, /CUSTOM/).matches?(failure_result) }
+      Then { Failure(CustomError).matches?(failure_result) }
+      Then { Failure(StandardError).matches?(failure_result) }
+      Then { Failure().matches?(failure_result) }
+    end
+
+    context "with non-matching results" do
+      Then {
+        expect {
+          Failure(StandardError).matches?(Object.new)
+        }.to raise_error(NotMetError,
+          /Expected.*StandardError, but nothing failed/)
+      }
+
+      Then {
+        expect {
+          Failure(StandardError, /CUSTOM/).matches?(Object.new)
+        }.to raise_error(NotMetError,
+          /Expected.*StandardError.*matching.*CUSTOM.*, but nothing failed/)
+      }
+
+      Then {
+        expect {
+          Failure(StandardError, /OTHER/).matches?(failure_result)
+        }.to raise_error(NotMetError,
+          /Expected.*StandardError matching.*OTHER.*, but got.*CustomError.*CUSTOM/)
+      }
+
+      Then {
+        expect {
+          Failure(OtherError, /CUSTOM/).matches?(failure_result)
+        }.to raise_error(NotMetError,
+          /Expected.*OtherError matching.*CUSTOM.*, but got.*CustomError.*CUSTOM/)
+      }
+
+      Then {
+        expect {
+          Failure(SubError, /CUSTOM/).matches?(failure_result)
+        }.to raise_error(NotMetError,
+          /Expected.*SubError matching.*CUSTOM.*, but got.*CustomError.*CUSTOM/)
+      }
+
+      Then {
+        expect {
+          Failure(OtherError).matches?(failure_result)
+        }.to raise_error(NotMetError,
+          /Expected.*OtherError, but got.*CustomError.*CUSTOM/)
+      }
+    end
+
+    describe "==" do
+      Then { failure_result == Failure(CustomError) }
+      Then { Failure(CustomError) == failure_result }
+    end
+
+    describe "!=" do
+      Then { failure_result != Failure(SubError) }
+      Then { Failure(SubError) == failure_result }
+    end
+  end
+end

data/spec/lib/given/failure_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'given/failure'
+
+describe Given::Failure do
+  OtherError = Class.new(StandardError)
+
+  Given(:exception) { StandardError.new("Oops") }
+  Given(:failure) { Given::Failure.new(exception) }
+
+  Then { failure.is_a?(Given::Failure).should be_true }
+
+  describe "general operations" do
+    Then { expect { failure.to_s }.to raise_error(StandardError, "Oops") }
+    Then { expect { failure.call }.to raise_error(StandardError, "Oops") }
+    Then { expect { failure.nil? }.to raise_error(StandardError, "Oops") }
+    Then { expect { failure == 0 }.to raise_error(StandardError, "Oops") }
+    Then { expect { failure != 0 }.to raise_error(StandardError, "Oops") }
+    Then { expect { failure =~ 0 }.to raise_error(StandardError, "Oops") }
+    Then { expect { ! failure }.to raise_error(StandardError, "Oops") }
+  end
+
+  describe "should raise error" do
+    Then { failure.should raise_error(StandardError, "Oops") }
+    Then { failure.should raise_error(StandardError) }
+    Then { failure.should raise_error }
+  end
+
+  describe "== have_failed" do
+    Then { failure == have_failed(StandardError, "Oops") }
+    Then { failure == have_failed(StandardError) }
+    Then { failure == have_failed }
+  end
+
+  describe "!= have_failed" do
+    Then { failure != have_failed() }
+  end
+
+  describe "== Failure" do
+    Then { failure == Failure(StandardError, "Oops") }
+    Then { failure == Failure(StandardError) }
+    Then { failure == Failure() }
+  end
+
+  describe "!= Failure" do
+    Then { expect { failure != Object.new }.to raise_error(StandardError) }
+    Then { failure != Failure() }
+  end
+
+end

data/spec/lib/given/file_cache_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+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
+
+MAX_LINE = __LINE__

data/spec/lib/{rspec/given → given}/fuzzy_number_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe RSpec::Given::Fuzzy::FuzzyNumber do
+describe Given::Fuzzy::FuzzyNumber do
   use_natural_assertions_if_supported
-  include RSpec::Given::Fuzzy
+  include Given::Fuzzy
 
   describe "attributes" do
     Given(:number) { about(10).delta(0.0001) }

data/spec/lib/{rspec/given → given}/have_failed_spec.rb

@@ -1,10 +1,11 @@
 require 'spec_helper'
 
-describe "#have_failed" do
+module HaveFailedSpec
   CustomError = Class.new(StandardError)
   DifferentError = Class.new(StandardError)
   ExpectationError = RSpec::Expectations::ExpectationNotMetError
 
+  describe "#have_failed" do
   context "with a failure" do
     When(:result) { fail CustomError, "Ouch" }
 
@@ -40,7 +41,7 @@ describe "#have_failed" do
 
   context "with a pending exception" do
     When(:result) { fail RSpec::Core::Pending::PendingDeclaredInExample, "Required pending in example ... please ignore" }
-    Then { RSpec::Given.fail_with "This example should have been pending" }
+    Then { Given.fail_with "This example should have been pending" }
   end
 
   context "with a non-failure" do
@@ -55,15 +56,15 @@ describe "#have_failed" do
     context "with failure" do
       When(:result) { fail CustomError, "Ouch" }
       Then { result == have_failed(CustomError, "Ouch") }
-      Then { ! (result != have_failed(CustomError, "Ouch")) }
+      Then { ! (result != have_failed) }
       Then { expect { result == :something }.to raise_error(CustomError, "Ouch") }
     end
 
     context "with different failure" do
       When(:result) { fail DifferentError, "Ouch" }
       Then { ! (result == have_failed(CustomError, "Ouch")) }
-      Then { result != have_failed(CustomError, "Ouch") }
     end
 
   end
 end
+end

data/spec/lib/given/line_extractor_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+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

data/spec/lib/{rspec/given → given}/module_methods_spec.rb

@@ -2,9 +2,9 @@ require 'spec_helper'
 
 describe "RSpec::Given.use_natural_assertions" do
   context "when in JRuby" do
-    When(:result) { RSpec::Given.use_natural_assertions }
+    When(:result) { ::Given.use_natural_assertions }
 
-    if RSpec::Given::NATURAL_ASSERTIONS_SUPPORTED
+    if ::Given::NATURAL_ASSERTIONS_SUPPORTED
       Then { result.should_not have_failed }
     else
       Then { result.should have_failed(ArgumentError) }

data/spec/lib/{rspec/given → given}/natural_assertion_spec.rb

@@ -1,9 +1,9 @@
 require 'rspec/given'
 require 'spec_helper'
 
-describe RSpec::Given::NaturalAssertion do
+describe Given::NaturalAssertion do
   before do
-    pending "Natural Assertions disabled for JRuby" unless RSpec::Given::NATURAL_ASSERTIONS_SUPPORTED
+    pending "Natural Assertions disabled for JRuby" unless Given::NATURAL_ASSERTIONS_SUPPORTED
   end
 
   describe "#content?" do
@@ -17,38 +17,6 @@ describe RSpec::Given::NaturalAssertion do
     end
   end
 
-  describe "detecting RSpec Assertions" do
-    context "with should" do
-      FauxThen { a.should == 1 }
-      Then { na.should be_using_rspec_assertion }
-    end
-
-    context "with should_not" do
-      FauxThen { a.should_not == 1 }
-      Then { na.should be_using_rspec_assertion }
-    end
-
-    context "with expect/to" do
-      FauxThen { expect(a).to eq(1) }
-      Then { na.should be_using_rspec_assertion }
-    end
-
-    context "with expect/not_to" do
-      FauxThen { expect(a).not_to eq(1) }
-      Then { na.should be_using_rspec_assertion }
-    end
-
-    context "with expect and block" do
-      FauxThen { expect { a }.to eq(1) }
-      Then { na.should be_using_rspec_assertion }
-    end
-
-    context "with natural assertion" do
-      FauxThen { a == 1 }
-      Then { na.should_not be_using_rspec_assertion }
-    end
-  end
-
   describe "failure messages" do
     let(:msg) { na.message }
     Invariant { msg.should =~ /^FauxThen expression/ }
@@ -166,7 +134,7 @@ describe RSpec::Given::NaturalAssertion do
     context "with no statements" do
       FauxThen {  }
       When(:result) { na.message }
-      Then { result.should_not have_failed(RSpec::Given::InvalidThenError) }
+      Then { result.should_not have_failed }
     end
 
     context "with multiple statements" do
@@ -175,7 +143,7 @@ describe RSpec::Given::NaturalAssertion do
         ary[1] == 3
       }
       When(:result) { na.message }
-      Then { result.should have_failed(RSpec::Given::InvalidThenError, /multiple.*statements/i) }
+      Then { result.should have_failed(Given::InvalidThenError, /multiple.*statements/i) }
     end
 
   end