rspec-given 2.2.1 → 2.3.0.beta.1

data/Gemfile

@@ -1,3 +1,10 @@
 source 'https://rubygems.org'
 gem 'rspec', '>= 2.12'
 gem 'rake', '>= 0.9.2.2'
+gem 'sorcerer'
+
+group :dev do
+  gem 'bluecloth'
+  gem 'ghpreview'
+  gem 'flog'
+end

data/Gemfile.lock

@@ -1,8 +1,19 @@
 GEM
   remote: https://rubygems.org/
   specs:
+    bluecloth (2.2.0)
     diff-lcs (1.1.3)
+    flog (3.2.1)
+      ruby_parser (~> 3.1, > 3.1.0)
+      sexp_processor (~> 4.0)
+    ghpreview (0.0.2)
+      httpclient
+      listen
+      rb-fsevent
+    httpclient (2.3.0.1)
+    listen (0.6.0)
     rake (0.9.2.2)
+    rb-fsevent (0.9.2)
     rspec (2.12.0)
       rspec-core (~> 2.12.0)
       rspec-expectations (~> 2.12.0)
@@ -11,10 +22,18 @@ GEM
     rspec-expectations (2.12.0)
       diff-lcs (~> 1.1.3)
     rspec-mocks (2.12.0)
+    ruby_parser (3.1.1)
+      sexp_processor (~> 4.1)
+    sexp_processor (4.1.3)
+    sorcerer (0.3.7)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  bluecloth
+  flog
+  ghpreview
   rake (>= 0.9.2.2)
   rspec (>= 2.12)
+  sorcerer

data/README.md

@@ -1,6 +1,6 @@
 # rspec-given
 
-Covering rspec-given, version 2.2.1.
+Covering rspec-given, version 3.0.0.beta.1.
 
 rspec-given is an RSpec extension to allow Given/When/Then notation in
 RSpec specifications.  It is a natural extension of the experimental
@@ -232,7 +232,7 @@ Let me repeat that: <b>_Then_ clauses should not have any side
 effects!</b> _Then_ clauses with side effects are erroneous. _Then_
 clauses need to be idempotent, so that running them once, twice, a
 hundred times, or never does not change the state of the program. (The
-same is true of _And_ clauses).
+same is true of _And_ and _Invariant_ clauses).
 
 In RSpec terms, a _Then_ clause forms a RSpec Example that runs in the
 context of an Example Group (defined by a describe or context clause).
@@ -261,7 +261,7 @@ The _And_ clause is similar to _Then_, but does not form its own RSpec
 example. This means that _And_ clauses reuse the setup from a sibling
 _Then_ clause. Using a single _Then_ an multiple _And_ clauses in an
 example group means the setup for that group is run only once (for the
-_Then_ clause) and reused for all the _And_s. This can be a
+_Then_ clause) and reused for all the _And_ clauses. This can be a
 significant speed savings where the setup for an example group is
 expensive.
 
@@ -325,6 +325,194 @@ Notes:
    represented in the RSpec formatted output (e.g. the '--format html'
    option).
 
+## Natural Assertions
+
+**NOTE:** <em>Natural assertions are an experimental feature of
+RSpec/Given. They are currently disabled by default.</em>
+
+RSpec/Given now supports the use of "natural assertions" in _Then_,
+_And_, and _Invariant_ blocks. Natural assertions are just Ruby
+conditionals, without the _should_ or _expect_ methods that RSpec
+provides. Here are the Then/And examples from above, but written using
+natural assertions:
+
+```ruby
+  Then { pop_result == :top_item }
+  And  { stack.top == :second_item }
+  And  { stack.depth == original_depth - 1 }
+```
+
+Natural assertions must be enabled, either globally or on a per
+context basis, to be recognized.
+
+### Failure Messages with Natural Assertions
+
+Since natural assertions do not depend upon matchers, you don't get
+customized error messages from them. What you _do_ get is a complete
+analsysis of the expression that failed.
+
+For example, given the following failing specification:
+
+```ruby
+  RSpec::Given.use_natural_assertions
+
+  describe "Natural Assertions" do
+    Given(:foo) { 1 }
+    Given(:bar) { 2 }
+    Then { foo + bar == 2 }
+  end
+```
+
+You would get:
+
+```
+  1) Natural Assertions
+     Failure/Error: Then { foo + bar == 2 }
+       Then expression failed at /Users/jim/working/git/rspec-given/examples/failing/sample_spec.rb:6
+       expected: 3
+       to equal: 2
+         false   <- foo + bar == 2
+         3       <- foo + bar
+         1       <- foo
+         2       <- bar
+     # ./examples/failing/sample_spec.rb:6:in `block in Then'
+```
+
+Notice how the failing expression "<code>foo+bar == 2</code>" was
+broken down into subexpressions and values for each subexpression.
+This gives you all the information you need to figure out exactly what
+part of the expression is causing the failure.
+
+Natural expressions will give additional information (e.g. "expected:
+3 to equal: 2") for top level expressions involving any of the
+comparison operators (==, !=, <, <=, >, >=) or matching operators (=~,
+!~).
+
+### Caveats on Natural Assertions
+
+Keep the following in mind when using Natural Assertions.
+
+* Only a single assertion per _Then_. Only the final expression of the
+  _Then_ block will be considered when determining pass/fail for the
+  assertion. If you _want_ to express a complex condition for the
+  _Then_, you need to use ||, && or some other logical operation to
+  join the conditions into a single expression (and the failure
+  message will breakdown the values for each part).
+
+* Natural assertions must be **idempotent** (that means they don't
+  change anything). Since the natural assertion error message contains
+  the values of all the subexpressions, the expression and its
+  subexpressions will be evaluated multiple times. If the block is not
+  idempotent, you will get changing answers as the subexpressions are
+  evaluated.
+
+That last point is important. If you write code like this:
+
+```ruby
+  # DO NOT WRITE CODE LIKE THIS
+  context "Incorrect non-idempotent conditions" do
+    Given(:ary) { [1, 2, 3] }
+    Then { ary.delete(1) == nil }
+  end
+```
+
+Then the assertion will fail (because <code>ary.delete(1)</code> will
+initially return 1). But when the error message is formated, the
+system reports that <code>ary.delete(1)</code> returns nil. You will
+scratch your head over that for a good while.
+
+Instead, move the state changing code into a When block, then just
+assert what you need about the result from the when block. Something
+like this is good:
+
+```ruby
+  context "Correct idempotent conditions" do
+    Given(:ary) { [1, 2, 3] }
+    When(:result) { ary.delete(1) }
+    Then { result == nil }
+  end
+```
+
+### Mixing Natural Assertions and RSpec Assertions
+
+Natural assertions and RSpec assertions for the most part can be
+intermixed in a single test suite, even within a single context.
+Because there are a few corner cases that might cause problems, they
+must be explicitly enabled before they will be considered.
+
+To enable natural assertions in a context, call the
+_use_natural_assertions_ method in that context. For example:
+
+```ruby
+  context "Outer" do
+    use_natural_assertions
+
+    context "Inner" do
+    end
+
+    context "Disabled" do
+      use_natural_assertions false
+    end
+  end
+```
+
+Both the _Outer_ and _Inner_ contexts will use natural assertions. The
+_Disabled_ context overrides the setting inherited from _Outer_ and
+will not process natural assertions.
+
+See the **configuration** section below to see how to enable natural
+assertions project wide.
+
+### Processing Natural Assertions
+
+When natural assertions are enabled, they are only used if:
+
+1. The block does not throw an RSpec assertion failure (or any other
+   exception for that matter).
+
+1. The block returns false (blocks that return true pass the
+   assertion and don't need a failure message).
+
+1. The block does not directly use RSpec's _should_ or _expect_
+   method.
+
+Detecting that last point (the use of _should_ and _expect_) is done
+by examining the source of the block. However it is not always
+possible to correctly determine if _should_ and _expect_ are used
+merely from the source. Fortunately you can always override the
+automatic detection by either forcing natural assertions (with
+:always) or disabling them (with false).
+
+```ruby
+  # Then uses a non-RSpec version of "should" on
+  context "sample" do
+    use_natural_assertions :always
+    Then { obj.should }    # Non-rspec should is called
+  end
+```
+
+```ruby
+  # Then does not call should directly, so disable natural assertions
+  context "sample" do
+    use_natural_assertions false
+    Then { check_validations(obj) }   # check_validations calls "should" internally
+  end
+
+  # You can also just not use a Then for that condition.
+  context "another sample" do
+    it "checks validations" do
+      check_validations(obj)
+    end
+  end
+```
+
+### Further Reading
+
+Natural assertions were inspired by the [wrong assertion
+library](http://rubygems.org/gems/wrong) by [Alex
+Chaffee](http://rubygems.org/profiles/alexch) and [Steve
+Conover](http://rubygems.org/profiles/sconoversf).
+
 ## Configuration
 
 Just require 'rspec/given' in the spec helper of your project and it
@@ -340,28 +528,18 @@ unconditionally, then add the following line to your spec helper file:
     RSpec::Given.source_caching_disabled = true
 ```
 
-# Future Directions
-
-I really like the way the Given framework is working out.  I feel my
-tests are much more like specifications when I use it.  However, I'm
-not entirely happy with it.
-
-I would like to remove the need for the ".should" in all the _Then_
-clauses. In other words, instead of saying:
+Natural assertions are disabled by default. To globally configure
+natural assertions, add one of the following lines to your spec_helper
+file:
 
 ```ruby
-    Then { x.should == y }
+    RSpec::Given.use_natural_assertions         # Enable natural assertions
+    RSpec::Given.use_natural_assertions true    # Same as above
+    RSpec::Given.use_natural_assertions false   # Disable natural assertions
+    RSpec::Given.use_natural_assertions :always # Always process natural assertions
+                                                # ... even when should/expect are detected
 ```
 
-we could say:
-
-```ruby
-    Then { x == y }
-```
-
-I think the [wrong assertion library](http://rubygems.org/gems/wrong)
-has laid some groundwork in this area.
-
 # Links
 
 * Github: [https://github.com/jimweirich/rspec-given](https://github.com/jimweirich/rspec-given)

data/Rakefile

@@ -66,10 +66,19 @@ task :examples1 => [:verify_rspec1] do
   sh "spec examples/stack/stack_spec1.rb"
 end
 
+EXAMPLES = FileList['examples/**/*_spec.rb'].exclude('examples/failing/*.rb')
+FAILING_EXAMPLES = FileList['examples/failing/**/*_spec.rb']
+
 desc "Run the examples in RSpec 2"
 task :examples2 => [:verify_rspec2] do
   puts "Running examples (with RSpec2)"
-  sh "rspec examples"
+  sh "rspec #{EXAMPLES}"
+end
+
+desc "Run failing examples"
+task :failing => [:verify_rspec2] do
+  puts "Running failing examples (with RSpec2)"
+  sh "rspec #{FAILING_EXAMPLES}"
 end
 
 task :verify_rspec1 do
@@ -89,17 +98,8 @@ end
 directory 'html'
 
 desc "Display the README file"
-task :readme => "html/README.html" do
-  sh "open html/README.html"
-end
-
-desc "format the README file"
-task "html/README.html" => ['html', 'README.md'] do
-  open("README.md") do |source|
-    open('html/README.html', 'w') do |out|
-      out.write(BlueCloth.new(source.read).to_html)
-    end
-  end
+task :readme => ["README.md"] do
+  sh "ghpreview README.md"
 end
 
 desc "Generate an RDoc README"

data/examples/failing/natural_failing_spec.rb

@@ -0,0 +1,36 @@
+require 'rspec/given'
+require 'rspec/given/natural_assertion'
+
+describe "Natural Assertions" do
+  use_natural_assertions
+
+  Given(:foo) { 1 }
+  Given(:expected) { 2 }
+  Given(:ary) { [1] }
+  Given(:empty) { [] }
+  Given(:null) { nil }
+  Then { foo+foo+2*foo == expected }
+  Then { nil == "HI" && true && :symbol  && 1}
+  Then { foo.should == 2 }
+  Then { foo != 1 }
+  Then { foo.should_not == 1 }
+  Then { foo.should be_nil }
+  Then { ary.empty? }
+  Then { !null.nil? }
+  Then { fail "OUCH" }
+  Then { ! empty.empty? }
+  Then {
+    (puts "Ha ha world", ! true)
+  }
+
+  context "Incorrect non-idempotent conditions" do
+    Given(:ary) { [1, 2, 3] }
+    Then { ary.delete(1) == nil }
+  end
+
+  context "Correct idempotent conditions" do
+    Given(:ary) { [1, 2, 3] }
+    When(:result) { ary.delete(1) }
+    Then { result == nil }
+  end
+end

data/examples/failing/sample_spec.rb

@@ -0,0 +1,7 @@
+require 'rspec/given'
+
+describe "Natural Assertions" do
+  Given(:foo) { 1 }
+  Given(:bar) { 2 }
+  Then { foo + bar == 2 }
+end

data/examples/integration/then_spec.rb

@@ -0,0 +1,9 @@
+require 'rspec/given'
+require 'example_helper'
+
+describe "Then" do
+  context "empty thens with natural assertions" do
+    use_natural_assertions
+    Then { }
+  end
+end

data/lib/rspec/given.rb

@@ -12,12 +12,7 @@ end
 if RSpec::Given.using_old_rspec?
   require 'rspec/given/rspec1_given'
 else
-  require 'rspec/given/version'
-  require 'rspec/given/module_methods'
-  require 'rspec/given/file_cache'
-  require 'rspec/given/line_extractor'
-  require 'rspec/given/extensions'
-  require 'rspec/given/configure'
-  require 'rspec/given/failure'
+  require 'rspec/given/core'
   require 'rspec/given/have_failed'
+  require 'rspec/given/configure'
 end

data/lib/rspec/given/configure.rb

@@ -8,5 +8,7 @@ RSpec.configure do |c|
   c.include(RSpec::Given::InstanceExtensions)
   c.include(RSpec::Given::HaveFailed)
 
+  c.backtrace_clean_patterns << /lib\/rspec\/given/
+
   RSpec::Given.detect_formatters(c)
 end

data/lib/rspec/given/core.rb

@@ -0,0 +1,9 @@
+
+# Require all the core features
+
+require 'rspec/given/version'
+require 'rspec/given/module_methods'
+require 'rspec/given/file_cache'
+require 'rspec/given/line_extractor'
+require 'rspec/given/extensions'
+require 'rspec/given/failure'

data/lib/rspec/given/extensions.rb

@@ -1,5 +1,6 @@
 require 'rspec/given/failure'
 require 'rspec/given/module_methods'
+require 'rspec/given/natural_assertion'
 
 module RSpec
   module Given
@@ -9,25 +10,47 @@ module RSpec
     # 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?(:_rg_givens)
+        }
+      end
+
       # List of containing contexts in order from outermost to
       # innermost.
       def _rg_contexts          # :nodoc:
-        self.class.ancestors.select { |context|
-          context.respond_to?(:_rg_givens)
-        }.reverse
+        _rg_inner_contexts.reverse
+      end
+
+      def _rg_info(keyword)
+        _rg_inner_contexts.each do |context|
+          h = context._rg_context_info
+          if h.has_key?(keyword)
+            return h[keyword]
+          end
+        end
+        nil
+      end
+
+      def _rg_natural_assertions?(nassert)
+        info_value = _rg_info(:natural_assertions_enabled)
+        use_na = info_value.nil? ? RSpec::Given.natural_assertions_enabled? : info_value
+        (! nassert.using_rspec_assertion? && use_na) || (use_na == :always)
       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)
+        return if defined?(@_rg_ran) && @_rg_ran
+        @_rg_ran = true
         _rg_contexts.each do |context|
           context._rg_givens.each do |block|
             instance_eval(&block)
           end
         end
-        @_rg_ran = true
       end
 
       # Check all the invariants in the current and surrounding
@@ -35,7 +58,7 @@ module RSpec
       def _rg_check_invariants  # :nodoc:
         _rg_contexts.each do |context|
           context._rg_invariants.each do |block|
-            instance_eval(&block)
+            _rg_evaluate(block)
           end
         end
       end
@@ -43,7 +66,7 @@ module RSpec
       def _rg_check_ands  # :nodoc:
         return if self.class._rg_context_info[:and_ran]
         self.class._rg_and_blocks.each do |block|
-          instance_eval(&block)
+          _rg_evaluate(block)
         end
         self.class._rg_context_info[:and_ran] = true
       end
@@ -52,9 +75,18 @@ module RSpec
       def _rg_then(&block)      # :nodoc:
         _rg_establish_givens
         _rg_check_invariants
-        instance_eval(&block)
+        _rg_evaluate(block)
         _rg_check_ands
       end
+
+      def _rg_evaluate(block)
+        unless instance_eval(&block)
+          nassert = NaturalAssertion.new(block, binding, self.class._rg_lines)
+          if ! nassert.using_rspec_assertion? && nassert.has_content?
+            ::RSpec::Expectations.fail_with nassert.message
+          end
+        end
+      end
     end
 
     module ClassExtensions
@@ -76,7 +108,7 @@ module RSpec
       end
 
       def _rg_context_info
-        @_rg_contet_info ||= {}
+        @_rg_context_info ||= {}
       end
 
       def _rg_lines
@@ -106,8 +138,7 @@ module RSpec
       #    Scenario "a scenario description" do ... end
       #
       def Scenario(description, &block)
-        line = eval("__LINE__", block.binding)
-        file = eval("__FILE__", block.binding)
+        file, line = eval("[__LINE__, __FILE__]", block.binding)
         puts "WARNING: Scenario is deprecated, please use either describe or context (#{file}:#{line})"
         context(description, &block)
       end
@@ -119,8 +150,8 @@ module RSpec
       # every time the specification is executed.
       #
       # :call-seq:
-      #   Given(:name, &block)
-      #   Given(&block)
+      #   Given(:name) { ... code ... }
+      #   Given { ... code ... }
       #
       def Given(*args, &block)
         if args.first.is_a?(Symbol)
@@ -136,6 +167,7 @@ module RSpec
       #
       # :call-seq:
       #   Given!(:name) { ... code ... }
+      #
       def Given!(name, &block)
         let!(name, &block)
         _rg_givens << _rg_trigger_given(name)
@@ -144,8 +176,8 @@ module RSpec
       # Declare the code that is under test.
       #
       # :call-seq:
-      #   When(:named_result, &block)
-      #   When(&block)
+      #   When(:named_result) { ... code_under_test ... }
+      #   When { ... code_under_test ... }
       #
       def When(*args, &block)
         if args.first.is_a?(Symbol)
@@ -170,10 +202,13 @@ module RSpec
       # 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)
-        b = block.binding
-        file = eval "__FILE__", b
-        line = eval "__LINE__", b
+        env = block.binding
+        file, line = eval "[__FILE__, __LINE__]", env
         description = _rg_lines.line(file, line) unless RSpec::Given.source_caching_disabled
         if description
           cmd = "it(description)"
@@ -194,6 +229,10 @@ module RSpec
         fail "And defined without a Then" unless _rg_context_info[:then_defined]
         _rg_and_blocks << block
       end
+
+      def use_natural_assertions(enabled=true)
+        _rg_context_info[:natural_assertions_enabled] = enabled
+      end
     end
   end
 end

data/lib/rspec/given/module_methods.rb

@@ -12,5 +12,13 @@ module RSpec
       format_active = c.formatters.any? { |f| f.class.name !~ /ProgressFormatter/ }
       RSpec::Given.source_caching_disabled = ! format_active
     end
+
+    def self.use_natural_assertions(enabled=true)
+      @natural_assertions_enabled = enabled
+    end
+
+    def self.natural_assertions_enabled?
+      @natural_assertions_enabled
+    end
   end
 end

data/lib/rspec/given/natural_assertion.rb

@@ -0,0 +1,178 @@
+require 'ripper'
+require 'sorcerer'
+
+module RSpec
+  module Given
+
+    InvalidThenError = Class.new(StandardError)
+
+    class EvalErr
+      def initialize(str)
+        @string = str
+      end
+      def size
+        inspect.size
+      end
+      def to_s
+        @string
+      end
+      def inspect
+        @string
+      end
+    end
+
+    class NaturalAssertion
+
+      def initialize(block, env, line_extractor)
+        @block = block
+        @env = env
+        @line_extractor = line_extractor
+        set_file_and_line
+      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 = "Then expression failed at #{source_line}\n"
+        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, eval_in(exp, @env)]
+        }
+      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
+        @line_extractor.line(@code_file, @code_line)
+      end
+
+      def set_file_and_line
+        @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)
+        sexp.first == :program &&
+          sexp[1].first == :stmts_add &&
+          sexp[1][2].first == :method_add_block &&
+          (sexp[1][2][2].first == :brace_block || sexp[1][2][2].first == :do_block)
+      end
+
+      def extract_first_statement(block_sexp)
+        unless contains_one_statement?(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_one_statement?(block_sexp)
+        block_sexp[2].first == :stmts_add &&
+          block_sexp[2][1].first == :stmts_new
+      end
+
+      def extract_statement_from_block(block_sexp)
+        block_sexp[2][2]
+      end
+
+      def eval_sexp(sexp)
+        expr = Sorcerer.source(sexp)
+        eval_in(expr, @env)
+      end
+
+      def eval_in(exp, binding)
+        eval(exp, binding).inspect
+      rescue StandardError => ex
+        EvalErr.new("#{ex.class}: #{ex.message}")
+      end
+
+      WRAP_WIDTH = 20
+
+      def display_pairs(pairs)
+        width = suggest_width(pairs)
+        pairs.each do |x, v|
+          fmt = (v.size > WRAP_WIDTH) ?
+            "  %-#{width+2}s\n  #{' '*(width+2)} <- %s\n" :
+            "  %-#{width+2}s <- %s\n"
+          @output << sprintf(fmt, v, x)
+        end
+      end
+
+      def suggest_width(pairs)
+        pairs.map { |x,v| v.size }.select { |n| n < WRAP_WIDTH }.max || 10
+      end
+
+      def source_line
+        "#{@code_file}:#{@code_line}"
+      end
+    end
+
+  end
+end

data/lib/rspec/given/version.rb

@@ -2,8 +2,10 @@ module RSpec
   module Given
     VERSION_NUMBERS = [
       VERSION_MAJOR = 2,
-      VERSION_MINOR = 2,
-      VERSION_BUILD = 1,
+      VERSION_MINOR = 3,
+      VERSION_BUILD = 0,
+      'beta',
+      VERSION_BETA  = 1,
     ]
     VERSION = VERSION_NUMBERS.join(".")
   end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rspec-given
 version: !ruby/object:Gem::Version
-  version: 2.2.1
-  prerelease: 
+  version: 2.3.0.beta.1
+  prerelease: 6
 platform: ruby
 authors:
 - Jim Weirich
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-24 00:00:00.000000000 Z
+date: 2012-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -27,6 +27,22 @@ dependencies:
     - - ! '>'
       - !ruby/object:Gem::Version
         version: 1.2.8
+- !ruby/object:Gem::Dependency
+  name: sorcerer
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.7
 - !ruby/object:Gem::Dependency
   name: bluecloth
   requirement: !ruby/object:Gem::Requirement
@@ -59,6 +75,22 @@ dependencies:
     - - ! '>'
       - !ruby/object:Gem::Version
         version: 2.4.2
+- !ruby/object:Gem::Dependency
+  name: ghpreview
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
 description: ! 'Given is an RSpec extension that allows explicit definition of the
 
   pre and post-conditions for code under test.
@@ -76,20 +108,25 @@ files:
 - README.md
 - lib/rspec-given.rb
 - lib/rspec/given/configure.rb
+- lib/rspec/given/core.rb
 - lib/rspec/given/extensions.rb
 - lib/rspec/given/failure.rb
 - lib/rspec/given/file_cache.rb
 - lib/rspec/given/have_failed.rb
 - lib/rspec/given/line_extractor.rb
 - lib/rspec/given/module_methods.rb
+- lib/rspec/given/natural_assertion.rb
 - lib/rspec/given/rspec1_given.rb
 - lib/rspec/given/version.rb
 - lib/rspec/given.rb
 - examples/example_helper.rb
+- examples/failing/natural_failing_spec.rb
+- examples/failing/sample_spec.rb
 - examples/integration/and_spec.rb
 - examples/integration/focused_line_spec.rb
 - examples/integration/given_spec.rb
 - examples/integration/invariant_spec.rb
+- examples/integration/then_spec.rb
 - examples/other/line_example.rb
 - examples/stack/stack.rb
 - examples/stack/stack_spec.rb
@@ -111,16 +148,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
-      segments:
-      - 0
-      hash: 3954842768326946335
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: given
 rubygems_version: 1.8.24