Update Rspec syntax
authorGreg Hurrell <greg@hurrell.net>
Mon, 20 Oct 2014 03:51:28 +0000 (20:51 -0700)
committerGreg Hurrell <greg@hurrell.net>
Mon, 20 Oct 2014 03:51:28 +0000 (20:51 -0700)
Did this with the help of the transpec gem. Contrary to the README, I
found I did need to add it to the Gemfile (although obviously, I removed
it immediately afterwards).

Additionally it crashed trying to open `.git/COMMIT_EDITMSG` after the
conversion had completed, because I was running it from inside a
submodule; upstream issue for that:

  https://github.com/yujinakayama/transpec/issues/94

Here are the relevant bits of the output:

  Summary:

  415 conversions
    from: obj.should
      to: expect(obj).to
  382 conversions
    from: == expected
      to: eq(expected)
  100 conversions
    from: lambda { }.should
      to: expect { }.to
  35 conversions
    from: obj.should_not
      to: expect(obj).not_to
  32 conversions
    from: lambda { }.should_not
      to: expect { }.not_to
  2 conversions
    from: it { should_not ... }
      to: it { is_expected.not_to ... }
  1 conversion
    from: it { should ... }
      to: it { is_expected.to ... }

  967 conversions, 0 incompletes, 0 warnings, 0 errors

Sure beats doing it by hand, or even with Vim macros...

21 files changed:
spec/additions/proc_spec.rb
spec/additions/regexp_spec.rb
spec/additions/string_spec.rb
spec/and_predicate_spec.rb
spec/grammar_spec.rb
spec/match_data_wrapper_spec.rb
spec/memoizing_cache_spec.rb
spec/not_predicate_spec.rb
spec/parser_state_spec.rb
spec/parslet_choice_spec.rb
spec/parslet_combining_spec.rb
spec/parslet_merge_spec.rb
spec/parslet_omission_spec.rb
spec/parslet_repetition_spec.rb
spec/parslet_sequence_spec.rb
spec/predicate_spec.rb
spec/proc_parslet_spec.rb
spec/regexp_parslet_spec.rb
spec/string_enumerator_spec.rb
spec/string_parslet_spec.rb
spec/symbol_parslet_spec.rb

index e0788b3f675aa6a97de95e3d10e213bf4d4547ce..5270575d478c9bd1ccde3a4ab051baa6fd55bc92 100755 (executable)
@@ -6,7 +6,7 @@ require 'spec_helper'
 describe 'proc additions' do
   it 'responds to "to_parseable", "parse" and "memoizing_parse"' do
     proc = lambda { |string, options| 'foo' }.to_parseable
-    proc.parse('bar').should == 'foo'
-    proc.memoizing_parse('bar').should == 'foo'
+    expect(proc.parse('bar')).to eq('foo')
+    expect(proc.memoizing_parse('bar')).to eq('foo')
   end
 end
index 5d7b0dcac54d96167961c0e42f3874e43d1672ed..dc5bc396db5658ff6bd1c4fb4fc94156c82f10a6 100755 (executable)
@@ -9,22 +9,22 @@ describe 'using shorthand to get RegexpParslets from Regexp instances' do
   context 'chaining two Regexps with the "&" operator' do
     it 'yields a two-element sequence' do
       sequence = /foo/ & /bar/
-      sequence.parse('foobar').map { |each| each.to_s }.should == ['foo', 'bar']
+      expect(sequence.parse('foobar').map { |each| each.to_s }).to eq(['foo', 'bar'])
     end
   end
 
   context 'chaining three Regexps with the "&" operator' do
     it 'yields a three-element sequence' do
       sequence = /foo/ & /bar/ & /\.\.\./
-      sequence.parse('foobar...').map { |each| each.to_s }.should == ['foo', 'bar', '...']
+      expect(sequence.parse('foobar...').map { |each| each.to_s }).to eq(['foo', 'bar', '...'])
     end
   end
 
   context 'alternating two Regexps with the "|" operator' do
     it 'yields a MatchDataWrapper' do
       sequence = /foo/ | /bar/
-      sequence.parse('foobar').to_s.should == 'foo'
-      sequence.parse('bar...').to_s.should == 'bar'
+      expect(sequence.parse('foobar').to_s).to eq('foo')
+      expect(sequence.parse('bar...').to_s).to eq('bar')
       expect do
         sequence.parse('no match')
       end.to raise_error(Walrat::ParseError)
index 0ed599f922d9f666e8749e5c6a1bd69a10af0ed3..0a17a3adfa5cea17806465c03458f33beac4e405 100755 (executable)
@@ -7,19 +7,19 @@ require 'spec_helper'
 describe String do
   describe '#to_class_name' do
     it 'works with require names' do
-      'foo_bar'.to_class_name.should == 'FooBar'
+      expect('foo_bar'.to_class_name).to eq('FooBar')
     end
 
     it 'works with a single-letter' do
-      'f'.to_class_name.should == 'F'
+      expect('f'.to_class_name).to eq('F')
     end
 
     it 'works with double-underscores' do
-      'foo__bar'.to_class_name.should == 'FooBar'
+      expect('foo__bar'.to_class_name).to eq('FooBar')
     end
 
     it 'works with terminating double-underscores' do
-      'foo__'.to_class_name.should == 'Foo'
+      expect('foo__'.to_class_name).to eq('Foo')
     end
   end
 end
@@ -30,8 +30,8 @@ describe 'iterating over a string' do
   it 'should be able to iterate over strings containing newlines' do
     chars = []
     "hello\nworld".each_char { |c| chars << c }
-    chars.should == ['h', 'e', 'l', 'l', 'o', "\n",
-      'w', 'o', 'r', 'l', 'd']
+    expect(chars).to eq(['h', 'e', 'l', 'l', 'o', "\n",
+      'w', 'o', 'r', 'l', 'd'])
   end
 end
 
@@ -44,27 +44,27 @@ describe 'working with Unicode strings' do
   it 'the "each_char" method should work with multibyte characters' do
     chars = []
     @string.each_char { |c| chars << c }
-    chars.should == ['U', 'n', 'i', 'c', 'o', 'd', 'e', ' ', '€', '!']
+    expect(chars).to eq(['U', 'n', 'i', 'c', 'o', 'd', 'e', ' ', '€', '!'])
   end
 
   it 'the "chars" method should work with multibyte characters' do
-    @string.chars.to_a.should == ['U', 'n', 'i', 'c', 'o', 'd', 'e', ' ', '€', '!']
+    expect(@string.chars.to_a).to eq(['U', 'n', 'i', 'c', 'o', 'd', 'e', ' ', '€', '!'])
   end
 
   it 'should be able to use "enumerator" convenience method to get a string enumerator' do
     enumerator = 'hello€'.enumerator
-    enumerator.next.should == 'h'
-    enumerator.next.should == 'e'
-    enumerator.next.should == 'l'
-    enumerator.next.should == 'l'
-    enumerator.next.should == 'o'
-    enumerator.next.should == '€'
-    enumerator.next.should be_nil
+    expect(enumerator.next).to eq('h')
+    expect(enumerator.next).to eq('e')
+    expect(enumerator.next).to eq('l')
+    expect(enumerator.next).to eq('l')
+    expect(enumerator.next).to eq('o')
+    expect(enumerator.next).to eq('€')
+    expect(enumerator.next).to be_nil
   end
 
   it 'the "jlength" method should correctly report the number of characters in a string' do
-    @string.jlength.should  == 10
-    "€".jlength.should      == 1  # three bytes long, but one character
+    expect(@string.jlength).to  eq(10)
+    expect("€".jlength).to      eq(1)  # three bytes long, but one character
   end
 end
 
@@ -73,21 +73,21 @@ end
 describe 'using shorthand to get StringParslets from String instances' do
   it 'chaining two Strings with the "&" operator should yield a two-element sequence' do
     sequence = 'foo' & 'bar'
-    sequence.parse('foobar').should == ['foo', 'bar']
-    lambda { sequence.parse('no match') }.should raise_error(Walrat::ParseError)
+    expect(sequence.parse('foobar')).to eq(['foo', 'bar'])
+    expect { sequence.parse('no match') }.to raise_error(Walrat::ParseError)
   end
 
   it 'chaining three Strings with the "&" operator should yield a three-element sequence' do
     sequence = 'foo' & 'bar' & '...'
-    sequence.parse('foobar...').should == ['foo', 'bar', '...']
-    lambda { sequence.parse('no match') }.should raise_error(Walrat::ParseError)
+    expect(sequence.parse('foobar...')).to eq(['foo', 'bar', '...'])
+    expect { sequence.parse('no match') }.to raise_error(Walrat::ParseError)
   end
 
   it 'alternating two Strings with the "|" operator should yield a single string' do
     sequence = 'foo' | 'bar'
-    sequence.parse('foo').should == 'foo'
-    sequence.parse('foobar').should == 'foo'
-    sequence.parse('bar').should == 'bar'
-    lambda { sequence.parse('no match') }.should raise_error(Walrat::ParseError)
+    expect(sequence.parse('foo')).to eq('foo')
+    expect(sequence.parse('foobar')).to eq('foo')
+    expect(sequence.parse('bar')).to eq('bar')
+    expect { sequence.parse('no match') }.to raise_error(Walrat::ParseError)
   end
 end
index a5db303baf39ca06dc2fb777cc5ff492e7b68b46..711c441a772cc6c9e1cdf8b1bb1f0a80d359961e 100755 (executable)
@@ -13,8 +13,8 @@ describe Walrat::AndPredicate do
   end
 
   it 'is able to compare for equality' do
-    should eql(Walrat::AndPredicate.new('foo'))     # same
-    should_not eql(Walrat::AndPredicate.new('bar')) # different
-    should_not eql(Walrat::Predicate.new('foo'))    # same but different class
+    is_expected.to eql(Walrat::AndPredicate.new('foo'))     # same
+    is_expected.not_to eql(Walrat::AndPredicate.new('bar')) # different
+    is_expected.not_to eql(Walrat::Predicate.new('foo'))    # same but different class
   end
 end
index 663c5af37998ae75854e2da3c8ea8dcae43a26a6..c19dcf6911a39196483d18ae0d92b7dfa4e1b163 100755 (executable)
@@ -50,8 +50,8 @@ describe Walrat::Grammar do
         node      :my_subclass_of_a_subclass, :my_node_subclass
       end
 
-      NodeGrammar1::MyNodeSubclass.superclass.should == Walrat::Node
-      NodeGrammar1::MySubclassOfASubclass.superclass.should == NodeGrammar1::MyNodeSubclass
+      expect(NodeGrammar1::MyNodeSubclass.superclass).to eq(Walrat::Node)
+      expect(NodeGrammar1::MySubclassOfASubclass.superclass).to eq(NodeGrammar1::MyNodeSubclass)
     end
 
     it 'should complain if an attempt is made to create the same production class twice' do
@@ -97,8 +97,8 @@ describe Walrat::Grammar do
       end
 
       grammar = AliceGrammar.new
-      grammar.parse('foo').should == 'foo'
-      lambda { grammar.parse('') }.should raise_error(Walrat::ParseError)
+      expect(grammar.parse('foo')).to eq('foo')
+      expect { grammar.parse('') }.to raise_error(Walrat::ParseError)
     end
 
     it 'should complain if reference is made to an undefined symbol' do
@@ -116,8 +116,8 @@ describe Walrat::Grammar do
       end
 
       grammar = SimpleGrammar.new
-      grammar.parse('foo!').should == 'foo!'
-      lambda { grammar.parse('---') }.should raise_error(Walrat::ParseError)
+      expect(grammar.parse('foo!')).to eq('foo!')
+      expect { grammar.parse('---') }.to raise_error(Walrat::ParseError)
     end
 
     it 'should be able to parse using a simple grammar (two rules)' do
@@ -128,9 +128,9 @@ describe Walrat::Grammar do
       end
 
       grammar = AlmostAsSimpleGrammar.new
-      grammar.parse('foo!').should == 'foo!'
-      grammar.parse('bar').should == 'bar'
-      lambda { grammar.parse('---') }.should raise_error(Walrat::ParseError)
+      expect(grammar.parse('foo!')).to eq('foo!')
+      expect(grammar.parse('bar')).to eq('bar')
+      expect { grammar.parse('---') }.to raise_error(Walrat::ParseError)
     end
 
     it 'should be able to parse using a simple grammar (three rules)' do
@@ -148,9 +148,9 @@ describe Walrat::Grammar do
       end
 
       grammar = MacGrammar.new
-      grammar.parse('## hello!').should == ['##', ' hello!']
-      grammar.parse('##').should == '##'
-      lambda { grammar.parse('foobar') }.should raise_error(Walrat::ParseError)
+      expect(grammar.parse('## hello!')).to eq(['##', ' hello!'])
+      expect(grammar.parse('##')).to eq('##')
+      expect { grammar.parse('foobar') }.to raise_error(Walrat::ParseError)
 
       # the same grammar rewritten without intermediary parslets
       # (three rules, no standalone parslets)
@@ -162,9 +162,9 @@ describe Walrat::Grammar do
       end
 
       grammar = MacAltGrammar.new
-      grammar.parse('## hello!').should == ['##', ' hello!']
-      grammar.parse('##').should == '##'
-      lambda { grammar.parse('foobar') }.should raise_error(Walrat::ParseError)
+      expect(grammar.parse('## hello!')).to eq(['##', ' hello!'])
+      expect(grammar.parse('##')).to eq('##')
+      expect { grammar.parse('foobar') }.to raise_error(Walrat::ParseError)
     end
 
     it 'should be able to parse using recursive rules (nested parentheses)' do
@@ -178,10 +178,10 @@ describe Walrat::Grammar do
       end
 
       grammar = NestedGrammar.new
-      grammar.parse('()').should == ['(', ')']
-      grammar.parse('(content)').should == ['(', 'content', ')']
-      grammar.parse('(content (and more content))').should == ['(', ['content ', ['(', 'and more content', ')']], ')']
-      lambda { grammar.parse('(') }.should raise_error(Walrat::ParseError)
+      expect(grammar.parse('()')).to eq(['(', ')'])
+      expect(grammar.parse('(content)')).to eq(['(', 'content', ')'])
+      expect(grammar.parse('(content (and more content))')).to eq(['(', ['content ', ['(', 'and more content', ')']], ')'])
+      expect { grammar.parse('(') }.to raise_error(Walrat::ParseError)
 
       # same example but automatically skipping the delimiting braces for clearer output
       class NestedSkippingGrammar < Walrat::Grammar
@@ -190,13 +190,13 @@ describe Walrat::Grammar do
       end
 
       grammar = NestedSkippingGrammar.new
-      grammar.parse('()').should == []
-      grammar.parse('(content)').should == 'content'
-      grammar.parse('(content (and more content))').should == ['content ', 'and more content']
-      grammar.parse('(content (and more content)(and more))').should == ['content ', 'and more content', 'and more']
-      grammar.parse('(content (and more content)(and more)(more still))').should == ['content ', 'and more content', 'and more', 'more still']
-      grammar.parse('(content (and more content)(and more(more still)))').should == ['content ', 'and more content', ['and more', 'more still']]
-      lambda { grammar.parse('(') }.should raise_error(Walrat::ParseError)
+      expect(grammar.parse('()')).to eq([])
+      expect(grammar.parse('(content)')).to eq('content')
+      expect(grammar.parse('(content (and more content))')).to eq(['content ', 'and more content'])
+      expect(grammar.parse('(content (and more content)(and more))')).to eq(['content ', 'and more content', 'and more'])
+      expect(grammar.parse('(content (and more content)(and more)(more still))')).to eq(['content ', 'and more content', 'and more', 'more still'])
+      expect(grammar.parse('(content (and more content)(and more(more still)))')).to eq(['content ', 'and more content', ['and more', 'more still']])
+      expect { grammar.parse('(') }.to raise_error(Walrat::ParseError)
 
       # note that this confusing (possible even misleading) nesting goes away if you use a proper AST
       class NestedBracketsWithAST < Walrat::Grammar
@@ -212,36 +212,36 @@ describe Walrat::Grammar do
 
       # simple tests
       grammar = NestedBracketsWithAST.new
-      grammar.parse('()').children.should == []
-      grammar.parse('(content)').children.to_s.should == 'content'
+      expect(grammar.parse('()').children).to eq([])
+      expect(grammar.parse('(content)').children.to_s).to eq('content')
 
       # nested test: two expressions at the first level, one of them nested
       results = grammar.parse('(content (and more content))')
-      results.children[0].should == 'content '
-      results.children[1].children.to_s.should == 'and more content'
+      expect(results.children[0]).to eq('content ')
+      expect(results.children[1].children.to_s).to eq('and more content')
 
       # nested test: three expressions at first level, two of them nested
       results = grammar.parse('(content (and more content)(and more))')#.should == ['content ', 'and more content', 'and more']
-      results.children[0].should == 'content '
-      results.children[1].children.should == 'and more content'
-      results.children[2].children.should == 'and more'
+      expect(results.children[0]).to eq('content ')
+      expect(results.children[1].children).to eq('and more content')
+      expect(results.children[2].children).to eq('and more')
 
       # nested test: four expressions at the first level, three of them nested
       results = grammar.parse('(content (and more content)(and more)(more still))')
-      results.children[0].should == 'content '
-      results.children[1].children.should == 'and more content'
-      results.children[2].children.should == 'and more'
-      results.children[3].children.should == 'more still'
+      expect(results.children[0]).to eq('content ')
+      expect(results.children[1].children).to eq('and more content')
+      expect(results.children[2].children).to eq('and more')
+      expect(results.children[3].children).to eq('more still')
 
       # nested test: three expressions at the first level, one nested and another not only nested but containing another level of nesting
       results = grammar.parse('(content (and more content)(and more(more still)))')
-      results.children[0].should == 'content '
-      results.children[1].children.should == 'and more content'
-      results.children[2].children[0].should == 'and more'
-      results.children[2].children[1].children.should == 'more still'
+      expect(results.children[0]).to eq('content ')
+      expect(results.children[1].children).to eq('and more content')
+      expect(results.children[2].children[0]).to eq('and more')
+      expect(results.children[2].children[1].children).to eq('more still')
 
       # bad input case
-      lambda { grammar.parse('(') }.should raise_error(Walrat::ParseError)
+      expect { grammar.parse('(') }.to raise_error(Walrat::ParseError)
     end
 
     it 'should be able to parse using recursive rules (nested comments)' do
@@ -254,10 +254,10 @@ describe Walrat::Grammar do
       end
 
       grammar = NestedCommentsGrammar.new
-      grammar.parse('/**/').should == ['/*', '*/']
-      grammar.parse('/*comment*/').should == ['/*', 'comment', '*/']
-      grammar.parse('/* comment /* nested */*/').should == ['/*', [' comment ', ['/*', ' nested ', '*/']], '*/']
-      lambda { grammar.parse('/*') }.should raise_error(Walrat::ParseError)
+      expect(grammar.parse('/**/')).to eq(['/*', '*/'])
+      expect(grammar.parse('/*comment*/')).to eq(['/*', 'comment', '*/'])
+      expect(grammar.parse('/* comment /* nested */*/')).to eq(['/*', [' comment ', ['/*', ' nested ', '*/']], '*/'])
+      expect { grammar.parse('/*') }.to raise_error(Walrat::ParseError)
     end
 
     it 'should be able to write a grammar that produces an AST for a simple language that supports addition and assignment' do
@@ -285,50 +285,50 @@ describe Walrat::Grammar do
 
       grammar = SimpleASTLanguage.new
       results = grammar.parse('hello')
-      results.should be_kind_of(SimpleASTLanguage::Identifier)
-      results.lexeme.should == 'hello'
+      expect(results).to be_kind_of(SimpleASTLanguage::Identifier)
+      expect(results.lexeme).to eq('hello')
 
       results = grammar.parse('1234')
-      results.should be_kind_of(SimpleASTLanguage::IntegerLiteral)
-      results.lexeme.should == '1234'
+      expect(results).to be_kind_of(SimpleASTLanguage::IntegerLiteral)
+      expect(results.lexeme).to eq('1234')
 
       results = grammar.parse('foo=bar')
-      results.should be_kind_of(SimpleASTLanguage::Expression)
-      results.should be_kind_of(SimpleASTLanguage::AssignmentExpression)
-      results.target.should be_kind_of(SimpleASTLanguage::Identifier)
-      results.target.lexeme.should == 'foo'
-      results.value.should be_kind_of(SimpleASTLanguage::Identifier)
-      results.value.lexeme.should == 'bar'
+      expect(results).to be_kind_of(SimpleASTLanguage::Expression)
+      expect(results).to be_kind_of(SimpleASTLanguage::AssignmentExpression)
+      expect(results.target).to be_kind_of(SimpleASTLanguage::Identifier)
+      expect(results.target.lexeme).to eq('foo')
+      expect(results.value).to be_kind_of(SimpleASTLanguage::Identifier)
+      expect(results.value.lexeme).to eq('bar')
 
       results = grammar.parse('baz+123')
-      results.should be_kind_of(SimpleASTLanguage::Expression)
-      results.should be_kind_of(SimpleASTLanguage::AdditionExpression)
-      results.summee.should be_kind_of(SimpleASTLanguage::Identifier)
-      results.summee.lexeme.should == 'baz'
-      results.summor.should be_kind_of(SimpleASTLanguage::IntegerLiteral)
-      results.summor.lexeme.should == '123'
+      expect(results).to be_kind_of(SimpleASTLanguage::Expression)
+      expect(results).to be_kind_of(SimpleASTLanguage::AdditionExpression)
+      expect(results.summee).to be_kind_of(SimpleASTLanguage::Identifier)
+      expect(results.summee.lexeme).to eq('baz')
+      expect(results.summor).to be_kind_of(SimpleASTLanguage::IntegerLiteral)
+      expect(results.summor.lexeme).to eq('123')
 
       results = grammar.parse('foo=abc+123')
-      results.should be_kind_of(SimpleASTLanguage::Expression)
-      results.should be_kind_of(SimpleASTLanguage::AssignmentExpression)
-      results.target.should be_kind_of(SimpleASTLanguage::Identifier)
-      results.target.lexeme.should == 'foo'
-      results.value.should be_kind_of(SimpleASTLanguage::AdditionExpression)
-      results.value.summee.should be_kind_of(SimpleASTLanguage::Identifier)
-      results.value.summee.lexeme.should == 'abc'
-      results.value.summor.should be_kind_of(SimpleASTLanguage::IntegerLiteral)
-      results.value.summor.lexeme.should == '123'
+      expect(results).to be_kind_of(SimpleASTLanguage::Expression)
+      expect(results).to be_kind_of(SimpleASTLanguage::AssignmentExpression)
+      expect(results.target).to be_kind_of(SimpleASTLanguage::Identifier)
+      expect(results.target.lexeme).to eq('foo')
+      expect(results.value).to be_kind_of(SimpleASTLanguage::AdditionExpression)
+      expect(results.value.summee).to be_kind_of(SimpleASTLanguage::Identifier)
+      expect(results.value.summee.lexeme).to eq('abc')
+      expect(results.value.summor).to be_kind_of(SimpleASTLanguage::IntegerLiteral)
+      expect(results.value.summor.lexeme).to eq('123')
 
       results = grammar.parse('a+b+2')
-      results.should be_kind_of(SimpleASTLanguage::Expression)
-      results.should be_kind_of(SimpleASTLanguage::AdditionExpression)
-      results.summee.should be_kind_of(SimpleASTLanguage::Identifier)
-      results.summee.lexeme.should == 'a'
-      results.summor.should be_kind_of(SimpleASTLanguage::AdditionExpression)
-      results.summor.summee.should be_kind_of(SimpleASTLanguage::Identifier)
-      results.summor.summee.lexeme.should == 'b'
-      results.summor.summor.should be_kind_of(SimpleASTLanguage::IntegerLiteral)
-      results.summor.summor.lexeme.should == '2'
+      expect(results).to be_kind_of(SimpleASTLanguage::Expression)
+      expect(results).to be_kind_of(SimpleASTLanguage::AdditionExpression)
+      expect(results.summee).to be_kind_of(SimpleASTLanguage::Identifier)
+      expect(results.summee.lexeme).to eq('a')
+      expect(results.summor).to be_kind_of(SimpleASTLanguage::AdditionExpression)
+      expect(results.summor.summee).to be_kind_of(SimpleASTLanguage::Identifier)
+      expect(results.summor.summee.lexeme).to eq('b')
+      expect(results.summor.summor).to be_kind_of(SimpleASTLanguage::IntegerLiteral)
+      expect(results.summor.summor.lexeme).to eq('2')
     end
 
     it 'should be able to write a grammar that complains if all the input is not consumed' do
@@ -342,12 +342,12 @@ describe Walrat::Grammar do
       end
 
       grammar = ComplainingGrammar.new
-      grammar.parse('').should == ''
-      grammar.parse('foo').should == 'foo'
-      grammar.parse('foo bar').should == ['foo', 'bar']
-      lambda { grammar.parse('...') }.should raise_error(Walrat::ParseError)
-      lambda { grammar.parse('foo...') }.should raise_error(Walrat::ParseError)
-      lambda { grammar.parse('foo bar...') }.should raise_error(Walrat::ParseError)
+      expect(grammar.parse('')).to eq('')
+      expect(grammar.parse('foo')).to eq('foo')
+      expect(grammar.parse('foo bar')).to eq(['foo', 'bar'])
+      expect { grammar.parse('...') }.to raise_error(Walrat::ParseError)
+      expect { grammar.parse('foo...') }.to raise_error(Walrat::ParseError)
+      expect { grammar.parse('foo bar...') }.to raise_error(Walrat::ParseError)
     end
 
     it 'should be able to define a default parslet for intertoken skipping' do
@@ -366,12 +366,12 @@ describe Walrat::Grammar do
       # if I catch these throws at the grammar level I can return nil
       # but note that the previous grammar returns an empty array, which to_s is just ""
       grammar = SkippingGrammar.new
-      lambda { grammar.parse('') }.should throw_symbol(:AndPredicateSuccess)
+      expect { grammar.parse('') }.to throw_symbol(:AndPredicateSuccess)
 
-      grammar.parse('foo').should == 'foo'
-      grammar.parse('foo bar').should == ['foo', 'bar']       # intervening whitespace
-      grammar.parse('foo bar     ').should == ['foo', 'bar']  # trailing whitespace
-      grammar.parse('     foo bar').should == ['foo', 'bar']  # leading whitespace
+      expect(grammar.parse('foo')).to eq('foo')
+      expect(grammar.parse('foo bar')).to eq(['foo', 'bar'])       # intervening whitespace
+      expect(grammar.parse('foo bar     ')).to eq(['foo', 'bar'])  # trailing whitespace
+      expect(grammar.parse('     foo bar')).to eq(['foo', 'bar'])  # leading whitespace
 
       # additional example, this time involving the ">>" pseudo-operator
       class SkippingAndMergingGrammar < Walrat::Grammar
@@ -386,19 +386,19 @@ describe Walrat::Grammar do
 
       # one word
       grammar = SkippingAndMergingGrammar.new
-      grammar.parse('foo').should == 'foo'
+      expect(grammar.parse('foo')).to eq('foo')
 
       # two words
-      grammar.parse('foo,bar').should == ['foo', 'bar']         # no whitespace
-      grammar.parse('foo, bar').should == ['foo', 'bar']        # whitespace after
-      grammar.parse('foo ,bar').should == ['foo', 'bar']        # whitespace before
-      grammar.parse('foo , bar').should == ['foo', 'bar']       # whitespace before and after
-      grammar.parse('foo , bar     ').should == ['foo', 'bar']  # trailing and embedded whitespace
-      grammar.parse('     foo , bar').should == ['foo', 'bar']  # leading and embedded whitespace
+      expect(grammar.parse('foo,bar')).to eq(['foo', 'bar'])         # no whitespace
+      expect(grammar.parse('foo, bar')).to eq(['foo', 'bar'])        # whitespace after
+      expect(grammar.parse('foo ,bar')).to eq(['foo', 'bar'])        # whitespace before
+      expect(grammar.parse('foo , bar')).to eq(['foo', 'bar'])       # whitespace before and after
+      expect(grammar.parse('foo , bar     ')).to eq(['foo', 'bar'])  # trailing and embedded whitespace
+      expect(grammar.parse('     foo , bar')).to eq(['foo', 'bar'])  # leading and embedded whitespace
 
       # three or four words
-      grammar.parse('foo , bar, baz').should == ['foo', 'bar', 'baz']
-      grammar.parse(' foo , bar, baz ,bin').should == ['foo', 'bar', 'baz', 'bin']
+      expect(grammar.parse('foo , bar, baz')).to eq(['foo', 'bar', 'baz'])
+      expect(grammar.parse(' foo , bar, baz ,bin')).to eq(['foo', 'bar', 'baz', 'bin'])
     end
 
     it 'should complain if trying to set default skipping parslet more than once' do
@@ -439,24 +439,24 @@ describe Walrat::Grammar do
 
       # words in word lists can be separated by whitespace or newlines
       grammar = OverrideDefaultSkippingParslet.new
-      grammar.parse('hello world').should ==  ['hello', 'world']
-      grammar.parse("hello\nworld").should == ['hello', 'world']
-      grammar.parse("hello world\nworld hello").should == ['hello', 'world', 'world', 'hello']
+      expect(grammar.parse('hello world')).to eq(['hello', 'world'])
+      expect(grammar.parse("hello\nworld")).to eq(['hello', 'world'])
+      expect(grammar.parse("hello world\nworld hello")).to eq(['hello', 'world', 'world', 'hello'])
 
       # numbers in number lists may be separated only by whitespace, not newlines
-      grammar.parse('123 456').should == ['123', '456']
-      grammar.parse("123\n456").should == ['123', '456'] # this succeeds because parser treats them as two separate number lists
-      grammar.parse("123 456\n456 123").should == [['123', '456'], ['456', '123']]
+      expect(grammar.parse('123 456')).to eq(['123', '456'])
+      expect(grammar.parse("123\n456")).to eq(['123', '456']) # this succeeds because parser treats them as two separate number lists
+      expect(grammar.parse("123 456\n456 123")).to eq([['123', '456'], ['456', '123']])
 
       # intermixing word lists and number lists
-      grammar.parse("bar\n123").should == ['bar', '123']
-      grammar.parse("123\n456\nbar").should == ['123', '456', 'bar']
+      expect(grammar.parse("bar\n123")).to eq(['bar', '123'])
+      expect(grammar.parse("123\n456\nbar")).to eq(['123', '456', 'bar'])
 
       # these were buggy at one point: "123\n456" was getting mashed into "123456" due to misguided use of String#delete! to delete first newline
-      grammar.parse("\n123\n456").should == ['123', '456']
-      grammar.parse("bar\n123\n456").should == ['bar', '123', '456']
-      grammar.parse("baz bar\n123\n456").should == [['baz', 'bar'], '123', '456']
-      grammar.parse("hello world\nfoo\n123 456 baz bar\n123\n456").should == [['hello', 'world', 'foo'], ['123', '456'], ['baz', 'bar'], '123', '456']
+      expect(grammar.parse("\n123\n456")).to eq(['123', '456'])
+      expect(grammar.parse("bar\n123\n456")).to eq(['bar', '123', '456'])
+      expect(grammar.parse("baz bar\n123\n456")).to eq([['baz', 'bar'], '123', '456'])
+      expect(grammar.parse("hello world\nfoo\n123 456 baz bar\n123\n456")).to eq([['hello', 'world', 'foo'], ['123', '456'], ['baz', 'bar'], '123', '456'])
     end
 
     it 'should complain if trying to override the default for the same rule twice' do
@@ -487,12 +487,12 @@ describe Walrat::Grammar do
       end
 
       grammar = NicePlayer.new
-      grammar.parse('hello world').should == 'hello'
-      grammar.parse('hello      world').should == 'hello'
-      grammar.parse('helloworld').should == 'hello'
-      lambda { grammar.parse('hello') }.should raise_error(Walrat::ParseError)
-      lambda { grammar.parse('hello buddy') }.should raise_error(Walrat::ParseError)
-      lambda { grammar.parse("hello\nbuddy") }.should raise_error(Walrat::ParseError)
+      expect(grammar.parse('hello world')).to eq('hello')
+      expect(grammar.parse('hello      world')).to eq('hello')
+      expect(grammar.parse('helloworld')).to eq('hello')
+      expect { grammar.parse('hello') }.to raise_error(Walrat::ParseError)
+      expect { grammar.parse('hello buddy') }.to raise_error(Walrat::ParseError)
+      expect { grammar.parse("hello\nbuddy") }.to raise_error(Walrat::ParseError)
 
       # example 2: word + predicate + other word
       class NicePlayer2 < Walrat::Grammar
@@ -503,12 +503,12 @@ describe Walrat::Grammar do
       end
 
       grammar = NicePlayer2.new
-      grammar.parse('hello world').should == ['hello', 'world']
-      grammar.parse('hello      world').should == ['hello', 'world']
-      grammar.parse('helloworld').should == ['hello', 'world']
-      lambda { grammar.parse('hello') }.should raise_error(Walrat::ParseError)
-      lambda { grammar.parse('hello buddy') }.should raise_error(Walrat::ParseError)
-      lambda { grammar.parse("hello\nbuddy") }.should raise_error(Walrat::ParseError)
+      expect(grammar.parse('hello world')).to eq(['hello', 'world'])
+      expect(grammar.parse('hello      world')).to eq(['hello', 'world'])
+      expect(grammar.parse('helloworld')).to eq(['hello', 'world'])
+      expect { grammar.parse('hello') }.to raise_error(Walrat::ParseError)
+      expect { grammar.parse('hello buddy') }.to raise_error(Walrat::ParseError)
+      expect { grammar.parse("hello\nbuddy") }.to raise_error(Walrat::ParseError)
     end
   end
 end
index df15d94ae729c139ec5aef0f0ae8ee0b69c50376..bb06d73f2f3be9eeefc9f9860faf819abaeba2f6 100755 (executable)
@@ -18,13 +18,13 @@ describe Walrat::MatchDataWrapper do
   specify 'stored match data persists after multiple matches are executed' do
     original      = @match.match_data     # store original value
     'foo'         =~ /foo/                # clobber $~
-    @match.match_data.should == original  # confirm stored value still intact
+    expect(@match.match_data).to eq(original)  # confirm stored value still intact
   end
 
   specify 'comparisons with Strings work without having to call "to_s"' do
-    @match.should         == 'hello agent'  # normal order
-    'hello agent'.should  == @match         # reverse order
-    @match.should_not     == 'foobar'       # inverse test sense (not equal)
-    'foobar'.should_not   == @match         # reverse order
+    expect(@match).to         eq('hello agent')  # normal order
+    expect('hello agent').to  eq(@match)         # reverse order
+    expect(@match).not_to     eq('foobar')       # inverse test sense (not equal)
+    expect('foobar').not_to   eq(@match)         # reverse order
   end
 end
index c4bc1cf2ad1044af7ec38565f77d6cce80091458..dc1892026f30997de3ad0de6d2274eaa17935961 100755 (executable)
@@ -9,17 +9,17 @@ describe Walrat::MemoizingCache::NoValueForKey do
       Walrat::MemoizingCache::NoValueForKey.new
     end.to raise_error(NoMethodError, /private method/)
 
-    Walrat::MemoizingCache::NoValueForKey.instance.object_id.
-      should == Walrat::MemoizingCache::NoValueForKey.instance.object_id
+    expect(Walrat::MemoizingCache::NoValueForKey.instance.object_id).
+      to eq(Walrat::MemoizingCache::NoValueForKey.instance.object_id)
   end
 
   it 'should be able to use NoValueForKey as the default value for a hash' do
     hash = Hash.new Walrat::MemoizingCache::NoValueForKey.instance
-    hash.default.should == Walrat::MemoizingCache::NoValueForKey.instance
-    hash[:foo].should == Walrat::MemoizingCache::NoValueForKey.instance
+    expect(hash.default).to eq(Walrat::MemoizingCache::NoValueForKey.instance)
+    expect(hash[:foo]).to eq(Walrat::MemoizingCache::NoValueForKey.instance)
     hash[:foo] = 'bar'
-    hash[:foo].should == 'bar'
-    hash[:bar].should == Walrat::MemoizingCache::NoValueForKey.instance
+    expect(hash[:foo]).to eq('bar')
+    expect(hash[:bar]).to eq(Walrat::MemoizingCache::NoValueForKey.instance)
   end
 end
 
@@ -52,7 +52,7 @@ describe 'working with left-recursive rules' do
     end
 
     grammar = AlmostInfinite.new
-    grammar.parse('foo').should == 'foo'
+    expect(grammar.parse('foo')).to eq('foo')
   end
 
   it 'retries after short-circuiting if valid continuation point' do
@@ -64,11 +64,11 @@ describe 'working with left-recursive rules' do
 
     # note the right associativity
     grammar = MuchMoreRealisticExample.new
-    grammar.parse('foo').should == 'foo'
-    grammar.parse('foofoo').should == ['foo', 'foo']
-    grammar.parse('foofoofoo').should == [['foo', 'foo'], 'foo']
-    grammar.parse('foofoofoofoo').should == [[['foo', 'foo'], 'foo'], 'foo']
-    grammar.parse('foofoofoofoofoo').should == [[[['foo', 'foo'], 'foo'], 'foo'], 'foo']
+    expect(grammar.parse('foo')).to eq('foo')
+    expect(grammar.parse('foofoo')).to eq(['foo', 'foo'])
+    expect(grammar.parse('foofoofoo')).to eq([['foo', 'foo'], 'foo'])
+    expect(grammar.parse('foofoofoofoo')).to eq([[['foo', 'foo'], 'foo'], 'foo'])
+    expect(grammar.parse('foofoofoofoofoo')).to eq([[[['foo', 'foo'], 'foo'], 'foo'], 'foo'])
   end
 
   specify 'right associativity should work when building AST nodes' do
index f49e5fe2493cc5960ecf4ca0763426c262ea6b7e..f1e2bce16151d070152e4595983f9738a84618c6 100755 (executable)
@@ -11,11 +11,11 @@ describe Walrat::NotPredicate do
   end
 
   it 'can be compared for equality' do
-    Walrat::NotPredicate.new('foo').
-      should eql(Walrat::NotPredicate.new('foo'))      # same
-    Walrat::NotPredicate.new('foo').
-      should_not eql(Walrat::NotPredicate.new('bar'))  # different
-    Walrat::NotPredicate.new('foo').
-      should_not eql(Walrat::Predicate.new('foo'))     # different class
+    expect(Walrat::NotPredicate.new('foo')).
+      to eql(Walrat::NotPredicate.new('foo'))      # same
+    expect(Walrat::NotPredicate.new('foo')).
+      not_to eql(Walrat::NotPredicate.new('bar'))  # different
+    expect(Walrat::NotPredicate.new('foo')).
+      not_to eql(Walrat::Predicate.new('foo'))     # different class
   end
 end
index 5562edc406b129fc22112ee00d0ed2cb30627e1c..e79c2d739fc471bb1151fee832782f7dc35e7291 100755 (executable)
@@ -17,61 +17,61 @@ describe Walrat::ParserState do
   end
 
   it 'before parsing has started "remainder" should equal the entire string' do
-    @state.remainder.should == @base_string
+    expect(@state.remainder).to eq(@base_string)
   end
 
   it 'before parsing has started "remainder" should equal the entire string (when string is an empty string)' do
-    Walrat::ParserState.new('').remainder.should == ''
+    expect(Walrat::ParserState.new('').remainder).to eq('')
   end
 
   it 'before parsing has started "results" should be empty' do
-    @state.results.should be_empty
+    expect(@state.results).to be_empty
   end
 
   it '"parsed" should complain if passed nil' do
-    lambda { @state.parsed(nil) }.should raise_error(ArgumentError)
+    expect { @state.parsed(nil) }.to raise_error(ArgumentError)
   end
 
   it '"skipped" should complain if passed nil' do
-    lambda { @state.skipped(nil) }.should raise_error(ArgumentError)
+    expect { @state.skipped(nil) }.to raise_error(ArgumentError)
   end
 
   it '"parsed" should return the remainder of the string' do
-    @state.parsed('this is the ').should  == 'string to be parsed'
-    @state.parsed('string ').should       == 'to be parsed'
-    @state.parsed('to be parsed').should  == ''
+    expect(@state.parsed('this is the ')).to  eq('string to be parsed')
+    expect(@state.parsed('string ')).to       eq('to be parsed')
+    expect(@state.parsed('to be parsed')).to  eq('')
   end
 
   it '"skipped" should return the remainder of the string' do
-    @state.skipped('this is the ').should == 'string to be parsed'
-    @state.skipped('string ').should      == 'to be parsed'
-    @state.skipped('to be parsed').should == ''
+    expect(@state.skipped('this is the ')).to eq('string to be parsed')
+    expect(@state.skipped('string ')).to      eq('to be parsed')
+    expect(@state.skipped('to be parsed')).to eq('')
   end
 
   it '"results" should return an unwrapped parsed result (for single results)' do
     @state.parsed('this')
-    @state.results.should == 'this'
+    expect(@state.results).to eq('this')
   end
 
   it 'skipped substrings should not appear in "results"' do
     @state.skipped('this')
-    @state.results.should be_empty
+    expect(@state.results).to be_empty
   end
 
   it 'should return an array of the parsed results (for multiple results)' do
     @state.parsed('this ')
     @state.parsed('is ')
-    @state.results.should == ['this ', 'is ']
+    expect(@state.results).to eq(['this ', 'is '])
   end
 
   it 'should work when the entire string is consumed in a single operation (using "parsed")' do
-    @state.parsed(@base_string).should == ''
-    @state.results.should == @base_string
+    expect(@state.parsed(@base_string)).to eq('')
+    expect(@state.results).to eq(@base_string)
   end
 
   it 'should work when the entire string is consumed in a single operation (using "skipped")' do
-    @state.skipped(@base_string).should == ''
-    @state.results.should be_empty
+    expect(@state.skipped(@base_string)).to eq('')
+    expect(@state.results).to be_empty
   end
 
   it '"parsed" should complain if passed something that doesn\'t respond to the "line_end" and "column_end" messages' do
@@ -100,55 +100,55 @@ describe Walrat::ParserState do
 
   it 'should be able to mix use of "parsed" and "skipped" methods' do
     # first example
-    @state.skipped('this is the ').should  == 'string to be parsed'
-    @state.results.should be_empty
-    @state.parsed('string ').should       == 'to be parsed'
-    @state.results.should == 'string '
-    @state.skipped('to be parsed').should  == ''
-    @state.results.should == 'string '
+    expect(@state.skipped('this is the ')).to  eq('string to be parsed')
+    expect(@state.results).to be_empty
+    expect(@state.parsed('string ')).to       eq('to be parsed')
+    expect(@state.results).to eq('string ')
+    expect(@state.skipped('to be parsed')).to  eq('')
+    expect(@state.results).to eq('string ')
 
     # second example (add this test to isolate a bug in another specification)
     state = Walrat::ParserState.new('foo1...')
-    state.skipped('foo').should == '1...'
-    state.remainder.should == '1...'
-    state.results.should be_empty
-    state.parsed('1').should == '...'
-    state.remainder.should == '...'
-    state.results.should == '1'
+    expect(state.skipped('foo')).to eq('1...')
+    expect(state.remainder).to eq('1...')
+    expect(state.results).to be_empty
+    expect(state.parsed('1')).to eq('...')
+    expect(state.remainder).to eq('...')
+    expect(state.results).to eq('1')
   end
 
   it '"parsed" and "results" methods should work with multi-byte Unicode strings' do
     # basic test
     state = Walrat::ParserState.new('400€, foo')
-    state.remainder.should == '400€, foo'
-    state.parsed('40').should == '0€, foo'
-    state.results.should == '40'
-    state.parsed('0€, ').should == 'foo'
-    state.results.should == ['40', '0€, ']
-    state.parsed('foo').should == ''
-    state.results.should == ['40', '0€, ', 'foo']
+    expect(state.remainder).to eq('400€, foo')
+    expect(state.parsed('40')).to eq('0€, foo')
+    expect(state.results).to eq('40')
+    expect(state.parsed('0€, ')).to eq('foo')
+    expect(state.results).to eq(['40', '0€, '])
+    expect(state.parsed('foo')).to eq('')
+    expect(state.results).to eq(['40', '0€, ', 'foo'])
 
     # test with newlines before and after multi-byte chars
     state = Walrat::ParserState.new("400\n or more €...\nfoo")
-    state.remainder.should == "400\n or more €...\nfoo"
-    state.parsed("400\n or more").should == " €...\nfoo"
-    state.results.should == "400\n or more"
-    state.parsed(' €..').should == ".\nfoo"
-    state.results.should == ["400\n or more", ' €..']
-    state.parsed(".\nfoo").should == ''
-    state.results.should == ["400\n or more", ' €..', ".\nfoo"]
+    expect(state.remainder).to eq("400\n or more €...\nfoo")
+    expect(state.parsed("400\n or more")).to eq(" €...\nfoo")
+    expect(state.results).to eq("400\n or more")
+    expect(state.parsed(' €..')).to eq(".\nfoo")
+    expect(state.results).to eq(["400\n or more", ' €..'])
+    expect(state.parsed(".\nfoo")).to eq('')
+    expect(state.results).to eq(["400\n or more", ' €..', ".\nfoo"])
   end
 
   it '"skipped" and "results" methods should work with multi-byte Unicode strings' do
     state = Walrat::ParserState.new('400€, foo')
-    state.remainder.should == '400€, foo'
-    state.skipped('4').should == '00€, foo'
-    state.results.should be_empty
-    state.parsed('0').should == '0€, foo'
-    state.results.should == '0'
-    state.skipped('0€, ').should == 'foo'
-    state.results.should == '0'
-    state.parsed('foo').should == ''
-    state.results.should == ['0', 'foo']
+    expect(state.remainder).to eq('400€, foo')
+    expect(state.skipped('4')).to eq('00€, foo')
+    expect(state.results).to be_empty
+    expect(state.parsed('0')).to eq('0€, foo')
+    expect(state.results).to eq('0')
+    expect(state.skipped('0€, ')).to eq('foo')
+    expect(state.results).to eq('0')
+    expect(state.parsed('foo')).to eq('')
+    expect(state.results).to eq(['0', 'foo'])
   end
 end
index 59097ea57bee4bc02613a401f57675b3ae94d2ea..8c9ec556a74c0be25e346909521bc4c9a3284c90 100755 (executable)
@@ -10,18 +10,18 @@ describe Walrat::ParsletChoice do
   end
 
   it 'hashes should be the same if initialized with the same parseables' do
-    Walrat::ParsletChoice.new(@p1, @p2).hash.should == Walrat::ParsletChoice.new(@p1, @p2).hash
-    Walrat::ParsletChoice.new(@p1, @p2).should eql(Walrat::ParsletChoice.new(@p1, @p2))
+    expect(Walrat::ParsletChoice.new(@p1, @p2).hash).to eq(Walrat::ParsletChoice.new(@p1, @p2).hash)
+    expect(Walrat::ParsletChoice.new(@p1, @p2)).to eql(Walrat::ParsletChoice.new(@p1, @p2))
   end
 
   it 'hashes should (ideally) be different if initialized with different parseables' do
-    Walrat::ParsletChoice.new(@p1, @p2).hash.should_not == Walrat::ParsletChoice.new('baz'.to_parseable, 'abc'.to_parseable).hash
-    Walrat::ParsletChoice.new(@p1, @p2).should_not eql(Walrat::ParsletChoice.new('baz'.to_parseable, 'abc'.to_parseable))
+    expect(Walrat::ParsletChoice.new(@p1, @p2).hash).not_to eq(Walrat::ParsletChoice.new('baz'.to_parseable, 'abc'.to_parseable).hash)
+    expect(Walrat::ParsletChoice.new(@p1, @p2)).not_to eql(Walrat::ParsletChoice.new('baz'.to_parseable, 'abc'.to_parseable))
   end
 
   it 'hashes should be different compared to other similar classes even if initialized with the same parseables' do
-    Walrat::ParsletChoice.new(@p1, @p2).hash.should_not == Walrat::ParsletSequence.new(@p1, @p2).hash
-    Walrat::ParsletChoice.new(@p1, @p2).should_not eql(Walrat::ParsletSequence.new(@p1, @p2))
+    expect(Walrat::ParsletChoice.new(@p1, @p2).hash).not_to eq(Walrat::ParsletSequence.new(@p1, @p2).hash)
+    expect(Walrat::ParsletChoice.new(@p1, @p2)).not_to eql(Walrat::ParsletSequence.new(@p1, @p2))
   end
 
   it 'should be able to use Parslet Choice instances as keys in a hash' do
@@ -30,7 +30,7 @@ describe Walrat::ParsletChoice do
     key2 = Walrat::ParsletChoice.new('baz'.to_parseable, 'abc'.to_parseable)
     hash[:key1] = 'foo'
     hash[:key2] = 'bar'
-    hash[:key1].should == 'foo'
-    hash[:key2].should == 'bar'
+    expect(hash[:key1]).to eq('foo')
+    expect(hash[:key2]).to eq('bar')
   end
 end
index aace632fe716ff8849c80a7f593c0c86cd93c5ce..10ab11f30b056a1462f9191077c6cb2c5eee84d9 100755 (executable)
@@ -7,146 +7,146 @@ describe 'using shorthand operators to combine String, Symbol and Regexp parsers
   it 'should be able to chain a String and a Regexp together' do
     # try in one order
     sequence = 'foo' & /\d+/
-    sequence.parse('foo1000').should == ['foo', '1000']
-    lambda { sequence.parse('foo') }.should raise_error(Walrat::ParseError) # first part alone is not enough
-    lambda { sequence.parse('1000') }.should raise_error(Walrat::ParseError) # neither is second part alone
-    lambda { sequence.parse('1000foo') }.should raise_error(Walrat::ParseError) # order matters
+    expect(sequence.parse('foo1000')).to eq(['foo', '1000'])
+    expect { sequence.parse('foo') }.to raise_error(Walrat::ParseError) # first part alone is not enough
+    expect { sequence.parse('1000') }.to raise_error(Walrat::ParseError) # neither is second part alone
+    expect { sequence.parse('1000foo') }.to raise_error(Walrat::ParseError) # order matters
 
     # same test but in reverse order
     sequence = /\d+/ & 'foo'
-    sequence.parse('1000foo').should == ['1000', 'foo']
-    lambda { sequence.parse('foo') }.should raise_error(Walrat::ParseError) # first part alone is not enough
-    lambda { sequence.parse('1000') }.should raise_error(Walrat::ParseError) # neither is second part alone
-    lambda { sequence.parse('foo1000') }.should raise_error(Walrat::ParseError) # order matters
+    expect(sequence.parse('1000foo')).to eq(['1000', 'foo'])
+    expect { sequence.parse('foo') }.to raise_error(Walrat::ParseError) # first part alone is not enough
+    expect { sequence.parse('1000') }.to raise_error(Walrat::ParseError) # neither is second part alone
+    expect { sequence.parse('foo1000') }.to raise_error(Walrat::ParseError) # order matters
   end
 
   it 'should be able to choose between a String and a Regexp' do
     # try in one order
     sequence = 'foo' | /\d+/
-    sequence.parse('foo').should == 'foo'
-    sequence.parse('100').should == '100'
-    lambda { sequence.parse('bar') }.should raise_error(Walrat::ParseError)
+    expect(sequence.parse('foo')).to eq('foo')
+    expect(sequence.parse('100')).to eq('100')
+    expect { sequence.parse('bar') }.to raise_error(Walrat::ParseError)
 
     # same test but in reverse order
     sequence = /\d+/ | 'foo'
-    sequence.parse('foo').should == 'foo'
-    sequence.parse('100').should == '100'
-    lambda { sequence.parse('bar') }.should raise_error(Walrat::ParseError)
+    expect(sequence.parse('foo')).to eq('foo')
+    expect(sequence.parse('100')).to eq('100')
+    expect { sequence.parse('bar') }.to raise_error(Walrat::ParseError)
   end
 
   it 'should be able to freely intermix String and Regexp objects when chaining and choosing' do
     sequence = 'foo' & /\d+/ | 'bar' & /[XYZ]{3}/
-    sequence.parse('foo123').should == ['foo', '123']
-    sequence.parse('barZYX').should == ['bar', 'ZYX']
-    lambda { sequence.parse('foo') }.should raise_error(Walrat::ParseError)
-    lambda { sequence.parse('123') }.should raise_error(Walrat::ParseError)
-    lambda { sequence.parse('bar') }.should raise_error(Walrat::ParseError)
-    lambda { sequence.parse('XYZ') }.should raise_error(Walrat::ParseError)
-    lambda { sequence.parse('barXY') }.should raise_error(Walrat::ParseError)
+    expect(sequence.parse('foo123')).to eq(['foo', '123'])
+    expect(sequence.parse('barZYX')).to eq(['bar', 'ZYX'])
+    expect { sequence.parse('foo') }.to raise_error(Walrat::ParseError)
+    expect { sequence.parse('123') }.to raise_error(Walrat::ParseError)
+    expect { sequence.parse('bar') }.to raise_error(Walrat::ParseError)
+    expect { sequence.parse('XYZ') }.to raise_error(Walrat::ParseError)
+    expect { sequence.parse('barXY') }.to raise_error(Walrat::ParseError)
   end
 
   it 'should be able to specify minimum and maximum repetition using shorthand methods' do
     # optional (same as "?" in regular expressions)
     sequence = 'foo'.optional
-    sequence.parse('foo').should == 'foo'
-    lambda { sequence.parse('bar') }.should throw_symbol(:ZeroWidthParseSuccess)
+    expect(sequence.parse('foo')).to eq('foo')
+    expect { sequence.parse('bar') }.to throw_symbol(:ZeroWidthParseSuccess)
 
     # zero_or_one (same as optional; "?" in regular expressions)
     sequence = 'foo'.zero_or_one
-    sequence.parse('foo').should == 'foo'
-    lambda { sequence.parse('bar') }.should throw_symbol(:ZeroWidthParseSuccess)
+    expect(sequence.parse('foo')).to eq('foo')
+    expect { sequence.parse('bar') }.to throw_symbol(:ZeroWidthParseSuccess)
 
     # zero_or_more (same as "*" in regular expressions)
     sequence = 'foo'.zero_or_more
-    sequence.parse('foo').should == 'foo'
-    sequence.parse('foofoofoobar').should == ['foo', 'foo', 'foo']
-    lambda { sequence.parse('bar') }.should throw_symbol(:ZeroWidthParseSuccess)
+    expect(sequence.parse('foo')).to eq('foo')
+    expect(sequence.parse('foofoofoobar')).to eq(['foo', 'foo', 'foo'])
+    expect { sequence.parse('bar') }.to throw_symbol(:ZeroWidthParseSuccess)
 
     # one_or_more (same as "+" in regular expressions)
     sequence = 'foo'.one_or_more
-    sequence.parse('foo').should == 'foo'
-    sequence.parse('foofoofoobar').should == ['foo', 'foo', 'foo']
-    lambda { sequence.parse('bar') }.should raise_error(Walrat::ParseError)
+    expect(sequence.parse('foo')).to eq('foo')
+    expect(sequence.parse('foofoofoobar')).to eq(['foo', 'foo', 'foo'])
+    expect { sequence.parse('bar') }.to raise_error(Walrat::ParseError)
 
     # repeat (arbitary limits for min, max; same as {min, max} in regular expressions)
     sequence = 'foo'.repeat(3, 5)
-    sequence.parse('foofoofoobar').should == ['foo', 'foo', 'foo']
-    sequence.parse('foofoofoofoobar').should == ['foo', 'foo', 'foo', 'foo']
-    sequence.parse('foofoofoofoofoobar').should == ['foo', 'foo', 'foo', 'foo', 'foo']
-    sequence.parse('foofoofoofoofoofoobar').should == ['foo', 'foo', 'foo', 'foo', 'foo']
-    lambda { sequence.parse('bar') }.should raise_error(Walrat::ParseError)
-    lambda { sequence.parse('foo') }.should raise_error(Walrat::ParseError)
-    lambda { sequence.parse('foofoo') }.should raise_error(Walrat::ParseError)
+    expect(sequence.parse('foofoofoobar')).to eq(['foo', 'foo', 'foo'])
+    expect(sequence.parse('foofoofoofoobar')).to eq(['foo', 'foo', 'foo', 'foo'])
+    expect(sequence.parse('foofoofoofoofoobar')).to eq(['foo', 'foo', 'foo', 'foo', 'foo'])
+    expect(sequence.parse('foofoofoofoofoofoobar')).to eq(['foo', 'foo', 'foo', 'foo', 'foo'])
+    expect { sequence.parse('bar') }.to raise_error(Walrat::ParseError)
+    expect { sequence.parse('foo') }.to raise_error(Walrat::ParseError)
+    expect { sequence.parse('foofoo') }.to raise_error(Walrat::ParseError)
   end
 
   it 'should be able to apply repetitions to other combinations wrapped in parentheses' do
     sequence = ('foo' & 'bar').one_or_more
-    sequence.parse('foobar').should == ['foo', 'bar']
-    sequence.parse('foobarfoobar').should == [['foo', 'bar'], ['foo', 'bar']] # fails: just returns ['foo', 'bar']
+    expect(sequence.parse('foobar')).to eq(['foo', 'bar'])
+    expect(sequence.parse('foobarfoobar')).to eq([['foo', 'bar'], ['foo', 'bar']]) # fails: just returns ['foo', 'bar']
   end
 
   it 'should be able to combine use of repetition shorthand methods with other shorthand methods' do
     # first we test with chaining
     sequence = 'foo'.optional & 'bar' & 'abc'.one_or_more
-    sequence.parse('foobarabc').should == ['foo', 'bar', 'abc']
-    sequence.parse('foobarabcabc').should == ['foo', 'bar', ['abc', 'abc']]
-    sequence.parse('barabc').should == ['bar', 'abc']
-    lambda { sequence.parse('abc') }.should raise_error(Walrat::ParseError)
+    expect(sequence.parse('foobarabc')).to eq(['foo', 'bar', 'abc'])
+    expect(sequence.parse('foobarabcabc')).to eq(['foo', 'bar', ['abc', 'abc']])
+    expect(sequence.parse('barabc')).to eq(['bar', 'abc'])
+    expect { sequence.parse('abc') }.to raise_error(Walrat::ParseError)
 
     # similar test but with alternation
     sequence = 'foo' | 'bar' | 'abc'.one_or_more
-    sequence.parse('foobarabc').should == 'foo'
-    sequence.parse('barabc').should == 'bar'
-    sequence.parse('abc').should == 'abc'
-    sequence.parse('abcabc').should == ['abc', 'abc']
-    lambda { sequence.parse('nothing') }.should raise_error(Walrat::ParseError)
+    expect(sequence.parse('foobarabc')).to eq('foo')
+    expect(sequence.parse('barabc')).to eq('bar')
+    expect(sequence.parse('abc')).to eq('abc')
+    expect(sequence.parse('abcabc')).to eq(['abc', 'abc'])
+    expect { sequence.parse('nothing') }.to raise_error(Walrat::ParseError)
 
     # test with defective sequence (makes no sense to use "optional" with alternation, will always succeed)
     sequence = 'foo'.optional | 'bar' | 'abc'.one_or_more
-    sequence.parse('foobarabc').should == 'foo'
-    lambda { sequence.parse('nothing') }.should throw_symbol(:ZeroWidthParseSuccess)
+    expect(sequence.parse('foobarabc')).to eq('foo')
+    expect { sequence.parse('nothing') }.to throw_symbol(:ZeroWidthParseSuccess)
   end
 
   it 'should be able to chain a "not predicate"' do
     sequence = 'foo' & 'bar'.not!
-    sequence.parse('foo').should == 'foo' # fails with ['foo'] because that's the way ParserState works...
-    sequence.parse('foo...').should == 'foo' # same
-    lambda { sequence.parse('foobar') }.should raise_error(Walrat::ParseError)
+    expect(sequence.parse('foo')).to eq('foo') # fails with ['foo'] because that's the way ParserState works...
+    expect(sequence.parse('foo...')).to eq('foo') # same
+    expect { sequence.parse('foobar') }.to raise_error(Walrat::ParseError)
   end
 
   it 'an isolated "not predicate" should return a zero-width match' do
     sequence = 'foo'.not!
-    lambda { sequence.parse('foo') }.should raise_error(Walrat::ParseError)
-    lambda { sequence.parse('bar') }.should throw_symbol(:NotPredicateSuccess)
+    expect { sequence.parse('foo') }.to raise_error(Walrat::ParseError)
+    expect { sequence.parse('bar') }.to throw_symbol(:NotPredicateSuccess)
   end
 
   it 'two "not predicates" chained together should act like a union' do
     # this means "not followed by 'foo' and not followed by 'bar'"
     sequence = 'foo'.not! & 'bar'.not!
-    lambda { sequence.parse('foo') }.should raise_error(Walrat::ParseError)
-    lambda { sequence.parse('bar') }.should raise_error(Walrat::ParseError)
-    lambda { sequence.parse('abc') }.should throw_symbol(:NotPredicateSuccess)
+    expect { sequence.parse('foo') }.to raise_error(Walrat::ParseError)
+    expect { sequence.parse('bar') }.to raise_error(Walrat::ParseError)
+    expect { sequence.parse('abc') }.to throw_symbol(:NotPredicateSuccess)
   end
 
   it 'should be able to chain an "and predicate"' do
     sequence = 'foo' & 'bar'.and?
-    sequence.parse('foobar').should == 'foo' # same problem, returns ['foo']
-    lambda { sequence.parse('foo...') }.should raise_error(Walrat::ParseError)
-    lambda { sequence.parse('foo') }.should raise_error(Walrat::ParseError)
+    expect(sequence.parse('foobar')).to eq('foo') # same problem, returns ['foo']
+    expect { sequence.parse('foo...') }.to raise_error(Walrat::ParseError)
+    expect { sequence.parse('foo') }.to raise_error(Walrat::ParseError)
   end
 
   it 'an isolated "and predicate" should return a zero-width match' do
     sequence = 'foo'.and?
-    lambda { sequence.parse('bar') }.should raise_error(Walrat::ParseError)
-    lambda { sequence.parse('foo') }.should throw_symbol(:AndPredicateSuccess)
+    expect { sequence.parse('bar') }.to raise_error(Walrat::ParseError)
+    expect { sequence.parse('foo') }.to throw_symbol(:AndPredicateSuccess)
   end
 
   it 'should be able to follow an "and predicate" with other parslets or combinations' do
     # this is equivalent to "foo" if followed by "bar", or any three characters
     sequence = 'foo' & 'bar'.and? | /.../
-    sequence.parse('foobar').should == 'foo' # returns ['foo']
-    sequence.parse('abc').should == 'abc'
-    lambda { sequence.parse('') }.should raise_error(Walrat::ParseError)
+    expect(sequence.parse('foobar')).to eq('foo') # returns ['foo']
+    expect(sequence.parse('abc')).to eq('abc')
+    expect { sequence.parse('') }.to raise_error(Walrat::ParseError)
 
     # it makes little sense for the predicate to follows a choice operator so we don't test that
   end
@@ -154,69 +154,69 @@ describe 'using shorthand operators to combine String, Symbol and Regexp parsers
   it 'should be able to follow a "not predicate" with other parslets or combinations' do
     # this is equivalent to "foo" followed by any three characters other than "bar"
     sequence = 'foo' & 'bar'.not! & /.../
-    sequence.parse('fooabc').should == ['foo', 'abc']
-    lambda { sequence.parse('foobar') }.should raise_error(Walrat::ParseError)
-    lambda { sequence.parse('foo') }.should raise_error(Walrat::ParseError)
-    lambda { sequence.parse('') }.should raise_error(Walrat::ParseError)
+    expect(sequence.parse('fooabc')).to eq(['foo', 'abc'])
+    expect { sequence.parse('foobar') }.to raise_error(Walrat::ParseError)
+    expect { sequence.parse('foo') }.to raise_error(Walrat::ParseError)
+    expect { sequence.parse('') }.to raise_error(Walrat::ParseError)
   end
 
   it 'should be able to include a "not predicate" when using a repetition operator' do
     # basic example
     sequence = ('foo' & 'bar'.not!).one_or_more
-    sequence.parse('foo').should == 'foo'
-    sequence.parse('foofoobar').should == 'foo'
-    sequence.parse('foofoo').should == ['foo', 'foo']
-    lambda { sequence.parse('bar') }.should raise_error(Walrat::ParseError)
-    lambda { sequence.parse('foobar') }.should raise_error(Walrat::ParseError)
+    expect(sequence.parse('foo')).to eq('foo')
+    expect(sequence.parse('foofoobar')).to eq('foo')
+    expect(sequence.parse('foofoo')).to eq(['foo', 'foo'])
+    expect { sequence.parse('bar') }.to raise_error(Walrat::ParseError)
+    expect { sequence.parse('foobar') }.to raise_error(Walrat::ParseError)
 
     # variation: note that greedy matching alters the behaviour
     sequence = ('foo' & 'bar').one_or_more & 'abc'.not!
-    sequence.parse('foobar').should == ['foo', 'bar']
-    sequence.parse('foobarfoobar').should == [['foo', 'bar'], ['foo', 'bar']]
-    lambda { sequence.parse('foobarabc') }.should raise_error(Walrat::ParseError)
+    expect(sequence.parse('foobar')).to eq(['foo', 'bar'])
+    expect(sequence.parse('foobarfoobar')).to eq([['foo', 'bar'], ['foo', 'bar']])
+    expect { sequence.parse('foobarabc') }.to raise_error(Walrat::ParseError)
   end
 
   it 'should be able to use regular expression shortcuts in conjunction with predicates' do
     # match "foo" as long as it's not followed by a digit
     sequence = 'foo' & /\d/.not!
-    sequence.parse('foo').should == 'foo'
-    sequence.parse('foobar').should == 'foo'
-    lambda { sequence.parse('foo1') }.should raise_error(Walrat::ParseError)
+    expect(sequence.parse('foo')).to eq('foo')
+    expect(sequence.parse('foobar')).to eq('foo')
+    expect { sequence.parse('foo1') }.to raise_error(Walrat::ParseError)
 
     # match "word" characters as long as they're not followed by whitespace
     sequence = /\w+/ & /\s/.not!
-    sequence.parse('foo').should == 'foo'
-    lambda { sequence.parse('foo ') }.should raise_error(Walrat::ParseError)
+    expect(sequence.parse('foo')).to eq('foo')
+    expect { sequence.parse('foo ') }.to raise_error(Walrat::ParseError)
   end
 end
 
 describe 'omitting tokens from the output using the "skip" method' do
   it 'should be able to skip quotation marks delimiting a string' do
     sequence = '"'.skip & /[^"]+/ & '"'.skip
-    sequence.parse('"hello world"').should == 'hello world' # note this is returning a ParserState object
+    expect(sequence.parse('"hello world"')).to eq('hello world') # note this is returning a ParserState object
   end
 
   it 'should be able to skip within a repetition expression' do
     sequence = ('foo'.skip & /\d+/).one_or_more
-    sequence.parse('foo1...').should == '1'
-    sequence.parse('foo1foo2...').should == ['1', '2'] # only returns 1
-    sequence.parse('foo1foo2foo3...').should == ['1', '2', '3'] # only returns 1
+    expect(sequence.parse('foo1...')).to eq('1')
+    expect(sequence.parse('foo1foo2...')).to eq(['1', '2']) # only returns 1
+    expect(sequence.parse('foo1foo2foo3...')).to eq(['1', '2', '3']) # only returns 1
   end
 
   it 'should be able to skip commas separating a list' do
     # closer to real-world use: a comma-separated list
     sequence = /\w+/ & (/\s*,\s*/.skip & /\w+/).zero_or_more
-    sequence.parse('a').should == 'a'
-    sequence.parse('a, b').should == ['a', 'b']
-    sequence.parse('a, b, c').should == ['a', ['b', 'c']]
-    sequence.parse('a, b, c, d').should == ['a', ['b', 'c', 'd']]
+    expect(sequence.parse('a')).to eq('a')
+    expect(sequence.parse('a, b')).to eq(['a', 'b'])
+    expect(sequence.parse('a, b, c')).to eq(['a', ['b', 'c']])
+    expect(sequence.parse('a, b, c, d')).to eq(['a', ['b', 'c', 'd']])
 
     # again, using the ">>" operator
     sequence = /\w+/ >> (/\s*,\s*/.skip & /\w+/).zero_or_more
-    sequence.parse('a').should == 'a'
-    sequence.parse('a, b').should == ['a', 'b']
-    sequence.parse('a, b, c').should == ['a', 'b', 'c']
-    sequence.parse('a, b, c, d').should == ['a', 'b', 'c', 'd']
+    expect(sequence.parse('a')).to eq('a')
+    expect(sequence.parse('a, b')).to eq(['a', 'b'])
+    expect(sequence.parse('a, b, c')).to eq(['a', 'b', 'c'])
+    expect(sequence.parse('a, b, c, d')).to eq(['a', 'b', 'c', 'd'])
   end
 end
 
@@ -224,23 +224,23 @@ describe 'using the shorthand ">>" pseudo-operator' do
   it 'should be able to chain the operator multiple times' do
     # comma-separated words followed by comma-separated digits
     sequence = /[a-zA-Z]+/ >> (/\s*,\s*/.skip & /[a-zA-Z]+/).zero_or_more >> (/\s*,\s*/.skip & /\d+/).one_or_more
-    sequence.parse('a, 1').should == ['a', '1']
-    sequence.parse('a, b, 1').should == ['a', 'b', '1']
-    sequence.parse('a, 1, 2').should == ['a', '1', '2']
-    sequence.parse('a, b, 1, 2').should == ['a', 'b', '1', '2']
+    expect(sequence.parse('a, 1')).to eq(['a', '1'])
+    expect(sequence.parse('a, b, 1')).to eq(['a', 'b', '1'])
+    expect(sequence.parse('a, 1, 2')).to eq(['a', '1', '2'])
+    expect(sequence.parse('a, b, 1, 2')).to eq(['a', 'b', '1', '2'])
 
     # same, but enclosed in quotes
     sequence = '"'.skip & /[a-zA-Z]+/ >> (/\s*,\s*/.skip & /[a-zA-Z]+/).zero_or_more >> (/\s*,\s*/.skip & /\d+/).one_or_more & '"'.skip
-    sequence.parse('"a, 1"').should == ['a', '1']
-    sequence.parse('"a, b, 1"').should == ['a', 'b', '1']
-    sequence.parse('"a, 1, 2"').should == ['a', '1', '2']
-    sequence.parse('"a, b, 1, 2"').should == ['a', 'b', '1', '2']
+    expect(sequence.parse('"a, 1"')).to eq(['a', '1'])
+    expect(sequence.parse('"a, b, 1"')).to eq(['a', 'b', '1'])
+    expect(sequence.parse('"a, 1, 2"')).to eq(['a', '1', '2'])
+    expect(sequence.parse('"a, b, 1, 2"')).to eq(['a', 'b', '1', '2'])
 
     # alternative construction of same
     sequence = /[a-zA-Z]+/ >> (/\s*,\s*/.skip & /[a-zA-Z]+/).zero_or_more & /\s*,\s*/.skip & /\d+/ >> (/\s*,\s*/.skip & /\d+/).zero_or_more
-    sequence.parse('a, 1').should == ['a', '1']
-    sequence.parse('a, b, 1').should == ['a', 'b', '1']
-    sequence.parse('a, 1, 2').should == ['a', '1', '2']
-    sequence.parse('a, b, 1, 2').should == ['a', 'b', '1', '2']
+    expect(sequence.parse('a, 1')).to eq(['a', '1'])
+    expect(sequence.parse('a, b, 1')).to eq(['a', 'b', '1'])
+    expect(sequence.parse('a, 1, 2')).to eq(['a', '1', '2'])
+    expect(sequence.parse('a, b, 1, 2')).to eq(['a', 'b', '1', '2'])
   end
 end
index 767a0b185c900d71d53d1e82577c4e97dce46e82..74911907969658652849b0f0fe51c26bf30daa6b 100755 (executable)
@@ -5,8 +5,8 @@ require 'spec_helper'
 
 describe Walrat::ParsletMerge do
   it 'should be able to compare for equality' do
-    Walrat::ParsletMerge.new('foo', 'bar').should eql(Walrat::ParsletMerge.new('foo', 'bar'))
-    Walrat::ParsletMerge.new('foo', 'bar').should_not eql(Walrat::ParsletOmission.new('foo')) # wrong class
+    expect(Walrat::ParsletMerge.new('foo', 'bar')).to eql(Walrat::ParsletMerge.new('foo', 'bar'))
+    expect(Walrat::ParsletMerge.new('foo', 'bar')).not_to eql(Walrat::ParsletOmission.new('foo')) # wrong class
   end
 
   it 'ParsletMerge and ParsletSequence hashs should not match even if created using the same parseable instances' do
@@ -14,7 +14,7 @@ describe Walrat::ParsletMerge do
     parseable2 = 'bar'.to_parseable
     p1 = Walrat::ParsletMerge.new(parseable1, parseable2)
     p2 = Walrat::ParsletSequence.new(parseable1, parseable2)
-    p1.hash.should_not == p2.hash
-    p1.should_not eql(p2)
+    expect(p1.hash).not_to eq(p2.hash)
+    expect(p1).not_to eql(p2)
   end
 end
index 96166292b0c998c1e998e9473d1921f910823335..0168f3460f752011047417cd18190f642832ded8 100755 (executable)
@@ -34,7 +34,7 @@ describe Walrat::ParsletOmission do
     rescue Walrat::SkippedSubstringException => e
       substring = e.to_s
     end
-    substring.should == 'foo'
+    expect(substring).to eq('foo')
   end
 
   specify 'the parsed substring is an an empty string in the case of a zero-width parse success at a lower level' do
@@ -43,13 +43,13 @@ describe Walrat::ParsletOmission do
     rescue Walrat::SkippedSubstringException => e
       substring = e.to_s
     end
-    substring.should == ''
+    expect(substring).to eq('')
   end
 
   it 'can be compared for equality' do
-    Walrat::ParsletOmission.new('foo').
-      should eql(Walrat::ParsletOmission.new('foo'))
-    Walrat::ParsletOmission.new('foo').
-      should_not eql(Walrat::ParsletOmission.new('bar'))
+    expect(Walrat::ParsletOmission.new('foo')).
+      to eql(Walrat::ParsletOmission.new('foo'))
+    expect(Walrat::ParsletOmission.new('foo')).
+      not_to eql(Walrat::ParsletOmission.new('bar'))
   end
 end
index c0c7472a09c9826d3cf17420a8cc1b4ed1bae29e..f450c57d75ef202b04651bbdb285a672611dde76 100755 (executable)
@@ -27,9 +27,9 @@ describe Walrat::ParsletRepetition do
     expect do
       parslet.parse 'bar'
     end.to throw_symbol(:ZeroWidthParseSuccess)                   # zero times
-    parslet.parse('foo').should == 'foo'                          # one time
-    parslet.parse('foofoo').should == ['foo', 'foo']              # two times
-    parslet.parse('foofoofoobar').should == ['foo', 'foo', 'foo'] # three times
+    expect(parslet.parse('foo')).to eq('foo')                          # one time
+    expect(parslet.parse('foofoo')).to eq(['foo', 'foo'])              # two times
+    expect(parslet.parse('foofoofoobar')).to eq(['foo', 'foo', 'foo']) # three times
   end
 
   it 'should be able to match "zero or one" times (like "?" in regular expressions)' do
@@ -37,8 +37,8 @@ describe Walrat::ParsletRepetition do
     expect do
       parslet.parse 'bar'
     end.to throw_symbol(:ZeroWidthParseSuccess) # zero times
-    parslet.parse('foo').should == 'foo'        # one time
-    parslet.parse('foofoo').should == 'foo'     # stop at one time
+    expect(parslet.parse('foo')).to eq('foo')        # one time
+    expect(parslet.parse('foofoo')).to eq('foo')     # stop at one time
   end
 
   it 'should be able to match "one or more" times (like "+" in regular expressions)' do
@@ -46,9 +46,9 @@ describe Walrat::ParsletRepetition do
     expect do
       parslet.parse 'bar'
     end.to raise_error(Walrat::ParseError)                        # zero times (error)
-    parslet.parse('foo').should == 'foo'                          # one time
-    parslet.parse('foofoo').should == ['foo', 'foo']              # two times
-    parslet.parse('foofoofoobar').should == ['foo', 'foo', 'foo'] # three times
+    expect(parslet.parse('foo')).to eq('foo')                          # one time
+    expect(parslet.parse('foofoo')).to eq(['foo', 'foo'])              # two times
+    expect(parslet.parse('foofoofoobar')).to eq(['foo', 'foo', 'foo']) # three times
   end
 
   it 'should be able to match "between X and Y" times (like {X, Y} in regular expressions)' do
@@ -59,9 +59,9 @@ describe Walrat::ParsletRepetition do
     expect do
       parslet.parse 'foo'
     end.to raise_error(Walrat::ParseError)                        # one time (error)
-    parslet.parse('foofoo').should == ['foo', 'foo']              # two times
-    parslet.parse('foofoofoo').should == ['foo', 'foo', 'foo']    # three times
-    parslet.parse('foofoofoofoo').should == ['foo', 'foo', 'foo'] # stop at three times
+    expect(parslet.parse('foofoo')).to eq(['foo', 'foo'])              # two times
+    expect(parslet.parse('foofoofoo')).to eq(['foo', 'foo', 'foo'])    # three times
+    expect(parslet.parse('foofoofoofoo')).to eq(['foo', 'foo', 'foo']) # stop at three times
   end
 
   it 'matches should be greedy' do
@@ -74,11 +74,11 @@ describe Walrat::ParsletRepetition do
   end
 
   it 'should be able to compare for equality' do
-    Walrat::ParsletRepetition.new('foo'.to_parseable, 1).
-      should eql(Walrat::ParsletRepetition.new('foo'.to_parseable, 1))
-    Walrat::ParsletRepetition.new('foo'.to_parseable, 1).
-      should_not eql(Walrat::ParsletRepetition.new('bar'.to_parseable, 1))
-    Walrat::ParsletRepetition.new('foo'.to_parseable, 1).
-      should_not eql(Walrat::ParsletRepetition.new('foo'.to_parseable, 2))
+    expect(Walrat::ParsletRepetition.new('foo'.to_parseable, 1)).
+      to eql(Walrat::ParsletRepetition.new('foo'.to_parseable, 1))
+    expect(Walrat::ParsletRepetition.new('foo'.to_parseable, 1)).
+      not_to eql(Walrat::ParsletRepetition.new('bar'.to_parseable, 1))
+    expect(Walrat::ParsletRepetition.new('foo'.to_parseable, 1)).
+      not_to eql(Walrat::ParsletRepetition.new('foo'.to_parseable, 2))
   end
 end
index a974c679a5151f424fc598a6175b495dd80f4d70..a71901b5624326016dcd15f11f82a8fbd1827c3e 100755 (executable)
@@ -10,24 +10,24 @@ describe Walrat::ParsletSequence do
   end
 
   it 'hashes should be the same if initialized with the same parseables' do
-    Walrat::ParsletSequence.new(@p1, @p2).hash.
-      should == Walrat::ParsletSequence.new(@p1, @p2).hash
-    Walrat::ParsletSequence.new(@p1, @p2).
-      should eql(Walrat::ParsletSequence.new(@p1, @p2))
+    expect(Walrat::ParsletSequence.new(@p1, @p2).hash).
+      to eq(Walrat::ParsletSequence.new(@p1, @p2).hash)
+    expect(Walrat::ParsletSequence.new(@p1, @p2)).
+      to eql(Walrat::ParsletSequence.new(@p1, @p2))
   end
 
   it 'hashes should (ideally) be different if initialized with different parseables' do
-    Walrat::ParsletSequence.new(@p1, @p2).hash.
-      should_not == Walrat::ParsletSequence.new('baz'.to_parseable, 'abc'.to_parseable).hash
-    Walrat::ParsletSequence.new(@p1, @p2).
-      should_not eql(Walrat::ParsletSequence.new('baz'.to_parseable, 'abc'.to_parseable))
+    expect(Walrat::ParsletSequence.new(@p1, @p2).hash).
+      not_to eq(Walrat::ParsletSequence.new('baz'.to_parseable, 'abc'.to_parseable).hash)
+    expect(Walrat::ParsletSequence.new(@p1, @p2)).
+      not_to eql(Walrat::ParsletSequence.new('baz'.to_parseable, 'abc'.to_parseable))
   end
 
   it 'hashes should be different compared to other similar classes even if initialized with the same parseables' do
-    Walrat::ParsletSequence.new(@p1, @p2).hash.
-      should_not == Walrat::ParsletChoice.new(@p1, @p2).hash
-    Walrat::ParsletSequence.new(@p1, @p2).
-      should_not eql(Walrat::ParsletChoice.new(@p1, @p2))
+    expect(Walrat::ParsletSequence.new(@p1, @p2).hash).
+      not_to eq(Walrat::ParsletChoice.new(@p1, @p2).hash)
+    expect(Walrat::ParsletSequence.new(@p1, @p2)).
+      not_to eql(Walrat::ParsletChoice.new(@p1, @p2))
   end
 
   it 'should be able to use Parslet Choice instances as keys in a hash' do
@@ -36,7 +36,7 @@ describe Walrat::ParsletSequence do
     key2 = Walrat::ParsletSequence.new('baz'.to_parseable, 'abc'.to_parseable)
     hash[:key1] = 'foo'
     hash[:key2] = 'bar'
-    hash[:key1].should == 'foo'
-    hash[:key2].should == 'bar'
+    expect(hash[:key1]).to eq('foo')
+    expect(hash[:key2]).to eq('bar')
   end
 end
index 63551254d5e4f4dc00825c849e0149f365ec71d3..0ec2a98dd54737a69c175085ea446cc06b915362 100755 (executable)
@@ -19,8 +19,8 @@ describe Walrat::Predicate do
   end
 
   it 'should be able to compare predicates for equality' do
-    Walrat::Predicate.new('foo').should eql(Walrat::Predicate.new('foo'))
-    Walrat::Predicate.new('foo').should_not eql(Walrat::Predicate.new('bar'))
+    expect(Walrat::Predicate.new('foo')).to eql(Walrat::Predicate.new('foo'))
+    expect(Walrat::Predicate.new('foo')).not_to eql(Walrat::Predicate.new('bar'))
   end
 
   it '"and" and "not" predicates should yield different hashes even if initialized with the same "parseable"' do
@@ -29,12 +29,12 @@ describe Walrat::Predicate do
     p2 = Walrat::AndPredicate.new(parseable)
     p3 = Walrat::NotPredicate.new(parseable)
 
-    p1.hash.should_not == p2.hash
-    p2.hash.should_not == p3.hash
-    p3.hash.should_not == p1.hash
+    expect(p1.hash).not_to eq(p2.hash)
+    expect(p2.hash).not_to eq(p3.hash)
+    expect(p3.hash).not_to eq(p1.hash)
 
-    p1.should_not eql(p2)
-    p2.should_not eql(p3)
-    p3.should_not eql(p1)
+    expect(p1).not_to eql(p2)
+    expect(p2).not_to eql(p3)
+    expect(p3).not_to eql(p1)
   end
 end
index 67917d0353309ccda7a9fa064814c6ac4933ef49..b31701032ab8b2348d547bbe379149aefcabb543 100755 (executable)
@@ -33,14 +33,14 @@ describe Walrat::ProcParslet do
   end
 
   it 'returns a parsed value if able to parse' do
-    @parslet.parse('foobar').should == 'foobar'
+    expect(@parslet.parse('foobar')).to eq('foobar')
   end
 
   it 'can be compared for equality' do
     # in practice only parslets created with the exact same Proc instance will
     # be eql because Proc returns different hashes for each
-    @parslet.should eql(@parslet.clone)
-    @parslet.should eql(@parslet.dup)
-    @parslet.should_not eql(lambda { nil }.to_parseable)
+    expect(@parslet).to eql(@parslet.clone)
+    expect(@parslet).to eql(@parslet.dup)
+    expect(@parslet).not_to eql(lambda { nil }.to_parseable)
   end
 end
index 9d7637e445f17fb1150ac297350b99896c182963..46f11ab4fbd2417c57d5c9792af6c5a923e26a18 100755 (executable)
@@ -15,44 +15,44 @@ describe Walrat::RegexpParslet do
   end
 
   it 'parse should succeed if the input string matches' do
-    lambda { @parslet.parse('an_identifier') }.should_not raise_error
-    lambda { @parslet.parse('An_Identifier') }.should_not raise_error
-    lambda { @parslet.parse('AN_IDENTIFIER') }.should_not raise_error
-    lambda { @parslet.parse('an_identifier1') }.should_not raise_error
-    lambda { @parslet.parse('An_Identifier1') }.should_not raise_error
-    lambda { @parslet.parse('AN_IDENTIFIER1') }.should_not raise_error
-    lambda { @parslet.parse('a') }.should_not raise_error
-    lambda { @parslet.parse('A') }.should_not raise_error
-    lambda { @parslet.parse('a9') }.should_not raise_error
-    lambda { @parslet.parse('A9') }.should_not raise_error
-    lambda { @parslet.parse('_identifier') }.should_not raise_error
-    lambda { @parslet.parse('_Identifier') }.should_not raise_error
-    lambda { @parslet.parse('_IDENTIFIER') }.should_not raise_error
-    lambda { @parslet.parse('_9Identifier') }.should_not raise_error
-    lambda { @parslet.parse('_') }.should_not raise_error
+    expect { @parslet.parse('an_identifier') }.not_to raise_error
+    expect { @parslet.parse('An_Identifier') }.not_to raise_error
+    expect { @parslet.parse('AN_IDENTIFIER') }.not_to raise_error
+    expect { @parslet.parse('an_identifier1') }.not_to raise_error
+    expect { @parslet.parse('An_Identifier1') }.not_to raise_error
+    expect { @parslet.parse('AN_IDENTIFIER1') }.not_to raise_error
+    expect { @parslet.parse('a') }.not_to raise_error
+    expect { @parslet.parse('A') }.not_to raise_error
+    expect { @parslet.parse('a9') }.not_to raise_error
+    expect { @parslet.parse('A9') }.not_to raise_error
+    expect { @parslet.parse('_identifier') }.not_to raise_error
+    expect { @parslet.parse('_Identifier') }.not_to raise_error
+    expect { @parslet.parse('_IDENTIFIER') }.not_to raise_error
+    expect { @parslet.parse('_9Identifier') }.not_to raise_error
+    expect { @parslet.parse('_') }.not_to raise_error
   end
 
   it 'parse should succeed if the input string matches, even if it continues after the match' do
-    lambda { @parslet.parse('an_identifier, more') }.should_not raise_error
-    lambda { @parslet.parse('An_Identifier, more') }.should_not raise_error
-    lambda { @parslet.parse('AN_IDENTIFIER, more') }.should_not raise_error
-    lambda { @parslet.parse('an_identifier1, more') }.should_not raise_error
-    lambda { @parslet.parse('An_Identifier1, more') }.should_not raise_error
-    lambda { @parslet.parse('AN_IDENTIFIER1, more') }.should_not raise_error
-    lambda { @parslet.parse('a, more') }.should_not raise_error
-    lambda { @parslet.parse('A, more') }.should_not raise_error
-    lambda { @parslet.parse('a9, more') }.should_not raise_error
-    lambda { @parslet.parse('A9, more') }.should_not raise_error
-    lambda { @parslet.parse('_identifier, more') }.should_not raise_error
-    lambda { @parslet.parse('_Identifier, more') }.should_not raise_error
-    lambda { @parslet.parse('_IDENTIFIER, more') }.should_not raise_error
-    lambda { @parslet.parse('_9Identifier, more') }.should_not raise_error
-    lambda { @parslet.parse('_, more') }.should_not raise_error
+    expect { @parslet.parse('an_identifier, more') }.not_to raise_error
+    expect { @parslet.parse('An_Identifier, more') }.not_to raise_error
+    expect { @parslet.parse('AN_IDENTIFIER, more') }.not_to raise_error
+    expect { @parslet.parse('an_identifier1, more') }.not_to raise_error
+    expect { @parslet.parse('An_Identifier1, more') }.not_to raise_error
+    expect { @parslet.parse('AN_IDENTIFIER1, more') }.not_to raise_error
+    expect { @parslet.parse('a, more') }.not_to raise_error
+    expect { @parslet.parse('A, more') }.not_to raise_error
+    expect { @parslet.parse('a9, more') }.not_to raise_error
+    expect { @parslet.parse('A9, more') }.not_to raise_error
+    expect { @parslet.parse('_identifier, more') }.not_to raise_error
+    expect { @parslet.parse('_Identifier, more') }.not_to raise_error
+    expect { @parslet.parse('_IDENTIFIER, more') }.not_to raise_error
+    expect { @parslet.parse('_9Identifier, more') }.not_to raise_error
+    expect { @parslet.parse('_, more') }.not_to raise_error
   end
 
   it 'parse should return a MatchDataWrapper object' do
-    @parslet.parse('an_identifier').should == 'an_identifier'
-    @parslet.parse('an_identifier, more').should == 'an_identifier'
+    expect(@parslet.parse('an_identifier')).to eq('an_identifier')
+    expect(@parslet.parse('an_identifier, more')).to eq('an_identifier')
   end
 
   it 'parse should raise an ArgumentError if passed nil' do
@@ -62,55 +62,55 @@ describe Walrat::RegexpParslet do
   end
 
   it 'parse should raise a ParseError if the input string does not match' do
-    lambda { @parslet.parse('9') }.should raise_error(Walrat::ParseError)           # a number is not a valid identifier
-    lambda { @parslet.parse('9fff') }.should raise_error(Walrat::ParseError)        # identifiers must not start with numbers
-    lambda { @parslet.parse(' identifier') }.should raise_error(Walrat::ParseError) # note the leading whitespace
-    lambda { @parslet.parse('') }.should raise_error(Walrat::ParseError)            # empty strings can't match
+    expect { @parslet.parse('9') }.to raise_error(Walrat::ParseError)           # a number is not a valid identifier
+    expect { @parslet.parse('9fff') }.to raise_error(Walrat::ParseError)        # identifiers must not start with numbers
+    expect { @parslet.parse(' identifier') }.to raise_error(Walrat::ParseError) # note the leading whitespace
+    expect { @parslet.parse('') }.to raise_error(Walrat::ParseError)            # empty strings can't match
   end
 
   it 'should be able to compare parslets for equality' do
-    /foo/.to_parseable.should eql(/foo/.to_parseable)        # equal
-    /foo/.to_parseable.should_not eql(/bar/.to_parseable)    # different
-    /foo/.to_parseable.should_not eql(/Foo/.to_parseable)    # differing only in case
-    /foo/.to_parseable.should_not eql('foo')                 # totally different classes
+    expect(/foo/.to_parseable).to eql(/foo/.to_parseable)        # equal
+    expect(/foo/.to_parseable).not_to eql(/bar/.to_parseable)    # different
+    expect(/foo/.to_parseable).not_to eql(/Foo/.to_parseable)    # differing only in case
+    expect(/foo/.to_parseable).not_to eql('foo')                 # totally different classes
   end
 
   it 'should accurately pack line and column ends into whatever gets returned from "parse"' do
     # single word
     parslet = /.+/m.to_parseable
     result = parslet.parse('hello')
-    result.line_end.should == 0
-    result.column_end.should == 5
+    expect(result.line_end).to eq(0)
+    expect(result.column_end).to eq(5)
 
     # single word with newline at end (UNIX style)
     result = parslet.parse("hello\n")
-    result.line_end.should == 1
-    result.column_end.should == 0
+    expect(result.line_end).to eq(1)
+    expect(result.column_end).to eq(0)
 
     # single word with newline at end (Classic Mac style)
     result = parslet.parse("hello\r")
-    result.line_end.should == 1
-    result.column_end.should == 0
+    expect(result.line_end).to eq(1)
+    expect(result.column_end).to eq(0)
 
     # single word with newline at end (Windows style)
     result = parslet.parse("hello\r\n")
-    result.line_end.should == 1
-    result.column_end.should == 0
+    expect(result.line_end).to eq(1)
+    expect(result.column_end).to eq(0)
 
     # two lines (UNIX style)
     result = parslet.parse("hello\nworld")
-    result.line_end.should == 1
-    result.column_end.should == 5
+    expect(result.line_end).to eq(1)
+    expect(result.column_end).to eq(5)
 
     # two lines (Classic Mac style)
     result = parslet.parse("hello\rworld")
-    result.line_end.should == 1
-    result.column_end.should == 5
+    expect(result.line_end).to eq(1)
+    expect(result.column_end).to eq(5)
 
     # two lines (Windows style)
     result = parslet.parse("hello\r\nworld")
-    result.line_end.should == 1
-    result.column_end.should == 5
+    expect(result.line_end).to eq(1)
+    expect(result.column_end).to eq(5)
   end
 
   # in the case of RegexpParslets, the "last successfully scanned position" is
@@ -123,8 +123,8 @@ describe Walrat::RegexpParslet do
     rescue Walrat::ParseError => e
       exception = e
     end
-    exception.line_end.should == 0
-    exception.column_end.should == 0
+    expect(exception.line_end).to eq(0)
+    expect(exception.column_end).to eq(0)
 
     # fail after 1 character
     begin
@@ -132,8 +132,8 @@ describe Walrat::RegexpParslet do
     rescue Walrat::ParseError => e
       exception = e
     end
-    exception.line_end.should == 0
-    exception.column_end.should == 0
+    expect(exception.line_end).to eq(0)
+    expect(exception.column_end).to eq(0)
 
     # fail after end-of-line
     begin
@@ -141,8 +141,8 @@ describe Walrat::RegexpParslet do
     rescue Walrat::ParseError => e
       exception = e
     end
-    exception.line_end.should == 0
-    exception.column_end.should == 0
+    expect(exception.line_end).to eq(0)
+    expect(exception.column_end).to eq(0)
   end
 end
 
@@ -150,7 +150,7 @@ describe 'chaining two regexp parslets together' do
   it 'parslets should work in specified order' do
     parslet = Walrat::RegexpParslet.new(/foo.\d/) &
               Walrat::RegexpParslet.new(/bar.\d/)
-    parslet.parse('foo_1bar_2').should == ['foo_1', 'bar_2']
+    expect(parslet.parse('foo_1bar_2')).to eq(['foo_1', 'bar_2'])
   end
 
   # Parser Expression Grammars match greedily
@@ -159,7 +159,7 @@ describe 'chaining two regexp parslets together' do
     # second parslet from succeeding
     parslet = Walrat::RegexpParslet.new(/foo.+\d/) &
               Walrat::RegexpParslet.new(/bar.+\d/)
-    lambda { parslet.parse('foo_1bar_2') }.should raise_error(Walrat::ParseError)
+    expect { parslet.parse('foo_1bar_2') }.to raise_error(Walrat::ParseError)
   end
 end
 
@@ -167,14 +167,14 @@ describe 'alternating two regexp parslets' do
   it 'either parslet should apply to generate a match' do
     parslet = Walrat::RegexpParslet.new(/\d+/) |
               Walrat::RegexpParslet.new(/[A-Z]+/)
-    parslet.parse('ABC').should == 'ABC'
-    parslet.parse('123').should == '123'
+    expect(parslet.parse('ABC')).to eq('ABC')
+    expect(parslet.parse('123')).to eq('123')
   end
 
   it 'should fail if no parslet generates a match' do
     parslet = Walrat::RegexpParslet.new(/\d+/) |
               Walrat::RegexpParslet.new(/[A-Z]+/)
-    lambda { parslet.parse('abc') }.should raise_error(Walrat::ParseError)
+    expect { parslet.parse('abc') }.to raise_error(Walrat::ParseError)
   end
 
   it 'parslets should be tried in left-to-right order' do
@@ -182,15 +182,15 @@ describe 'alternating two regexp parslets' do
     parslet = Walrat::RegexpParslet.new(/(.)(..)/) |
               Walrat::RegexpParslet.new(/(..)(.)/)
     match_data = parslet.parse('abc').match_data
-    match_data[1].should == 'a'
-    match_data[2].should == 'bc'
+    expect(match_data[1]).to eq('a')
+    expect(match_data[2]).to eq('bc')
 
     # here we swap the order; again the first parslet should win
     parslet = Walrat::RegexpParslet.new(/(..)(.)/) |
               Walrat::RegexpParslet.new(/(.)(..)/)
     match_data = parslet.parse('abc').match_data
-    match_data[1].should == 'ab'
-    match_data[2].should == 'c'
+    expect(match_data[1]).to eq('ab')
+    expect(match_data[2]).to eq('c')
   end
 end
 
@@ -199,7 +199,7 @@ describe 'chaining three regexp parslets' do
     parslet = Walrat::RegexpParslet.new(/foo.\d/) &
               Walrat::RegexpParslet.new(/bar.\d/) &
               Walrat::RegexpParslet.new(/.../)
-    parslet.parse('foo_1bar_2ABC').should == ['foo_1', 'bar_2', 'ABC']
+    expect(parslet.parse('foo_1bar_2ABC')).to eq(['foo_1', 'bar_2', 'ABC'])
   end
 end
 
@@ -208,16 +208,16 @@ describe 'alternating three regexp parslets' do
     parslet = Walrat::RegexpParslet.new(/\d+/) |
               Walrat::RegexpParslet.new(/[A-Z]+/) |
               Walrat::RegexpParslet.new(/[a-z]+/)
-    parslet.parse('ABC').should == 'ABC'
-    parslet.parse('123').should == '123'
-    parslet.parse('abc').should == 'abc'
+    expect(parslet.parse('ABC')).to eq('ABC')
+    expect(parslet.parse('123')).to eq('123')
+    expect(parslet.parse('abc')).to eq('abc')
   end
 
   it 'should fail if no parslet generates a match' do
     parslet = Walrat::RegexpParslet.new(/\d+/) |
               Walrat::RegexpParslet.new(/[A-Z]+/) |
               Walrat::RegexpParslet.new(/[a-z]+/)
-    lambda { parslet.parse(':::') }.should raise_error(Walrat::ParseError)
+    expect { parslet.parse(':::') }.to raise_error(Walrat::ParseError)
   end
 
   it 'parslets should be tried in left-to-right order' do
@@ -226,23 +226,23 @@ describe 'alternating three regexp parslets' do
               Walrat::RegexpParslet.new(/(..)(.)/) |
               Walrat::RegexpParslet.new(/(...)/)
     match_data = parslet.parse('abc').match_data
-    match_data[1].should == 'a'
-    match_data[2].should == 'bc'
+    expect(match_data[1]).to eq('a')
+    expect(match_data[2]).to eq('bc')
 
     # here we swap the order; again the first parslet should win
     parslet = Walrat::RegexpParslet.new(/(..)(.)/) |
               Walrat::RegexpParslet.new(/(.)(..)/) |
               Walrat::RegexpParslet.new(/(...)/)
     match_data = parslet.parse('abc').match_data
-    match_data[1].should == 'ab'
-    match_data[2].should == 'c'
+    expect(match_data[1]).to eq('ab')
+    expect(match_data[2]).to eq('c')
 
     # similar test but this time the first parslet can't win (doesn't match)
     parslet = Walrat::RegexpParslet.new(/foo/) |
               Walrat::RegexpParslet.new(/(...)/) |
               Walrat::RegexpParslet.new(/(.)(..)/)
     match_data = parslet.parse('abc').match_data
-    match_data[1].should == 'abc'
+    expect(match_data[1]).to eq('abc')
   end
 end
 
@@ -252,19 +252,19 @@ describe 'combining chaining and alternation' do
     parslet = Walrat::RegexpParslet.new(/foo/) |
               Walrat::RegexpParslet.new(/bar/) &
               Walrat::RegexpParslet.new(/abc/)
-    parslet.parse('foo').should == 'foo'                                            # succeed on first choice
-    parslet.parse('barabc').should == ['bar', 'abc']                                # succeed on alternate path
-    lambda { parslet.parse('bar...') }.should raise_error(Walrat::ParseError)       # fail half-way down alternate path
-    lambda { parslet.parse('lemon') }.should raise_error(Walrat::ParseError)        # fail immediately
+    expect(parslet.parse('foo')).to eq('foo')                                            # succeed on first choice
+    expect(parslet.parse('barabc')).to eq(['bar', 'abc'])                                # succeed on alternate path
+    expect { parslet.parse('bar...') }.to raise_error(Walrat::ParseError)       # fail half-way down alternate path
+    expect { parslet.parse('lemon') }.to raise_error(Walrat::ParseError)        # fail immediately
 
     # swap the order, now equivalent to: ( /bar/ & /abc/ ) | /foo/
     parslet = Walrat::RegexpParslet.new(/bar/) &
               Walrat::RegexpParslet.new(/abc/) |
               Walrat::RegexpParslet.new(/foo/)
-    parslet.parse('barabc').should == ['bar', 'abc']                                # succeed on first choice
-    parslet.parse('foo').should == 'foo'                                            # succeed on alternate path
-    lambda { parslet.parse('bar...') }.should raise_error(Walrat::ParseError)       # fail half-way down first path
-    lambda { parslet.parse('lemon') }.should raise_error(Walrat::ParseError)        # fail immediately
+    expect(parslet.parse('barabc')).to eq(['bar', 'abc'])                                # succeed on first choice
+    expect(parslet.parse('foo')).to eq('foo')                                            # succeed on alternate path
+    expect { parslet.parse('bar...') }.to raise_error(Walrat::ParseError)       # fail half-way down first path
+    expect { parslet.parse('lemon') }.to raise_error(Walrat::ParseError)        # fail immediately
   end
 
   it 'should be able to override precedence using parentheses' do
@@ -272,24 +272,24 @@ describe 'combining chaining and alternation' do
     parslet = (Walrat::RegexpParslet.new(/foo/) |
                Walrat::RegexpParslet.new(/bar/)) &
                Walrat::RegexpParslet.new(/abc/)
-    parslet.parse('fooabc').should == ['foo', 'abc']                                # first choice
-    parslet.parse('barabc').should == ['bar', 'abc']                                # second choice
-    lambda { parslet.parse('foo...') }.should raise_error(Walrat::ParseError)        # fail in second half
-    lambda { parslet.parse('bar...') }.should raise_error(Walrat::ParseError)        # another way of failing in second half
-    lambda { parslet.parse('foo') }.should raise_error(Walrat::ParseError)           # another way of failing in second half
-    lambda { parslet.parse('bar') }.should raise_error(Walrat::ParseError)           # another way of failing in second half
-    lambda { parslet.parse('lemon') }.should raise_error(Walrat::ParseError)         # fail immediately
-    lambda { parslet.parse('abcfoo') }.should raise_error(Walrat::ParseError)        # order matters
+    expect(parslet.parse('fooabc')).to eq(['foo', 'abc'])                                # first choice
+    expect(parslet.parse('barabc')).to eq(['bar', 'abc'])                                # second choice
+    expect { parslet.parse('foo...') }.to raise_error(Walrat::ParseError)        # fail in second half
+    expect { parslet.parse('bar...') }.to raise_error(Walrat::ParseError)        # another way of failing in second half
+    expect { parslet.parse('foo') }.to raise_error(Walrat::ParseError)           # another way of failing in second half
+    expect { parslet.parse('bar') }.to raise_error(Walrat::ParseError)           # another way of failing in second half
+    expect { parslet.parse('lemon') }.to raise_error(Walrat::ParseError)         # fail immediately
+    expect { parslet.parse('abcfoo') }.to raise_error(Walrat::ParseError)        # order matters
 
     # take second example above and make it /bar/ & ( /abc/ | /foo/ )
     parslet = Walrat::RegexpParslet.new(/bar/) &
       (Walrat::RegexpParslet.new(/abc/) | Walrat::RegexpParslet.new(/foo/))
-    parslet.parse('barabc').should == ['bar', 'abc']                                # succeed on first choice
-    parslet.parse('barfoo').should == ['bar', 'foo']                                # second choice
-    lambda { parslet.parse('bar...') }.should raise_error(Walrat::ParseError)       # fail in second part
-    lambda { parslet.parse('bar') }.should raise_error(Walrat::ParseError)          # another way to fail in second part
-    lambda { parslet.parse('lemon') }.should raise_error(Walrat::ParseError)        # fail immediately
-    lambda { parslet.parse('abcbar') }.should raise_error(Walrat::ParseError)       # order matters
+    expect(parslet.parse('barabc')).to eq(['bar', 'abc'])                                # succeed on first choice
+    expect(parslet.parse('barfoo')).to eq(['bar', 'foo'])                                # second choice
+    expect { parslet.parse('bar...') }.to raise_error(Walrat::ParseError)       # fail in second part
+    expect { parslet.parse('bar') }.to raise_error(Walrat::ParseError)          # another way to fail in second part
+    expect { parslet.parse('lemon') }.to raise_error(Walrat::ParseError)        # fail immediately
+    expect { parslet.parse('abcbar') }.to raise_error(Walrat::ParseError)       # order matters
   end
 
   it 'should be able to include long runs of sequences' do
@@ -299,9 +299,9 @@ describe 'combining chaining and alternation' do
               Walrat::RegexpParslet.new(/c/) &
               Walrat::RegexpParslet.new(/d/) |
               Walrat::RegexpParslet.new(/e/)
-    parslet.parse('abcd').should == ['a', 'b', 'c', 'd']
-    parslet.parse('e').should == 'e'
-    lambda { parslet.parse('f') }.should raise_error(Walrat::ParseError)
+    expect(parslet.parse('abcd')).to eq(['a', 'b', 'c', 'd'])
+    expect(parslet.parse('e')).to eq('e')
+    expect { parslet.parse('f') }.to raise_error(Walrat::ParseError)
   end
 
   it 'should be able to include long runs of options' do
@@ -311,11 +311,11 @@ describe 'combining chaining and alternation' do
               Walrat::RegexpParslet.new(/c/) |
               Walrat::RegexpParslet.new(/d/) &
               Walrat::RegexpParslet.new(/e/)
-    parslet.parse('a').should == 'a'
-    parslet.parse('b').should == 'b'
-    parslet.parse('c').should == 'c'
-    parslet.parse('de').should == ['d', 'e']
-    lambda { parslet.parse('f') }.should raise_error(Walrat::ParseError)
+    expect(parslet.parse('a')).to eq('a')
+    expect(parslet.parse('b')).to eq('b')
+    expect(parslet.parse('c')).to eq('c')
+    expect(parslet.parse('de')).to eq(['d', 'e'])
+    expect { parslet.parse('f') }.to raise_error(Walrat::ParseError)
   end
 
   it 'should be able to alternate repeatedly between sequences and choices' do
@@ -325,10 +325,10 @@ describe 'combining chaining and alternation' do
               Walrat::RegexpParslet.new(/c/) &
               Walrat::RegexpParslet.new(/d/) |
               Walrat::RegexpParslet.new(/e/)
-    parslet.parse('ab').should == ['a', 'b']
-    parslet.parse('cd').should == ['c', 'd']
-    parslet.parse('e').should == 'e'
-    lambda { parslet.parse('f') }.should raise_error(Walrat::ParseError)
+    expect(parslet.parse('ab')).to eq(['a', 'b'])
+    expect(parslet.parse('cd')).to eq(['c', 'd'])
+    expect(parslet.parse('e')).to eq('e')
+    expect { parslet.parse('f') }.to raise_error(Walrat::ParseError)
   end
 
   it 'should be able to combine long runs with alternation' do
@@ -341,10 +341,10 @@ describe 'combining chaining and alternation' do
               Walrat::RegexpParslet.new(/f/) &
               Walrat::RegexpParslet.new(/g/) &
               Walrat::RegexpParslet.new(/h/)
-    parslet.parse('abc').should == ['a', 'b', 'c']
-    parslet.parse('d').should == 'd'
-    parslet.parse('e').should == 'e'
-    parslet.parse('fgh').should == ['f', 'g', 'h']
-    lambda { parslet.parse('i') }.should raise_error(Walrat::ParseError)
+    expect(parslet.parse('abc')).to eq(['a', 'b', 'c'])
+    expect(parslet.parse('d')).to eq('d')
+    expect(parslet.parse('e')).to eq('e')
+    expect(parslet.parse('fgh')).to eq(['f', 'g', 'h'])
+    expect { parslet.parse('i') }.to raise_error(Walrat::ParseError)
   end
 end
index 045fadfd600ff511357f59819f31ef8f749ebae1..865692268c3b5e2c5773f64968a7e34119b8f875 100755 (executable)
@@ -13,57 +13,57 @@ describe Walrat::StringEnumerator do
 
   it 'returns characters one by one until end of string, then return nil' do
     enumerator = Walrat::StringEnumerator.new('hello')
-    enumerator.next.should == 'h'
-    enumerator.next.should == 'e'
-    enumerator.next.should == 'l'
-    enumerator.next.should == 'l'
-    enumerator.next.should == 'o'
-    enumerator.next.should be_nil
+    expect(enumerator.next).to eq('h')
+    expect(enumerator.next).to eq('e')
+    expect(enumerator.next).to eq('l')
+    expect(enumerator.next).to eq('l')
+    expect(enumerator.next).to eq('o')
+    expect(enumerator.next).to be_nil
   end
 
   it 'is Unicode-aware (UTF-8)' do
     enumerator = Walrat::StringEnumerator.new('€ cañon')
-    enumerator.next.should == '€'
-    enumerator.next.should == ' '
-    enumerator.next.should == 'c'
-    enumerator.next.should == 'a'
-    enumerator.next.should == 'ñ'
-    enumerator.next.should == 'o'
-    enumerator.next.should == 'n'
-    enumerator.next.should be_nil
+    expect(enumerator.next).to eq('€')
+    expect(enumerator.next).to eq(' ')
+    expect(enumerator.next).to eq('c')
+    expect(enumerator.next).to eq('a')
+    expect(enumerator.next).to eq('ñ')
+    expect(enumerator.next).to eq('o')
+    expect(enumerator.next).to eq('n')
+    expect(enumerator.next).to be_nil
   end
 
   # this was a bug
   it 'continues past newlines' do
     enumerator = Walrat::StringEnumerator.new("hello\nworld")
-    enumerator.next.should == 'h'
-    enumerator.next.should == 'e'
-    enumerator.next.should == 'l'
-    enumerator.next.should == 'l'
-    enumerator.next.should == 'o'
-    enumerator.next.should == "\n" # was returning nil here
-    enumerator.next.should == 'w'
-    enumerator.next.should == 'o'
-    enumerator.next.should == 'r'
-    enumerator.next.should == 'l'
-    enumerator.next.should == 'd'
+    expect(enumerator.next).to eq('h')
+    expect(enumerator.next).to eq('e')
+    expect(enumerator.next).to eq('l')
+    expect(enumerator.next).to eq('l')
+    expect(enumerator.next).to eq('o')
+    expect(enumerator.next).to eq("\n") # was returning nil here
+    expect(enumerator.next).to eq('w')
+    expect(enumerator.next).to eq('o')
+    expect(enumerator.next).to eq('r')
+    expect(enumerator.next).to eq('l')
+    expect(enumerator.next).to eq('d')
   end
 
   it 'can recall the last character using the "last" method' do
     enumerator = Walrat::StringEnumerator.new('h€llo')
-    enumerator.last.should == nil # nothing scanned yet
-    enumerator.next.should == 'h' # advance
-    enumerator.last.should == nil # still no previous character
-    enumerator.next.should == '€' # advance
-    enumerator.last.should == 'h'
-    enumerator.next.should == 'l' # advance
-    enumerator.last.should == '€'
-    enumerator.next.should == 'l' # advance
-    enumerator.last.should == 'l'
-    enumerator.next.should == 'o' # advance
-    enumerator.last.should == 'l'
-    enumerator.next.should == nil # nothing left to scan
-    enumerator.last.should == 'o'
-    enumerator.last.should == 'o' # didn't advance, so should return the same
+    expect(enumerator.last).to eq(nil) # nothing scanned yet
+    expect(enumerator.next).to eq('h') # advance
+    expect(enumerator.last).to eq(nil) # still no previous character
+    expect(enumerator.next).to eq('€') # advance
+    expect(enumerator.last).to eq('h')
+    expect(enumerator.next).to eq('l') # advance
+    expect(enumerator.last).to eq('€')
+    expect(enumerator.next).to eq('l') # advance
+    expect(enumerator.last).to eq('l')
+    expect(enumerator.next).to eq('o') # advance
+    expect(enumerator.last).to eq('l')
+    expect(enumerator.next).to eq(nil) # nothing left to scan
+    expect(enumerator.last).to eq('o')
+    expect(enumerator.last).to eq('o') # didn't advance, so should return the same
   end
 end
index 83f3311b6e1b6ea03ddd2b1326d9a19f234676b7..af7d49e78b550b7ae368a429509bafa3966e4a1d 100755 (executable)
@@ -9,89 +9,89 @@ describe Walrat::StringParslet do
   end
 
   it 'should raise an ArgumentError if initialized with nil' do
-    lambda { Walrat::StringParslet.new(nil) }.should raise_error(ArgumentError)
+    expect { Walrat::StringParslet.new(nil) }.to raise_error(ArgumentError)
   end
 
   it 'parse should succeed if the input string matches' do
-    lambda { @parslet.parse('HELLO') }.should_not raise_error
+    expect { @parslet.parse('HELLO') }.not_to raise_error
   end
 
   it 'parse should succeed if the input string matches, even if it continues after the match' do
-    lambda { @parslet.parse('HELLO...') }.should_not raise_error
+    expect { @parslet.parse('HELLO...') }.not_to raise_error
   end
 
   it 'parse should return parsed string' do
-    @parslet.parse('HELLO').should == 'HELLO'
-    @parslet.parse('HELLO...').should == 'HELLO'
+    expect(@parslet.parse('HELLO')).to eq('HELLO')
+    expect(@parslet.parse('HELLO...')).to eq('HELLO')
   end
 
   it 'parse should raise an ArgumentError if passed nil' do
-    lambda { @parslet.parse(nil) }.should raise_error(ArgumentError)
+    expect { @parslet.parse(nil) }.to raise_error(ArgumentError)
   end
 
   it 'parse should raise a ParseError if the input string does not match' do
-    lambda { @parslet.parse('GOODBYE') }.should raise_error(Walrat::ParseError)        # total mismatch
-    lambda { @parslet.parse('GOODBYE, HELLO') }.should raise_error(Walrat::ParseError) # eventually would match, but too late
-    lambda { @parslet.parse('HELL...') }.should raise_error(Walrat::ParseError)        # starts well, but fails
-    lambda { @parslet.parse(' HELLO') }.should raise_error(Walrat::ParseError)         # note the leading whitespace
-    lambda { @parslet.parse('') }.should raise_error(Walrat::ParseError)               # empty strings can't match
+    expect { @parslet.parse('GOODBYE') }.to raise_error(Walrat::ParseError)        # total mismatch
+    expect { @parslet.parse('GOODBYE, HELLO') }.to raise_error(Walrat::ParseError) # eventually would match, but too late
+    expect { @parslet.parse('HELL...') }.to raise_error(Walrat::ParseError)        # starts well, but fails
+    expect { @parslet.parse(' HELLO') }.to raise_error(Walrat::ParseError)         # note the leading whitespace
+    expect { @parslet.parse('') }.to raise_error(Walrat::ParseError)               # empty strings can't match
   end
 
   it 'parse exceptions should include a detailed error message' do
     # TODO: catch the raised exception and compare the message
-    lambda { @parslet.parse('HELL...') }.should raise_error(Walrat::ParseError)
-    lambda { @parslet.parse('HELL') }.should raise_error(Walrat::ParseError)
+    expect { @parslet.parse('HELL...') }.to raise_error(Walrat::ParseError)
+    expect { @parslet.parse('HELL') }.to raise_error(Walrat::ParseError)
   end
 
   it 'should be able to compare string parslets for equality' do
-    'foo'.to_parseable.should eql('foo'.to_parseable)           # equal
-    'foo'.to_parseable.should_not eql('bar'.to_parseable)       # different
-    'foo'.to_parseable.should_not eql('Foo'.to_parseable)       # differing only in case
-    'foo'.to_parseable.should_not eql(/foo/)                    # totally different classes
+    expect('foo'.to_parseable).to eql('foo'.to_parseable)           # equal
+    expect('foo'.to_parseable).not_to eql('bar'.to_parseable)       # different
+    expect('foo'.to_parseable).not_to eql('Foo'.to_parseable)       # differing only in case
+    expect('foo'.to_parseable).not_to eql(/foo/)                    # totally different classes
   end
 
   it 'should accurately pack line and column ends into whatever is returned by "parse"' do
     # single word
     parslet = 'hello'.to_parseable
     result = parslet.parse('hello')
-    result.line_end.should == 0
-    result.column_end.should == 5
+    expect(result.line_end).to eq(0)
+    expect(result.column_end).to eq(5)
 
     # single word with newline at end (UNIX style)
     parslet = "hello\n".to_parseable
     result = parslet.parse("hello\n")
-    result.line_end.should == 1
-    result.column_end.should == 0
+    expect(result.line_end).to eq(1)
+    expect(result.column_end).to eq(0)
 
     # single word with newline at end (Classic Mac style)
     parslet = "hello\r".to_parseable
     result = parslet.parse("hello\r")
-    result.line_end.should == 1
-    result.column_end.should == 0
+    expect(result.line_end).to eq(1)
+    expect(result.column_end).to eq(0)
 
     # single word with newline at end (Windows style)
     parslet = "hello\r\n".to_parseable
     result = parslet.parse("hello\r\n")
-    result.line_end.should == 1
-    result.column_end.should == 0
+    expect(result.line_end).to eq(1)
+    expect(result.column_end).to eq(0)
 
     # two lines (UNIX style)
     parslet = "hello\nworld".to_parseable
     result = parslet.parse("hello\nworld")
-    result.line_end.should == 1
-    result.column_end.should == 5
+    expect(result.line_end).to eq(1)
+    expect(result.column_end).to eq(5)
 
     # two lines (Classic Mac style)
     parslet = "hello\rworld".to_parseable
     result = parslet.parse("hello\rworld")
-    result.line_end.should == 1
-    result.column_end.should == 5
+    expect(result.line_end).to eq(1)
+    expect(result.column_end).to eq(5)
 
     # two lines (Windows style)
     parslet = "hello\r\nworld".to_parseable
     result = parslet.parse("hello\r\nworld")
-    result.line_end.should == 1
-    result.column_end.should == 5
+    expect(result.line_end).to eq(1)
+    expect(result.column_end).to eq(5)
   end
 
   it 'line and column end should reflect last succesfully scanned position prior to failure' do
@@ -102,8 +102,8 @@ describe Walrat::StringParslet do
     rescue Walrat::ParseError => e
       exception = e
     end
-    exception.line_end.should == 0
-    exception.column_end.should == 0
+    expect(exception.line_end).to eq(0)
+    expect(exception.column_end).to eq(0)
 
     # fail after 1 character
     begin
@@ -111,8 +111,8 @@ describe Walrat::StringParslet do
     rescue Walrat::ParseError => e
       exception = e
     end
-    exception.line_end.should == 0
-    exception.column_end.should == 1
+    expect(exception.line_end).to eq(0)
+    expect(exception.column_end).to eq(1)
 
     # fail after end-of-line
     begin
@@ -120,7 +120,7 @@ describe Walrat::StringParslet do
     rescue Walrat::ParseError => e
       exception = e
     end
-    exception.line_end.should == 1
-    exception.column_end.should == 0
+    expect(exception.line_end).to eq(1)
+    expect(exception.column_end).to eq(0)
   end
 end
index 0afc096eb442cf84b3cba643d49c025799037b3a..a9ecce9e5a43c7efbdc3778203b63bee74f34093 100755 (executable)
@@ -11,9 +11,9 @@ describe Walrat::SymbolParslet do
   end
 
   it 'should be able to compare symbol parslets for equality' do
-    :foo.to_parseable.should eql(:foo.to_parseable)           # equal
-    :foo.to_parseable.should_not eql(:bar.to_parseable)       # different
-    :foo.to_parseable.should_not eql(:Foo.to_parseable)       # differing only in case
-    :foo.to_parseable.should_not eql(/foo/)                   # totally different classes
+    expect(:foo.to_parseable).to eql(:foo.to_parseable)           # equal
+    expect(:foo.to_parseable).not_to eql(:bar.to_parseable)       # different
+    expect(:foo.to_parseable).not_to eql(:Foo.to_parseable)       # differing only in case
+    expect(:foo.to_parseable).not_to eql(/foo/)                   # totally different classes
   end
 end