]> git.wincent.com - walrat.git/blob - spec/string_parslet_spec.rb
Update to RSpec 3.1.0
[walrat.git] / spec / string_parslet_spec.rb
1 # Copyright 2007-2014 Greg Hurrell. All rights reserved.
2 # Licensed under the terms of the BSD 2-clause license.
3
4 require 'spec_helper'
5
6 describe Walrat::StringParslet do
7   before do
8     @parslet = Walrat::StringParslet.new('HELLO')
9   end
10
11   it 'should raise an ArgumentError if initialized with nil' do
12     lambda { Walrat::StringParslet.new(nil) }.should raise_error(ArgumentError)
13   end
14
15   it 'parse should succeed if the input string matches' do
16     lambda { @parslet.parse('HELLO') }.should_not raise_error
17   end
18
19   it 'parse should succeed if the input string matches, even if it continues after the match' do
20     lambda { @parslet.parse('HELLO...') }.should_not raise_error
21   end
22
23   it 'parse should return parsed string' do
24     @parslet.parse('HELLO').should == 'HELLO'
25     @parslet.parse('HELLO...').should == 'HELLO'
26   end
27
28   it 'parse should raise an ArgumentError if passed nil' do
29     lambda { @parslet.parse(nil) }.should raise_error(ArgumentError)
30   end
31
32   it 'parse should raise a ParseError if the input string does not match' do
33     lambda { @parslet.parse('GOODBYE') }.should raise_error(Walrat::ParseError)        # total mismatch
34     lambda { @parslet.parse('GOODBYE, HELLO') }.should raise_error(Walrat::ParseError) # eventually would match, but too late
35     lambda { @parslet.parse('HELL...') }.should raise_error(Walrat::ParseError)        # starts well, but fails
36     lambda { @parslet.parse(' HELLO') }.should raise_error(Walrat::ParseError)         # note the leading whitespace
37     lambda { @parslet.parse('') }.should raise_error(Walrat::ParseError)               # empty strings can't match
38   end
39
40   it 'parse exceptions should include a detailed error message' do
41     # TODO: catch the raised exception and compare the message
42     lambda { @parslet.parse('HELL...') }.should raise_error(Walrat::ParseError)
43     lambda { @parslet.parse('HELL') }.should raise_error(Walrat::ParseError)
44   end
45
46   it 'should be able to compare string parslets for equality' do
47     'foo'.to_parseable.should eql('foo'.to_parseable)           # equal
48     'foo'.to_parseable.should_not eql('bar'.to_parseable)       # different
49     'foo'.to_parseable.should_not eql('Foo'.to_parseable)       # differing only in case
50     'foo'.to_parseable.should_not eql(/foo/)                    # totally different classes
51   end
52
53   it 'should accurately pack line and column ends into whatever is returned by "parse"' do
54     # single word
55     parslet = 'hello'.to_parseable
56     result = parslet.parse('hello')
57     result.line_end.should == 0
58     result.column_end.should == 5
59
60     # single word with newline at end (UNIX style)
61     parslet = "hello\n".to_parseable
62     result = parslet.parse("hello\n")
63     result.line_end.should == 1
64     result.column_end.should == 0
65
66     # single word with newline at end (Classic Mac style)
67     parslet = "hello\r".to_parseable
68     result = parslet.parse("hello\r")
69     result.line_end.should == 1
70     result.column_end.should == 0
71
72     # single word with newline at end (Windows style)
73     parslet = "hello\r\n".to_parseable
74     result = parslet.parse("hello\r\n")
75     result.line_end.should == 1
76     result.column_end.should == 0
77
78     # two lines (UNIX style)
79     parslet = "hello\nworld".to_parseable
80     result = parslet.parse("hello\nworld")
81     result.line_end.should == 1
82     result.column_end.should == 5
83
84     # two lines (Classic Mac style)
85     parslet = "hello\rworld".to_parseable
86     result = parslet.parse("hello\rworld")
87     result.line_end.should == 1
88     result.column_end.should == 5
89
90     # two lines (Windows style)
91     parslet = "hello\r\nworld".to_parseable
92     result = parslet.parse("hello\r\nworld")
93     result.line_end.should == 1
94     result.column_end.should == 5
95   end
96
97   it 'line and column end should reflect last succesfully scanned position prior to failure' do
98     # fail right at start
99     parslet = "hello\r\nworld".to_parseable
100     begin
101       parslet.parse('foobar')
102     rescue Walrat::ParseError => e
103       exception = e
104     end
105     exception.line_end.should == 0
106     exception.column_end.should == 0
107
108     # fail after 1 character
109     begin
110       parslet.parse('hfoobar')
111     rescue Walrat::ParseError => e
112       exception = e
113     end
114     exception.line_end.should == 0
115     exception.column_end.should == 1
116
117     # fail after end-of-line
118     begin
119       parslet.parse("hello\r\nfoobar")
120     rescue Walrat::ParseError => e
121       exception = e
122     end
123     exception.line_end.should == 1
124     exception.column_end.should == 0
125   end
126 end