citrus 1.7.0 → 1.8.0

data/test/rule_test.rb

@@ -9,19 +9,15 @@ class RuleTest < Test::Unit::TestCase
   end
 
   NumericProc = Proc.new {
-    def to_i
-      text.to_i
-    end
-
-    def to_f
-      text.to_f
+    def add_one
+      to_i + 1
     end
   }
 
   NumericModule = Module.new(&NumericProc)
 
   def test_create
-    rule = Rule.create('"a"')
+    rule = Rule.eval('"a"')
     assert(rule)
     match = rule.match(input('a'))
     assert(match)
@@ -40,7 +36,7 @@ class RuleTest < Test::Unit::TestCase
     rule.extension = NumericProc
     match = rule.match(input('1'))
     assert(match)
-    assert_equal(1, match.to_i)
+    assert_equal(2, match.add_one)
     assert_instance_of(Float, match.to_f)
   end
 
@@ -49,7 +45,7 @@ class RuleTest < Test::Unit::TestCase
     rule.extension = NumericModule
     match = rule.match(input('1'))
     assert(match)
-    assert_equal(1, match.to_i)
+    assert_equal(2, match.add_one)
     assert_instance_of(Float, match.to_f)
   end
 

data/test/sequence_test.rb

@@ -18,7 +18,7 @@ class SequenceTest < Test::Unit::TestCase
 
     match = rule.match(input('ab'))
     assert(match)
-    assert_equal('ab', match.text)
+    assert_equal('ab', match)
     assert_equal(2, match.length)
   end
 
@@ -26,7 +26,7 @@ class SequenceTest < Test::Unit::TestCase
     rule = Sequence.new([/\d+/, '+', /\d+/])
     match = rule.match(input('1+2'))
     assert(match)
-    assert_equal('1+2', match.text)
+    assert_equal('1+2', match)
     assert_equal(3, match.length)
   end
 
@@ -34,7 +34,7 @@ class SequenceTest < Test::Unit::TestCase
     rule = Sequence.new([/[0-9]+/, Choice.new(%w<+ ->), /\d+/])
     match = rule.match(input('1+2'))
     assert(match)
-    assert_equal('1+2', match.text)
+    assert_equal('1+2', match)
     assert_equal(3, match.length)
   end
 

data/test/super_test.rb

@@ -20,12 +20,12 @@ class SuperTest < Test::Unit::TestCase
 
     match = grammar2.parse('b')
     assert(match)
-    assert_equal('b', match.text)
+    assert_equal('b', match)
     assert_equal(1, match.length)
 
     match = grammar2.parse('a')
     assert(match)
-    assert_equal('a', match.text)
+    assert_equal('a', match)
     assert_equal(1, match.length)
   end
 

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 1
-  - 7
+  - 8
   - 0
-  version: 1.7.0
+  version: 1.8.0
 platform: ruby
 authors: 
 - Michael Jackson
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-17 00:00:00 -05:00
+date: 2010-08-17 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -55,12 +55,12 @@ files:
 - benchmark/seqpar.citrus
 - benchmark/seqpar.gnuplot
 - benchmark/seqpar.rb
-- doc/background.rdoc
-- doc/example.rdoc
-- doc/index.rdoc
-- doc/license.rdoc
-- doc/links.rdoc
-- doc/syntax.rdoc
+- doc/background.markdown
+- doc/example.markdown
+- doc/index.markdown
+- doc/license.markdown
+- doc/links.markdown
+- doc/syntax.markdown
 - examples/calc.citrus
 - examples/calc.rb
 - examples/ip.citrus
@@ -79,6 +79,7 @@ files:
 - test/_files/super.citrus
 - test/alias_test.rb
 - test/and_predicate_test.rb
+- test/but_predicate_test.rb
 - test/calc_file_test.rb
 - test/calc_test.rb
 - test/choice_test.rb
@@ -138,6 +139,7 @@ summary: Parsing Expressions for Ruby
 test_files: 
 - test/alias_test.rb
 - test/and_predicate_test.rb
+- test/but_predicate_test.rb
 - test/calc_file_test.rb
 - test/calc_test.rb
 - test/choice_test.rb

data/doc/example.rdoc

@@ -1,115 +0,0 @@
-= Example
-
-Below is an example of a simple grammar that is able to parse strings of
-integers separated by any amount of white space and a <tt>+</tt> symbol.
-
-  grammar Addition
-    rule additive
-      number plus (additive | number)
-    end
-
-    rule number
-      [0-9]+ space
-    end
-
-    rule plus
-      '+' space
-    end
-
-    rule space
-      [ \t]*
-    end
-  end
-
-Several things to note about the above example:
-
-* Grammar and rule declarations end with the <tt>end</tt> keyword
-* A Sequence of rules is created by separating expressions with a space
-* Likewise, ordered choice is represented with a vertical bar
-* Parentheses may be used to override the natural binding order
-* Rules may refer to other rules in their own definitions simply by using the
-  other rule's name
-* Any expression may be followed by a quantifier
-
-== Interpretation
-
-The grammar above is able to parse simple mathematical expressions such as "1+2"
-and "1 + 2+3", but it does not have enough semantic information to be able to
-actually interpret these expressions.
-
-At this point, when the grammar parses a string it generates a tree of Match[link:api/classes/Citrus/Match.html]
-objects. Each match is created by a rule. A match will know what text it
-contains, its offset in the original input, and what submatches it contains.
-
-Submatches are created whenever a rule contains another rule. For example, in
-the grammar above the number rule matches a string of digits followed by white
-space. Thus, a match generated by the number rule will contain two submatches.
-
-We can use Ruby's block syntax to create a module that will be attached to these
-matches when they are created and is used to lazily extend them when we want to
-interpret them. The following example shows one way to do this.
-
-  grammar Addition
-    rule additive
-      (number plus term:(additive | number)) {
-        def value
-          number.value + term.value
-        end
-      }
-    end
-
-    rule number
-      ([0-9]+ space) {
-        def value
-          text.strip.to_i
-        end
-      }
-    end
-
-    rule plus
-      '+' space
-    end
-
-    rule space
-      [ \t]*
-    end
-  end
-
-In this version of the grammar we have added two semantic blocks, one each for
-the +additive+ and +number+ rules. These blocks contain methods that will be present
-on all match objects that result from matches of those particular rules. It's
-easiest to explain what is going on here by starting with the lowest level
-block, which is defined within the +number+ rule.
-
-The semantic block associated with the +number+ rule defines one method, +value+.
-Inside this method, we can see that the value of a number match is determined to
-be its text value, stripped of white space and converted to an integer.
-
-The +additive+ rule also extends its matches with a +value+ method. Notice the use
-of the "term" label within the rule definition. This label allows the match that
-is created by either the +additive+ or the +number+ rule to be retrieved using the
-"term" label. The value of an additive is determined to be the values of its
-number and term matches added together using Ruby's addition operator.
-
-Since additive is the first rule defined in the grammar, any match that results
-from parsing a string with this grammar will have a value method that can be
-used to recursively calculate the collective value of the entire match tree.
-
-To give it a try, save the code for the Addition grammar in a file called
-addition.citrus. Next, assuming you have the Citrus gem installed, try the
-following sequence of commands in a terminal.
-
-  $ irb
-  > require 'citrus'
-   => true
-  > Citrus.load 'addition'
-   => [Addition]
-  > m = Addition.parse '1 + 2 + 3'
-   => #<Citrus::Match ...
-  > m.value
-   => 6
-
-Congratulations! You just ran your first piece of Citrus code.
-
-Take a look at examples/calc.citrus[http://github.com/mjijackson/citrus/blob/master/examples/calc.citrus] for an example of a calculator that is able
-to parse and evaluate more complex mathematical expressions.

data/doc/index.rdoc

@@ -1,15 +0,0 @@
-Citrus is a compact and powerful parsing library for Ruby[http://ruby-lang.org/] that combines the
-elegance and expressiveness of the language with the simplicity and power of
-parsing expressions.
-
-= Installation
-
-Via RubyGems[http://rubygems.org/]:
-
-  $ sudo gem install citrus
-
-From a local copy:
-
-  $ git clone git://github.com/mjijackson/citrus.git
-  $ cd citrus
-  $ rake package && sudo rake install

data/doc/links.rdoc

@@ -1,18 +0,0 @@
-= Links
-
-The primary resource for all things to do with parsing expressions can be found
-at MIT.
-
-http://pdos.csail.mit.edu/~baford/packrat
-
-A useful summary of parsing expression grammars can be found on Wikipedia as
-well.
-
-http://en.wikipedia.org/wiki/Parsing_expression_grammar
-
-Citrus draws inspiration from another Ruby library for writing parsing
-expression grammars, Treetop. While Citrus' syntax is similar to that of
-Treetop, it's not identical. The link is included here for those who may wish to
-explore an alternative implementation.
-
-http://treetop.rubyforge.org

data/doc/syntax.rdoc

@@ -1,96 +0,0 @@
-= Syntax
-
-The most straightforward way to compose a Citrus grammar is to use Citrus' own
-custom grammar syntax. This syntax borrows heavily from Ruby, so it should
-already be familiar to Ruby programmers.
-
-== Terminals
-
-Terminals may be represented by a string or a regular expression. Both follow
-the same rules as Ruby string and regular expression literals.
-
-  'abc'
-  "abc\n"
-  /\xFF/
-
-Character classes and the dot (match anything) symbol are supported as well for
-compatibility with other parsing expression implementations.
-
-  [a-z0-9]      # match any lowercase letter or digit
-  [\x00-\xFF]   # match any octet
-  .             # match anything, even new lines
-
-See FixedWidth[link:api/classes/Citrus/FixedWidth.html] and
-Expression[link:api/classes/Citrus/Expression.html] for more information.
-
-== Repetition
-
-Quantifiers may be used after any expression to specify a number of times it
-must match. The universal form of a quantifier is N*M where N is the minimum and
-M is the maximum number of times the expression may match.
-
-  'abc'1*2      # match "abc" a minimum of one, maximum
-                # of two times
-  'abc'1*       # match "abc" at least once
-  'abc'*2       # match "abc" a maximum of twice
-
-The + and ? operators are supported as well for the common cases of 1* and *1
-respectively.
-
-  'abc'+        # match "abc" at least once
-  'abc'?        # match "abc" a maximum of once
-
-See Repeat[link:api/classes/Citrus/Repeat.html] for more information.
-
-== Lookahead
-
-Both positive and negative lookahead are supported in Citrus. Use the & and !
-operators to indicate that an expression either should or should not match. In
-neither case is any input consumed.
-
-  &'a' 'b'      # match a "b" preceded by an "a"
-  !'a' 'b'      # match a "b" that is not preceded by an "a"
-  !'a' .        # match any character except for "a"
-
-See AndPredicate[link:api/classes/Citrus/AndPredicate.html] and
-NotPredicate[link:api/classes/Citrus/NotPredicate.html] for more information.
-
-== Sequences
-
-Sequences of expressions may be separated by a space to indicate that the rules
-should match in that order.
-
-  'a' 'b' 'c'   # match "a", then "b", then "c"
-  'a' [0-9]     # match "a", then a numeric digit
-
-See Sequence[link:api/classes/Citrus/Sequence.html] for more information.
-
-== Choices
-
-Ordered choice is indicated by a vertical bar that separates two expressions.
-Note that any operator binds more tightly than the bar.
-
-  'a' | 'b'       # match "a" or "b"
-  'a' 'b' | 'c'   # match "a" then "b" (in sequence), or "c"
-
-See Choice[link:api/classes/Citrus/Choice.html] for more information.
-
-== Super
-
-When including a grammar inside another, all rules in the child that have the
-same name as a rule in the parent also have access to the super keyword to
-invoke the parent rule.
-
-See Super[link:api/classes/Citrus/Super.html] for more information.
-
-== Labels
-
-Match objects may be referred to by a different name than the rule that
-originally generated them. Labels are created by placing the label and a colon
-immediately preceding any expression.
-
-  chars:/[a-z]+/  # the characters matched by the regular
-                  # expression may be referred to as "chars"
-                  # in a block method
-
-See Label[link:api/classes/Citrus/Label.html] for more information.