whittle 0.0.1 → 0.0.2

data/README.md

@@ -2,32 +2,57 @@
 
 Whittle is a LALR(1) parser.  It's very small, easy to understand, and what's most important,
 it's 100% ruby.  You write parsers by specifying sequences of allowable rules (which refer to
-other rules, or even to themselves), and for each rule in your grammar, you provide a block that
+other rules, or even to themselves).  For each rule in your grammar, you provide a block that
 is invoked when the grammar is recognized.
 
-If you're not familiar with parsing, you should find Whittle to be a very friendly little
+If you're *not* familiar with parsing, you should find Whittle to be a very friendly little
 parser.
 
-It is related, somewhat, to yacc and bison, which belong to the class of parsers knows as
-LALR(1): Lookahead Left-Right (using 1 lookahead token).  This class of parsers is both easy to
-work with, and powerful.
+It is related, somewhat, to yacc and bison, which belong to the class of parsers known as
+LALR(1): Left-Right, using 1 Lookahead token.  This class of parsers is both easy to work with
+and particularly powerful (ruby itself is parsed using a LALR(1) parser).  Since the algorithm
+is based around a theory that *never* has to backtrack (that is, each token read takes the
+parse forward, with just a single lookup in a parse table), parse time is also fast.  Parse
+time is governed by the size of the input, not by the size of the grammar.
 
-Whittle provides meaningful error reporting and even lets you hook into the error handling logic
-if you need to write some sort of crazy madman forgiving parser.
+Whittle provides meaningful error reporting (line number, expected tokens, received token) and
+even lets you hook into the error handling logic if you need to write some sort of crazy
+madman-forgiving parser.
+
+If you've had issues with other parsers hitting "stack level too deep" errors, you should find
+that Whittle does not suffer from the same issues, since it uses a state-switching algorithm
+(a pushdown automaton to be precise), rather than simply having one parse function call another
+and so on.  Whittle also supports the following concepts:
+
+  - Left/right recursion
+  - Left/right associativity
+  - Operator precedences
+  - Skipping of silent tokens in the input (e.g. whitespace/comments)
+
+## Installation
+
+Via rubygems:
+
+    gem install whittle
+
+Or in your Gemfile, if you're using bundler:
+
+    gem 'whittle'
 
 ## The Basics
 
-Parsers using Whittle are *not* generated.  This may strike users of other LALR(1) parsers as
-odd, but c'mon, we're using Ruby, right?
+Parsers using Whittle do not generate ruby code from a grammar file.  This may strike users of
+other LALR(1) parsers as odd, but c'mon, we're using Ruby, right?
 
 I'll avoid discussing the algorithm until we get into the really advanced stuff, but you will
 need to understand a few fundamental ideas before we begin.
 
-  1. There are two types of rule that make up a complete parser: terminal, and nonterminal
+  1. There are two types of rule that make up a complete parser: *terminal*, and *nonterminal*
     - A terminal rule is quite simply a chunk of the input string, like '42', or 'function'
-    - A nonterminal rule is a rule that makes reference to other rules (terminal and nonterminal)
+    - A nonterminal rule is a rule that makes reference to other rules (both terminal and
+      nonterminal)
   2. The input to be parsed *always* conforms to just one rule at the topmost level.  This is
-     known as the "start rule".
+     known as the "start rule" and describes the structure of the program as a whole.
 
 The easiest way to understand how the parser works is just to learn by example, so let's see an
 example.
@@ -38,9 +63,7 @@ require 'whittle'
 class Mathematician < Whittle::Parser
   rule("+")
 
-  rule(:int) do |r|
-    r[/[0-9]+/].as { |num| Integer(num) }
-  end
+  rule(:int => /[0-9]+/).as { |num| Integer(num) }
 
   rule(:expr) do |r|
     r[:int, "+", :int].as { |a, _, b| a + b }
@@ -55,21 +78,32 @@ mathematician.parse("1+2")
 ```
 
 Let's break this down a bit.  As you can see, the whole thing is really just `rule` used in
-different ways.  We also have to set the rule that we can use to describe an entire program,
-which in this case is the `:expr` rule that can add two numbers together.
+different ways.  We also have to set the start rule that we can use to describe an entire
+program, which in this case is the `:expr` rule that can add two numbers together.
 
 There are two terminal rules (`"+"` and `:int`) and one nonterminal (`:expr`) in the above
 grammar.  Each rule can have a block attached to it.  The block is invoked with the result
-evaluating the blocks that are attached to each input (recursively).  A rule with no block
-attached as just a shorthand way of saying "return the input verbatim", so our "+" above receives
-the string "+" and returns the string "+".  Since this is such a common use-case, Whittle offers
-the shorthand.
-
-As the input string is parsed, it *must* match the start rule `:expr`.  Whittle reads the "1",
-which matches `:int` (which casts the String "1" to the Integer 1), next the parser looks for the
-expected "+", which it gets.  Now it looks for another `:int`, which it gets.  Upon having
-read the sequence `:int`, `"+"`, `:int`, Whittle invokes the block for `:expr` with the arguments
-1, "+", 2, returning the 3 we expect.
+evaluating the blocks attached to each of its inputs (in a depth-first manner).  The default
+action if no block is given, is to return whatever the leftmost input to the rule happens to
+be.
+
+We can optionally use the Hash notation to map a name with a pattern (or a fixed string) when
+we declare terminal rules too, as we have done with the `:int` rule above.  Note that the
+longer way around defining terminal rules is to do like we have done for `:expr` and define a
+block, but since this is such a common use-case, Whittle offers the shorthand.
+
+As the input string is parsed, it *must* match the start rule `:expr`.
+
+Let's step through the parse for the above input "1+2".  When the parser starts, it looks at
+the start rule `:expr` and decides what tokens would be valid if they were encountered. Since
+`:expr` starts with `:int`, the only thing that would be valid is anything matching
+`/[0-9]+/`. When the parser reads the "1", it recognizes it as an `:int`, puts at aside (puts
+it on the stack, in technical terms).  Now it advances through the rule for `:expr` and
+decides the only possible valid input would be a "+", and finally the last `:int`.  Upon
+having read the sequence `:int`, "+", `:int`, our block attached to that rule is invoked to
+return a result.  First the three inputs are passed through their respective blocks (so the
+"1" and the "2" are cast to integers, according to the rule for `:int`), then they are passed
+to the `:expr`, which adds the 1 and the 2 to make 3.  Magic!
 
 ## Nonterminal rules can have more than one valid sequence
 
@@ -88,9 +122,7 @@ class Mathematician < Whittle::Parser
   rule("*")
   rule("/")
 
-  rule(:int) do |r|
-    r[/[0-9]+/].as { |num| Integer(num) }
-  end
+  rule(:int => /[0-9]+/).as { |num| Integer(num) }
 
   rule(:expr) do |r|
     r[:int, "+", :int].as { |a, _, b| a + b }
@@ -117,7 +149,9 @@ mathematician.parse("4/2")
 # => 2
 ```
 
-Now you're probably seeing how matching just one rule for the entire input is not a problem.
+Now you're probably beginning to see how matching just one rule for the entire input is not a
+problem.  To think about a more real world example, you can describe most programming
+languages as a series of statements and constructs.
 
 ## Rules can refer to themselves
 
@@ -133,16 +167,14 @@ class Mathematician < Whittle::Parser
   rule("*")
   rule("/")
 
-  rule(:int) do |r|
-    r[/[0-9]+/].as { |num| Integer(num) }
-  end
+  rule(:int => /[0-9]+/).as { |num| Integer(num) }
 
   rule(:expr) do |r|
     r[:expr, "+", :expr].as { |a, _, b| a + b }
     r[:expr, "-", :expr].as { |a, _, b| a - b }
     r[:expr, "*", :expr].as { |a, _, b| a * b }
     r[:expr, "/", :expr].as { |a, _, b| a / b }
-    r[:int].as(:value)
+    r[:int]
   end
 
   start(:expr)
@@ -156,14 +188,15 @@ mathematician.parse("1+5-2")
 Adding a rule of just `:int` to the `:expr` rule means that any integer is also a valid `:expr`.
 It is now possible to say that any `:expr` can be added to, multiplied by, divided by or
 subtracted from another `:expr`.  It is this ability to self-reference that makes LALR(1)
-parsers so powerful and easy to use.  Note that because the result each rule is computed
-*before* being passed as arguments to the block, each `:expr` in the calculations above will
-always be a number, since each `:expr` returns a number.
+parsers so powerful and easy to use.  Note that because the result each input to any given rule
+is computed *before* being passed as arguments to the block, each `:expr` in the calculations
+above will always be a number, since each `:expr` returns a number.  The recursion in these rules
+is practically limitless.  You can write "1+2-3*4+775/3" and it's still an `:expr`.
 
 ## Specifying the associativity
 
-Our mathematician still isn't very clever however.  It makes some silly mistakes.  Let's see
-what happens when we do the following:
+If we poke around for more than a few seconds, we'll soon realize that our mathematician  makes
+some silly mistakes.  Let's see what happens when we do the following:
 
 ``` ruby
 mathematician.parse("6-3-1")
@@ -196,16 +229,14 @@ class Mathematician < Whittle::Parser
   rule("*") % :left
   rule("/") % :left
 
-  rule(:int) do |r|
-    r[/[0-9]+/].as { |num| Integer(num) }
-  end
+  rule(:int => /[0-9]+/).as { |num| Integer(num) }
 
   rule(:expr) do |r|
     r[:expr, "+", :expr].as { |a, _, b| a + b }
     r[:expr, "-", :expr].as { |a, _, b| a - b }
     r[:expr, "*", :expr].as { |a, _, b| a * b }
     r[:expr, "/", :expr].as { |a, _, b| a / b }
-    r[:int].as(:value)
+    r[:int]
   end
 
   start(:expr)
@@ -217,11 +248,12 @@ mathematician.parse("6-3-1")
 ```
 
 Attaching a percent sign followed by either `:left` or `:right` changes the associativity of a
-rule.  We now get the correct result.
+terminal rule.  We now get the correct result.
 
 ## Specifying the operator precedence
 
-Well, despite fixing the associativity, we find we still have a problem:
+Basic arithmetic is easy peasy, right?  Well, despite fixing the associativity, we find we still
+have a problem:
 
 ``` ruby
 mathematician.parse("1+2*3")
@@ -241,16 +273,14 @@ class Mathematician < Whittle::Parser
   rule("*") % :left ^ 2
   rule("/") % :left ^ 2
 
-  rule(:int) do |r|
-    r[/[0-9]+/].as { |num| Integer(num) }
-  end
+  rule(:int => /[0-9]+/).as { |num| Integer(num) }
 
   rule(:expr) do |r|
     r[:expr, "+", :expr].as { |a, _, b| a + b }
     r[:expr, "-", :expr].as { |a, _, b| a - b }
     r[:expr, "*", :expr].as { |a, _, b| a * b }
     r[:expr, "/", :expr].as { |a, _, b| a / b }
-    r[:int].as(:value)
+    r[:int]
   end
 
   start(:expr)
@@ -270,7 +300,7 @@ The same applies to "*" and "/", but these both usually have a higher precedence
 ## Disambiguating expressions with the use of parentheses
 
 Sometimes we really do want "1+2*3" to mean "(1+2)*3", so we should really support this in our
-mathematician.  Fortunately adjusting the syntax rules in Whittle is a painless exercise.
+mathematician class.  Fortunately adjusting the syntax rules in Whittle is a painless exercise.
 
 ``` ruby
 require 'whittle'
@@ -284,9 +314,7 @@ class Mathematician < Whittle::Parser
   rule("(")
   rule(")")
 
-  rule(:int) do |r|
-    r[/[0-9]+/].as { |num| Integer(num) }
-  end
+  rule(:int => /[0-9]+/).as { |num| Integer(num) }
 
   rule(:expr) do |r|
     r["(", :expr, ")"].as   { |_, exp, _| exp }
@@ -294,7 +322,7 @@ class Mathematician < Whittle::Parser
     r[:expr, "-", :expr].as { |a, _, b| a - b }
     r[:expr, "*", :expr].as { |a, _, b| a * b }
     r[:expr, "/", :expr].as { |a, _, b| a / b }
-    r[:int].as(:value)
+    r[:int]
   end
 
   start(:expr)
@@ -306,22 +334,22 @@ mathematician.parse("(1+2)*3")
 ```
 
 All we had to do was add the new terminal rules for "(" and ")" then specify that the value of
-an expression enclosed in parentheses is simply the value of the expression itself.
+an expression enclosed in parentheses is simply the value of the expression itself.  We could
+just as easily pick some other characters to surround the grouping (maybe "~1+2~*3"), but then
+people would think we were silly (arguably, we would be a bit silly if we gave the expression a
+curly moustache like that!).
 
 ## Skipping whitespace
 
 Most languages contain tokens that are ignored when interpreting the input, such as whitespace
 and comments.  Accounting for the possibility of these in all rules would be both wasteful and
-tiresome.  Instead, we skip them entirely, by declaring a terminal rule without any associated
-action, or if you want to be explicit, with `as(:nothing)`.
+tiresome.  Instead, we skip them entirely, by declaring a terminal rule with `#skip!`.
 
 ``` ruby
 require 'whittle'
 
 class Mathematician < Whittle::Parser
-  rule(:wsp) do |r|
-    r[/\s+/]
-  end
+  rule(:wsp => /\s+/).skip!
 
   rule("+") % :left ^ 1
   rule("-") % :left ^ 1
@@ -331,9 +359,7 @@ class Mathematician < Whittle::Parser
   rule("(")
   rule(")")
 
-  rule(:int) do |r|
-    r[/[0-9]+/].as { |num| Integer(num) }
-  end
+  rule(:int => /[0-9]+/).as { |num| Integer(num) }
 
   rule(:expr) do |r|
     r["(", :expr, ")"].as   { |_, exp, _| exp }
@@ -341,7 +367,7 @@ class Mathematician < Whittle::Parser
     r[:expr, "-", :expr].as { |a, _, b| a - b }
     r[:expr, "*", :expr].as { |a, _, b| a * b }
     r[:expr, "/", :expr].as { |a, _, b| a / b }
-    r[:int].as(:value)
+    r[:int]
   end
 
   start(:expr)
@@ -387,9 +413,7 @@ match nothing at all, which is what we hit in the middle of our nested parenthes
 This is most useful in constructs like the following:
 
 ``` ruby
-rule(:id) do |r|
-  r[/[a-z]+/].as(:value)
-end
+rule(:id => /[a-z]+/)
 
 rule(:list) do |r|
   r[].as                { [] }
@@ -412,13 +436,9 @@ information.
 
 ``` ruby
 class ListParser < Whittle::Parser
-  rule(:wsp) do |r|
-    r[/\s+/]
-  end
+  rule(:wsp => /\s+/).skip!
 
-  rule(:id) do |r|
-    r[/[a-z]+/].as(:value)
-  end
+  rule(:id => /[a-z]+/)
 
   rule(",")
   rule("-")
@@ -447,10 +467,17 @@ something else, or rewinding the parse stack to a point where the error would no
 need to write some specs on this and explore it fully myself before I document it.  99% of users
 would never need to do such a thing.
 
+## More examples
+
+There are some runnable examples included in the examples/ directory.  Playing around with these
+would probably be a useful exercise.
+
+If you have any examples you'd like to contribute, I will gladly add them to the repository.
+
 ## TODO
 
   - Provide a more powerful (state based) lexer algorithm, or at least document how users can
-override `#lex`.
+    override `#lex`.
   - Allow inspection of the parse table (it is not very human friendly right now).
   - Allow inspection of the AST (maybe).
   - Given in an input String, provide a human readble explanation of the parse.

data/examples/calculator.rb

@@ -0,0 +1,59 @@
+# Whittle: A little LALR(1) parser in pure ruby, without a generator.
+#
+# Copyright (c) Chris Corbyn, 2011
+
+# This example creates a simple infix calculator, supporting the four basic arithmetic
+# functions, add, subtract, multiply and divide, along with logic grouping and operator
+# precedence
+
+require "whittle"
+require "bigdecimal"
+
+class Calculator < Whittle::Parser
+  rule(:wsp => /\s+/).skip!
+
+  rule("+") % :left ^ 1
+  rule("-") % :left ^ 1
+  rule("*") % :left ^ 2
+  rule("/") % :left ^ 2
+
+  rule("(")
+  rule(")")
+
+  rule(:decimal => /([0-9]*\.)?[0-9]+/).as { |num| BigDecimal(num) }
+
+  rule(:expr) do |r|
+    r["(", :expr, ")"].as   { |_, e, _| e }
+    r[:expr, "+", :expr].as { |a, _, b| a + b }
+    r[:expr, "-", :expr].as { |a, _, b| a - b }
+    r[:expr, "*", :expr].as { |a, _, b| a * b }
+    r[:expr, "/", :expr].as { |a, _, b| a / b }
+    r["-", :expr].as        { |_, e| -e }
+    r[:decimal]
+  end
+
+  start(:expr)
+end
+
+calculator = Calculator.new
+
+p calculator.parse("5-2-1").to_f
+# => 2
+
+p calculator.parse("5-2*3").to_f
+# => -1
+
+p calculator.parse(".7").to_f
+# => 0.7
+
+p calculator.parse("3.3 - .7").to_f
+# => 2.6
+
+p calculator.parse("5-(2-1)").to_f
+# => 4
+
+p calculator.parse("5 - -2").to_f
+# => 7
+
+p calculator.parse("5 * 2 - -2").to_f
+# => 12

data/lib/whittle/parser.rb

@@ -58,69 +58,42 @@ module Whittle
 
       # Declares a new rule.
       #
-      # The are two ways to call this method.  The most fundamental way is to pass a Symbol
-      # in the +name+ parameter, along with a block, in which you will add one more possible
-      # rules.
+      # The are three ways to call this method:
       #
-      # @example Specifying multiple rules with a block
+      #  1. rule("+")
+      #  2. rule(:int => /[0-9]+/)
+      #  3. rule(:expr) do |r|
+      #       r[:int, "+", :int].as { |a, _, b| a + b }
+      #     end
       #
-      #   rule(:expr) do |r|
-      #     r[:expr, "+", :expr].as { |a, _, b| a + b }
-      #     r[:expr, "-", :expr].as { |a, _, b| a - b }
-      #     r[:expr, "/", :expr].as { |a, _, b| a / b }
-      #     r[:expr, "*", :expr].as { |a, _, b| a * b }
-      #     r[:integer].as { |i| Integer(i) }
-      #   end
+      # Variants (1) and (2) define basic terminal symbols (direct chunks of the input string),
+      # while variant (3) takes a block to define one or more nonterminal rules.
       #
-      # Each rule specified in this way defines one of many possibilities to describe the input.
-      # Rules may refer back to themselves, which means in the above, any integer is a valid
-      # expr:
-      #
-      #   42
-      #
-      # Therefore any sum of integers as also a valid expr:
-      #
-      #   42 + 24
-      #
-      # Therefore any multiplication of sums of integers is also a valid expr, and so on.
-      #
-      #   42 + 24 * 7 + 52
-      #
-      # A rule like the above is called a 'nonterminal', because upon recognizing any expr, it
-      # is possible for the rule to continue collecting input and becoming a larger expr.
-      #
-      # In subtle contrast, a rule like the following:
-      #
-      #   rule("+") do |r|
-      #     r["+"].as { |plus| plus }
-      #   end
-      #
-      # Is called a 'terminal' token, since upon recognizing a "+", the parser cannot
-      # add further input to the "+" itself... it is the tip of a branch in the parse tree; the
-      # branch terminates here, and subsequently the rule is terminal.
-      #
-      # There is a shorthand way to write the above rule:
-      #
-      #   rule("+")
-      #
-      # Not given a block, #rule treats the name parameter as a literal token.
-      #
-      # Note that nonterminal rules are composed of other nonterminal rules and/or terminal
-      # rules.  Terminal rules contain one, and only one Regexp pattern or fixed string.
-      #
-      # @param [Symbol, String] name
-      #   the name of the ruleset (note the one ruleset can contain multiple rules)
+      # @param [Symbol, String, Hash] name
+      #   the name of the rule, or a Hash mapping the name to a pattern
       #
       # @return [RuleSet, Rule]
       #   the newly created RuleSet if a block was given, otherwise a rule representing a
       #   terminal token for the input string +name+.
       def rule(name)
-        rules[name] = RuleSet.new(name)
-
         if block_given?
+          raise ArgumentError,
+            "Parser#rule does not accept both a Hash and a block" if name.kind_of?(Hash)
+
+          rules[name] = RuleSet.new(name)
           rules[name].tap { |r| yield r }
         else
-          rules[name][name].as(:value)
+          key, value = if name.kind_of?(Hash)
+            raise ArgumentError,
+              "Only one element allowed in Hash for Parser#rule" unless name.length == 1
+
+            name.first
+          else
+            [name, name]
+          end
+
+          rules[key] = RuleSet.new(key)
+          rules[key][value].as(:value)
         end
       end
 

data/lib/whittle/rule.rb

@@ -26,7 +26,7 @@ module Whittle
     #   a variable list of components that make up the Rule
     def initialize(name, *components)
       @components = components
-      @action     = NULL_ACTION
+      @action     = DUMP_ACTION
       @name       = name
       @terminal   = components.length == 1 && !components.first.kind_of?(Symbol)
       @assoc      = :right
@@ -142,6 +142,8 @@ module Whittle
     # Given a block, the Rule will be reduced by passing the result of reducing
     # all inputs as arguments to the block.
     #
+    # The default action is to return the leftmost input unchanged.
+    #
     # Given the Symbol :value, the matched input will be returned verbatim.
     # Given the Symbol :nothing, nil will be returned; you can use this to
     # skip whitesapce and comments, for example.
@@ -165,6 +167,14 @@ module Whittle
       end
     end
 
+    # Alias for as(:nothing).
+    #
+    # @return [Rule]
+    #   returns self
+    def skip!
+      as(:nothing)
+    end
+
     # Set the associativity of this Rule.
     #
     # Accepts values of :left, :right (default) or :nonassoc.

data/lib/whittle/version.rb

@@ -1,3 +1,7 @@
+# Whittle: A little LALR(1) parser in pure ruby, without a generator.
+#
+# Copyright (c) Chris Corbyn, 2011
+
 module Whittle
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/whittle.rb

@@ -1,3 +1,7 @@
+# Whittle: A little LALR(1) parser in pure ruby, without a generator.
+#
+# Copyright (c) Chris Corbyn, 2011
+
 require "whittle/version"
 require "whittle/error"
 require "whittle/errors/unconsumed_input_error"

data/spec/unit/parser/error_reporting_spec.rb

@@ -3,13 +3,9 @@ require "spec_helper"
 describe "a parser encountering unexpected input" do
   let(:parser) do
     Class.new(Whittle::Parser) do
-      rule(:wsp) do |r|
-        r[/\s+/]
-      end
+      rule(:wsp => /\s+/).skip!
 
-      rule(:id) do |r|
-        r[/[a-z]+/].as(:value)
-      end
+      rule(:id => /[a-z]+/)
 
       rule(",")
       rule("-")

data/spec/unit/parser/grouped_expr_spec.rb

@@ -6,12 +6,10 @@ describe "a parser with logical grouping" do
       rule(:expr) do |r|
         r["(", :expr, ")"].as   { |_, expr, _| expr }
         r[:expr, "-", :expr].as { |a, _, b| a - b }
-        r[:int].as(:value)
+        r[:int]
       end
 
-      rule(:int) do |r|
-        r[/[0-9]+/].as { |int| Integer(int) }
-      end
+      rule(:int => /[0-9]+/).as { |int| Integer(int) }
 
       rule("(")
       rule(")")

data/spec/unit/parser/multiple_precedence_spec.rb

@@ -9,12 +9,10 @@ describe "a parser with multiple precedence levels" do
         r[:expr, "-", :expr].as { |a, _, b| a - b }
         r[:expr, "*", :expr].as { |a, _, b| a * b }
         r[:expr, "/", :expr].as { |a, _, b| a / b }
-        r[:int].as(:value)
+        r[:int]
       end
 
-      rule(:int) do |r|
-        r[/[0-9]+/].as { |int| Integer(int) }
-      end
+      rule(:int => /[0-9]+/).as { |int| Integer(int) }
 
       rule("(")
       rule(")")

data/spec/unit/parser/noop_spec.rb

@@ -3,12 +3,10 @@ require "spec_helper"
 describe "a noop parser" do
   let(:parser) do
     Class.new(Whittle::Parser) do
-      rule(:char) do |r|
-        r[/./].as(:value)
-      end
+      rule(:char => /./)
 
       rule(:prog) do |r|
-        r[:char]
+        r[:char].skip!
       end
 
       start(:prog)

data/spec/unit/parser/pass_through_parser_spec.rb

@@ -3,9 +3,7 @@ require "spec_helper"
 describe "a pass-through parser" do
   let(:parser) do
     Class.new(Whittle::Parser) do
-      rule(:foo) do |r|
-        r["FOO"].as(:value)
-      end
+      rule(:foo => "FOO")
 
       start(:foo)
     end

data/spec/unit/parser/precedence_spec.rb

@@ -6,14 +6,12 @@ describe "a parser depending on operator precedences" do
       rule("+") % :left ^ 1
       rule("*") % :left ^ 2
 
-      rule(:int) do |r|
-        r[/[0-9]+/].as { |i| Integer(i) }
-      end
+      rule(:int => /[0-9]+/).as { |i| Integer(i) }
 
       rule(:expr) do |r|
         r[:expr, "+", :expr].as { |a, _, b| a + b }
         r[:expr, "*", :expr].as { |a, _, b| a * b }
-        r[:int].as(:value)
+        r[:int]
       end
 
       start(:expr)

data/spec/unit/parser/self_referential_expr_spec.rb

@@ -7,13 +7,11 @@ describe "a parser with a self-referential rule" do
       rule(")")
       rule("+")
 
-      rule(:int) do |r|
-        r[/[0-9]+/].as { |int| Integer(int) }
-      end
+      rule(:int => /[0-9]+/).as { |int| Integer(int) }
 
       rule(:expr) do |r|
         r[:expr, "+", :expr].as { |a, _, b| a + b }
-        r[:int].as(:value)
+        r[:int]
       end
 
       start(:expr)

data/spec/unit/parser/skipped_tokens_spec.rb

@@ -3,19 +3,15 @@ require "spec_helper"
 describe "a parser that skips tokens" do
   let(:parser) do
     Class.new(Whittle::Parser) do
-      rule(:wsp) do |r|
-        r[/\s+/]
-      end
+      rule(:wsp => /\s+/).skip!
 
       rule("-") % :left
 
-      rule(:int) do |r|
-        r[/[0-9]+/].as { |int| Integer(int) }
-      end
+      rule(:int => /[0-9]+/).as { |int| Integer(int) }
 
       rule(:expr) do |r|
         r[:expr, "-", :expr].as { |a, _, b| a - b }
-        r[:int].as(:value)
+        r[:int]
       end
 
       start(:expr)

data/spec/unit/parser/sum_parser_spec.rb

@@ -5,9 +5,7 @@ describe "a parser returning the sum of two integers" do
     Class.new(Whittle::Parser) do
       rule("+")
 
-      rule(:int) do |r|
-        r[/[0-9]+/].as { |int| Integer(int) }
-      end
+      rule(:int => /[0-9]+/).as { |int| Integer(int) }
 
       rule(:sum) do |r|
         r[:int, "+", :int].as { |a, _, b| a + b }

data/spec/unit/parser/typecast_parser_spec.rb

@@ -3,9 +3,7 @@ require "spec_helper"
 describe "a type-casting parser" do
   let(:parser) do
     Class.new(Whittle::Parser) do
-      rule(:int) do |r|
-        r[/[0-9]+/].as { |int| Integer(int) }
-      end
+      rule(:int => /[0-9]+/).as { |int| Integer(int) }
 
       start(:int)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: whittle
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-27 00:00:00.000000000 Z
+date: 2011-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70265816010420 !ruby/object:Gem::Requirement
+  requirement: &70351976364700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,7 @@ dependencies:
         version: '2.6'
   type: :development
   prerelease: false
-  version_requirements: *70265816010420
+  version_requirements: *70351976364700
 description: ! "Write powerful parsers by defining a series of very simple rules\n
   \                    and operations to perform as those rules are matched.  Whittle\n
   \                    parsers are written in pure ruby and as such are extremely
@@ -40,6 +40,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- examples/calculator.rb
 - lib/whittle.rb
 - lib/whittle/error.rb
 - lib/whittle/errors/grammar_error.rb