rpg_lib 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d34b6d848dfd8d8f76606d2ff2da3e4db758349f
-  data.tar.gz: 92897b0065a31f7c747b0806a9be0ec7a0d8b99d
+  metadata.gz: 136dbff71bbb97184c6835b956e5cc79a3578142
+  data.tar.gz: 356ce85a68d6f9a03d87335452dd6293bd8453d3
 SHA512:
-  metadata.gz: 5cc706792314e57fc3a7612194b215a4f8e9b6c02aef932c8150e26b0d836589830c28d2292ab9335877058df7da9ad7a49fd8d68576d805fa45577e6e058d14
-  data.tar.gz: 035d42799027fdadcafdb903d7c4ab8a7355cb05bb0d0ec49e54ca62e3271bd68bbc319aad6598f080c8a4331ec653484fd093cf9350e12dddd14445b698537b
+  metadata.gz: 7ed15287c7b7c90cdd89cf6f50e98591be19ac72ab74fc4cec1d999e775e6258daa2b59178da775c7ace7b89a5c30382ab823900d9fe27c65925c26ee7184df1
+  data.tar.gz: '08bd9248297bd14ed7226d391df5cc46a8712ac3d2ad6806c615f3a43f2e8c82b0d1977c30363a960d5a227c0f8e3c87cc066451f6165eab930ffe229703b155'

data/.gitignore

@@ -1 +1,3 @@
 /coverage
+/pkg
+*.swp

data/.rubocop.yml

@@ -1,3 +1,7 @@
+AllCops:
+    Exclude:
+        - 'lib/rpg_lib/parser/dice_expression_parser.rb'
+
 Metrics/LineLength:
     Enabled: false
 Metrics/ModuleLength:

data/Gemfile

@@ -1,3 +1,20 @@
+# Copyright 2017 Jamie Hale
+#
+# This file is part of the RpgLib gem.
+#
+# RpgLib is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# RpgLib is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with RpgLib.  If not, see <http://www.gnu.org/licenses/>.
+
 source 'https://rubygems.org'
 
 gemspec

data/Gemfile.lock

@@ -2,6 +2,7 @@ PATH
   remote: .
   specs:
     rpg_lib (1.0.0)
+      treetop (~> 1.6)
 
 GEM
   remote: https://rubygems.org/
@@ -12,6 +13,7 @@ GEM
     json (2.0.3)
     parser (2.4.0.0)
       ast (~> 2.2)
+    polyglot (0.3.5)
     powerpack (0.1.1)
     rainbow (2.2.1)
     rake (12.0.0)
@@ -40,6 +42,8 @@ GEM
       json (>= 1.8, < 3)
       simplecov-html (~> 0.10.0)
     simplecov-html (0.10.0)
+    treetop (1.6.8)
+      polyglot (~> 0.3)
     unicode-display_width (1.1.3)
 
 PLATFORMS

data/Rakefile

@@ -26,3 +26,7 @@ task default: :spec
 task :rubocop do
   sh 'bundle exec rubocop'
 end
+
+task :treetop do
+  sh 'tt --force --output lib/rpg_lib/parser/dice_expression_parser.rb grammar/dice_expression.treetop'
+end

data/grammar/dice_expression.treetop

@@ -0,0 +1,95 @@
+module RpgLib
+  module Parser
+    # :nocov:
+    grammar DiceExpression
+      rule additive
+        head:multitive
+        tail:(
+          space operator:additive_op
+          space operand:multitive)* <BinaryOperation>
+      end
+
+      rule additive_op
+        '+' {
+          def apply(a, b)
+            a + b
+          end
+        }
+        /
+        '-' {
+          def apply(a, b)
+            a - b
+          end
+        }
+      end
+
+      rule multitive
+        head:primary
+        tail:(
+          space operator:multitive_op
+          space operand:primary)* <BinaryOperation>
+      end
+
+      rule multitive_op
+        '*' {
+          def apply(a, b)
+            a * b
+          end
+        }
+        /
+        '/' {
+          def apply(a, b)
+            a / b
+          end
+        }
+      end
+
+      rule primary
+        dice
+        /
+        number
+        /
+        '(' space additive space ')' {
+          def eval(roller)
+            additive.eval(roller)
+          end
+        }
+      end
+
+      rule number
+        ('-'? [1-9] [0-9]* / '0' ) {
+          def eval(_roller)
+            text_value.to_i
+          end
+        }
+      end
+
+      rule positive_integer
+        ([1-9] [0-9]*) {
+          def eval(_roller)
+            text_value.to_i
+          end
+        }
+      end
+
+      rule dice
+        count:positive_integer? 'd' sides:positive_integer {
+          def eval(roller)
+            die_count = count.empty? ? 1 : count.eval(nil)
+            die_sides = sides.eval(nil)
+            rolls = []
+            die_count.times do
+              rolls << roller.roll(die_sides)
+            end
+            rolls.inject(&:+)
+          end
+        }
+      end
+
+      rule space
+        ' '*
+      end
+    end
+    # :nocov:
+  end
+end

data/lib/rpg_lib.rb

@@ -17,6 +17,12 @@
 
 require 'rpg_lib/version'
 require 'rpg_lib/roll_set'
-require 'rpg_lib/roll_descriptor'
+require 'rpg_lib/die_roller'
 require 'rpg_lib/dice_roller'
 require 'rpg_lib/string'
+require 'rpg_lib/api'
+
+require 'treetop'
+require 'rpg_lib/parser/dice_expression_nodes.rb'
+require 'rpg_lib/parser/dice_expression_parser.rb'
+require 'rpg_lib/parser/dice_parser.rb'

data/lib/rpg_lib/api.rb

@@ -1,11 +1,35 @@
+# Copyright 2017 Jamie Hale
+#
+# This file is part of the RpgLib gem.
+#
+# RpgLib is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# RpgLib is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with RpgLib.  If not, see <http://www.gnu.org/licenses/>.
+
 module RpgLib
+  ##
+  # Api
+  #
   module Api
     def roll(dice)
       DiceRoller.instance.roll(dice)
     end
 
     def roll_and_ignore(dice, *args)
-      DiceRoller.instance.roll_and_ignore(dice, *args)
+      DiceRoller.instance.roll_and_ignore(dice, RollSet.new(*args))
+    end
+
+    def choose(options)
+      options[DiceRoller.instance.roll_die(options.size) - 1]
     end
   end
 end

data/lib/rpg_lib/dice_roller.rb

@@ -24,59 +24,27 @@ module RpgLib
   class DiceRoller
     include Singleton
 
-    DICE_REGEXP = /(\d*)d(\d+)((dl)(\d*)|(dh)(\d*))?/
+    attr_reader :parser
+    attr_accessor :roller
 
-    def random_value_in_range(range)
-      rand(range)
+    def initialize
+      @roller = DieRoller.new
+      @parser = Parser::DiceParser.new
     end
 
-    def roll_dice(roll_descriptor)
-      rolled_values = roll_all_dice_from_descriptor(roll_descriptor)
-      drop_lowest(rolled_values, roll_descriptor)
-      drop_highest(rolled_values, roll_descriptor)
-      total(rolled_values)
+    def roll_die(n)
+      @roller.roll(n)
     end
 
     def roll(dice)
-      local_dice = dice.dup
-      loop do
-        m = local_dice.downcase.match(DICE_REGEXP)
-        break if m.nil?
-        rolled_value = roll_dice(RollDescriptor.new(m))
-        local_dice[m.begin(0)...m.end(0)] = rolled_value.to_s
-      end
-      eval(local_dice)
+      @parser.parse(dice).eval(@roller)
     end
 
     def roll_and_ignore(dice, ignored_values)
-      rolled_value = nil
       loop do
         rolled_value = roll(dice)
-        break unless ignored_values.include?(rolled_value)
-      end
-      rolled_value
-    end
-
-    private
-
-    def roll_all_dice_from_descriptor(roll_descriptor)
-      rolled_values = []
-      1.upto roll_descriptor.count do
-        rolled_values << random_value_in_range(1..roll_descriptor.die)
+        return rolled_value unless ignored_values.include?(rolled_value)
       end
-      rolled_values.sort
-    end
-
-    def drop_lowest(rolled_values, roll_descriptor)
-      rolled_values.slice!(0, roll_descriptor.drop_lowest)
-    end
-
-    def drop_highest(rolled_values, roll_descriptor)
-      rolled_values.slice!(rolled_values.size - roll_descriptor.drop_highest, roll_descriptor.drop_highest)
-    end
-
-    def total(rolled_values)
-      rolled_values.inject(:+)
     end
   end
 end

data/lib/rpg_lib/die_roller.rb

@@ -0,0 +1,14 @@
+module RpgLib
+  ##
+  # DieRoller
+  #
+  class DieRoller
+    def initialize(generator = nil)
+      @generator = generator || Random.new
+    end
+
+    def roll(sides)
+      @generator.rand(1..sides)
+    end
+  end
+end

data/lib/rpg_lib/parser/dice_expression_nodes.rb

@@ -0,0 +1,16 @@
+module RpgLib
+  module Parser
+    module DiceExpression
+      ##
+      # BinaryOperation
+      #
+      class BinaryOperation < Treetop::Runtime::SyntaxNode
+        def eval(roller)
+          tail.elements.inject(head.eval(roller)) do |value, element|
+            element.operator.apply(value, element.operand.eval(roller))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rpg_lib/parser/dice_expression_parser.rb

@@ -0,0 +1,677 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+module RpgLib
+  module Parser
+    # :nocov:
+    module DiceExpression
+      include Treetop::Runtime
+
+      def root
+        @root ||= :additive
+      end
+
+      module Additive0
+        def space1
+          elements[0]
+        end
+
+        def operator
+          elements[1]
+        end
+
+        def space2
+          elements[2]
+        end
+
+        def operand
+          elements[3]
+        end
+      end
+
+      module Additive1
+        def head
+          elements[0]
+        end
+
+        def tail
+          elements[1]
+        end
+      end
+
+      def _nt_additive
+        start_index = index
+        if node_cache[:additive].has_key?(index)
+          cached = node_cache[:additive][index]
+          if cached
+            node_cache[:additive][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_multitive
+        s0 << r1
+        if r1
+          s2, i2 = [], index
+          loop do
+            i3, s3 = index, []
+            r4 = _nt_space
+            s3 << r4
+            if r4
+              r5 = _nt_additive_op
+              s3 << r5
+              if r5
+                r6 = _nt_space
+                s3 << r6
+                if r6
+                  r7 = _nt_multitive
+                  s3 << r7
+                end
+              end
+            end
+            if s3.last
+              r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+              r3.extend(Additive0)
+            else
+              @index = i3
+              r3 = nil
+            end
+            if r3
+              s2 << r3
+            else
+              break
+            end
+          end
+          r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+          s0 << r2
+        end
+        if s0.last
+          r0 = instantiate_node(BinaryOperation,input, i0...index, s0)
+          r0.extend(Additive1)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:additive][start_index] = r0
+
+        r0
+      end
+
+      module AdditiveOp0
+        def apply(a, b)
+          a + b
+        end
+      end
+
+      module AdditiveOp1
+        def apply(a, b)
+          a - b
+        end
+      end
+
+      def _nt_additive_op
+        start_index = index
+        if node_cache[:additive_op].has_key?(index)
+          cached = node_cache[:additive_op][index]
+          if cached
+            node_cache[:additive_op][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0 = index
+        if (match_len = has_terminal?('+', false, index))
+          r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          r1.extend(AdditiveOp0)
+          @index += match_len
+        else
+          terminal_parse_failure('\'+\'')
+          r1 = nil
+        end
+        if r1
+          r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+          r0 = r1
+        else
+          if (match_len = has_terminal?('-', false, index))
+            r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+            r2.extend(AdditiveOp1)
+            @index += match_len
+          else
+            terminal_parse_failure('\'-\'')
+            r2 = nil
+          end
+          if r2
+            r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+            r0 = r2
+          else
+            @index = i0
+            r0 = nil
+          end
+        end
+
+        node_cache[:additive_op][start_index] = r0
+
+        r0
+      end
+
+      module Multitive0
+        def space1
+          elements[0]
+        end
+
+        def operator
+          elements[1]
+        end
+
+        def space2
+          elements[2]
+        end
+
+        def operand
+          elements[3]
+        end
+      end
+
+      module Multitive1
+        def head
+          elements[0]
+        end
+
+        def tail
+          elements[1]
+        end
+      end
+
+      def _nt_multitive
+        start_index = index
+        if node_cache[:multitive].has_key?(index)
+          cached = node_cache[:multitive][index]
+          if cached
+            node_cache[:multitive][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r1 = _nt_primary
+        s0 << r1
+        if r1
+          s2, i2 = [], index
+          loop do
+            i3, s3 = index, []
+            r4 = _nt_space
+            s3 << r4
+            if r4
+              r5 = _nt_multitive_op
+              s3 << r5
+              if r5
+                r6 = _nt_space
+                s3 << r6
+                if r6
+                  r7 = _nt_primary
+                  s3 << r7
+                end
+              end
+            end
+            if s3.last
+              r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+              r3.extend(Multitive0)
+            else
+              @index = i3
+              r3 = nil
+            end
+            if r3
+              s2 << r3
+            else
+              break
+            end
+          end
+          r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+          s0 << r2
+        end
+        if s0.last
+          r0 = instantiate_node(BinaryOperation,input, i0...index, s0)
+          r0.extend(Multitive1)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:multitive][start_index] = r0
+
+        r0
+      end
+
+      module MultitiveOp0
+        def apply(a, b)
+          a * b
+        end
+      end
+
+      module MultitiveOp1
+        def apply(a, b)
+          a / b
+        end
+      end
+
+      def _nt_multitive_op
+        start_index = index
+        if node_cache[:multitive_op].has_key?(index)
+          cached = node_cache[:multitive_op][index]
+          if cached
+            node_cache[:multitive_op][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0 = index
+        if (match_len = has_terminal?('*', false, index))
+          r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+          r1.extend(MultitiveOp0)
+          @index += match_len
+        else
+          terminal_parse_failure('\'*\'')
+          r1 = nil
+        end
+        if r1
+          r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+          r0 = r1
+        else
+          if (match_len = has_terminal?('/', false, index))
+            r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
+            r2.extend(MultitiveOp1)
+            @index += match_len
+          else
+            terminal_parse_failure('\'/\'')
+            r2 = nil
+          end
+          if r2
+            r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+            r0 = r2
+          else
+            @index = i0
+            r0 = nil
+          end
+        end
+
+        node_cache[:multitive_op][start_index] = r0
+
+        r0
+      end
+
+      module Primary0
+        def space1
+          elements[1]
+        end
+
+        def additive
+          elements[2]
+        end
+
+        def space2
+          elements[3]
+        end
+
+      end
+
+      module Primary1
+        def eval(roller)
+          additive.eval(roller)
+        end
+      end
+
+      def _nt_primary
+        start_index = index
+        if node_cache[:primary].has_key?(index)
+          cached = node_cache[:primary][index]
+          if cached
+            node_cache[:primary][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0 = index
+        r1 = _nt_dice
+        if r1
+          r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+          r0 = r1
+        else
+          r2 = _nt_number
+          if r2
+            r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
+            r0 = r2
+          else
+            i3, s3 = index, []
+            if (match_len = has_terminal?('(', false, index))
+              r4 = true
+              @index += match_len
+            else
+              terminal_parse_failure('\'(\'')
+              r4 = nil
+            end
+            s3 << r4
+            if r4
+              r5 = _nt_space
+              s3 << r5
+              if r5
+                r6 = _nt_additive
+                s3 << r6
+                if r6
+                  r7 = _nt_space
+                  s3 << r7
+                  if r7
+                    if (match_len = has_terminal?(')', false, index))
+                      r8 = true
+                      @index += match_len
+                    else
+                      terminal_parse_failure('\')\'')
+                      r8 = nil
+                    end
+                    s3 << r8
+                  end
+                end
+              end
+            end
+            if s3.last
+              r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+              r3.extend(Primary0)
+              r3.extend(Primary1)
+            else
+              @index = i3
+              r3 = nil
+            end
+            if r3
+              r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
+              r0 = r3
+            else
+              @index = i0
+              r0 = nil
+            end
+          end
+        end
+
+        node_cache[:primary][start_index] = r0
+
+        r0
+      end
+
+      module Number0
+      end
+
+      module Number1
+        def eval(_roller)
+          text_value.to_i
+        end
+      end
+
+      def _nt_number
+        start_index = index
+        if node_cache[:number].has_key?(index)
+          cached = node_cache[:number][index]
+          if cached
+            node_cache[:number][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0 = index
+        i1, s1 = index, []
+        if (match_len = has_terminal?('-', false, index))
+          r3 = true
+          @index += match_len
+        else
+          terminal_parse_failure('\'-\'')
+          r3 = nil
+        end
+        if r3
+          r2 = r3
+        else
+          r2 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s1 << r2
+        if r2
+          if has_terminal?(@regexps[gr = '\A[1-9]'] ||= Regexp.new(gr), :regexp, index)
+            r4 = true
+            @index += 1
+          else
+            terminal_parse_failure('[1-9]')
+            r4 = nil
+          end
+          s1 << r4
+          if r4
+            s5, i5 = [], index
+            loop do
+              if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
+                r6 = true
+                @index += 1
+              else
+                terminal_parse_failure('[0-9]')
+                r6 = nil
+              end
+              if r6
+                s5 << r6
+              else
+                break
+              end
+            end
+            r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+            s1 << r5
+          end
+        end
+        if s1.last
+          r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+          r1.extend(Number0)
+        else
+          @index = i1
+          r1 = nil
+        end
+        if r1
+          r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
+          r0 = r1
+          r0.extend(Number1)
+          r0.extend(Number1)
+        else
+          if (match_len = has_terminal?('0', false, index))
+            r7 = true
+            @index += match_len
+          else
+            terminal_parse_failure('\'0\'')
+            r7 = nil
+          end
+          if r7
+            r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
+            r0 = r7
+            r0.extend(Number1)
+            r0.extend(Number1)
+          else
+            @index = i0
+            r0 = nil
+          end
+        end
+
+        node_cache[:number][start_index] = r0
+
+        r0
+      end
+
+      module PositiveInteger0
+      end
+
+      module PositiveInteger1
+        def eval(_roller)
+          text_value.to_i
+        end
+      end
+
+      def _nt_positive_integer
+        start_index = index
+        if node_cache[:positive_integer].has_key?(index)
+          cached = node_cache[:positive_integer][index]
+          if cached
+            node_cache[:positive_integer][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        if has_terminal?(@regexps[gr = '\A[1-9]'] ||= Regexp.new(gr), :regexp, index)
+          r1 = true
+          @index += 1
+        else
+          terminal_parse_failure('[1-9]')
+          r1 = nil
+        end
+        s0 << r1
+        if r1
+          s2, i2 = [], index
+          loop do
+            if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
+              r3 = true
+              @index += 1
+            else
+              terminal_parse_failure('[0-9]')
+              r3 = nil
+            end
+            if r3
+              s2 << r3
+            else
+              break
+            end
+          end
+          r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+          s0 << r2
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(PositiveInteger0)
+          r0.extend(PositiveInteger1)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:positive_integer][start_index] = r0
+
+        r0
+      end
+
+      module Dice0
+        def count
+          elements[0]
+        end
+
+        def sides
+          elements[2]
+        end
+      end
+
+      module Dice1
+        def eval(roller)
+          die_count = count.empty? ? 1 : count.eval(nil)
+          die_sides = sides.eval(nil)
+          rolls = []
+          die_count.times do
+            rolls << roller.roll(die_sides)
+          end
+          rolls.inject(&:+)
+        end
+      end
+
+      def _nt_dice
+        start_index = index
+        if node_cache[:dice].has_key?(index)
+          cached = node_cache[:dice][index]
+          if cached
+            node_cache[:dice][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        i0, s0 = index, []
+        r2 = _nt_positive_integer
+        if r2
+          r1 = r2
+        else
+          r1 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s0 << r1
+        if r1
+          if (match_len = has_terminal?('d', false, index))
+            r3 = true
+            @index += match_len
+          else
+            terminal_parse_failure('\'d\'')
+            r3 = nil
+          end
+          s0 << r3
+          if r3
+            r4 = _nt_positive_integer
+            s0 << r4
+          end
+        end
+        if s0.last
+          r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+          r0.extend(Dice0)
+          r0.extend(Dice1)
+        else
+          @index = i0
+          r0 = nil
+        end
+
+        node_cache[:dice][start_index] = r0
+
+        r0
+      end
+
+      def _nt_space
+        start_index = index
+        if node_cache[:space].has_key?(index)
+          cached = node_cache[:space][index]
+          if cached
+            node_cache[:space][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+            @index = cached.interval.end
+          end
+          return cached
+        end
+
+        s0, i0 = [], index
+        loop do
+          if (match_len = has_terminal?(' ', false, index))
+            r1 = true
+            @index += match_len
+          else
+            terminal_parse_failure('\' \'')
+            r1 = nil
+          end
+          if r1
+            s0 << r1
+          else
+            break
+          end
+        end
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+
+        node_cache[:space][start_index] = r0
+
+        r0
+      end
+
+    end
+
+    class DiceExpressionParser < Treetop::Runtime::CompiledParser
+      include DiceExpression
+    end
+
+    # :nocov:
+  end
+end