personify 1.0.0 → 1.1.0

data/vendor/treetop/examples/lambda_calculus/arithmetic.rb

@@ -1,551 +0,0 @@
-module Arithmetic
-  include Treetop::Runtime
-  
-  def root
-    @root || :expression
-  end
-  
-  def _nt_expression
-    start_index = index
-    cached = node_cache[:expression][index]
-    if cached
-      @index = cached.interval.end
-      return cached
-    end
-    
-    i0 = index
-    r1 = _nt_comparative
-    if r1.success?
-      r0 = r1
-    else
-      r2 = _nt_additive
-      if r2.success?
-        r0 = r2
-      else
-        self.index = i0
-        r0 = ParseFailure.new(input, i0)
-      end
-    end
-    
-    node_cache[:expression][start_index] = r0
-    
-    return r0
-  end
-  
-  module Comparative0
-    def operand_1
-      elements[0]
-    end
-    
-    def space
-      elements[1]
-    end
-    
-    def operator
-      elements[2]
-    end
-    
-    def space
-      elements[3]
-    end
-    
-    def operand_2
-      elements[4]
-    end
-  end
-  
-  def _nt_comparative
-    start_index = index
-    cached = node_cache[:comparative][index]
-    if cached
-      @index = cached.interval.end
-      return cached
-    end
-    
-    i0, s0 = index, []
-    r1 = _nt_additive
-    s0 << r1
-    if r1.success?
-      r2 = _nt_space
-      s0 << r2
-      if r2.success?
-        r3 = _nt_equality_op
-        s0 << r3
-        if r3.success?
-          r4 = _nt_space
-          s0 << r4
-          if r4.success?
-            r5 = _nt_additive
-            s0 << r5
-          end
-        end
-      end
-    end
-    if s0.last.success?
-      r0 = (BinaryOperation).new(input, i0...index, s0)
-      r0.extend(Comparative0)
-    else
-      self.index = i0
-      r0 = ParseFailure.new(input, i0)
-    end
-    
-    node_cache[:comparative][start_index] = r0
-    
-    return r0
-  end
-  
-  module EqualityOp0
-    def apply(a, b)
-      a == b
-    end
-  end
-  
-  def _nt_equality_op
-    start_index = index
-    cached = node_cache[:equality_op][index]
-    if cached
-      @index = cached.interval.end
-      return cached
-    end
-    
-    r0 = parse_terminal('==', SyntaxNode, EqualityOp0)
-    
-    node_cache[:equality_op][start_index] = r0
-    
-    return r0
-  end
-  
-  module Additive0
-    def operand_1
-      elements[0]
-    end
-    
-    def space
-      elements[1]
-    end
-    
-    def operator
-      elements[2]
-    end
-    
-    def space
-      elements[3]
-    end
-    
-    def operand_2
-      elements[4]
-    end
-  end
-  
-  def _nt_additive
-    start_index = index
-    cached = node_cache[:additive][index]
-    if cached
-      @index = cached.interval.end
-      return cached
-    end
-    
-    i0 = index
-    i1, s1 = index, []
-    r2 = _nt_multitive
-    s1 << r2
-    if r2.success?
-      r3 = _nt_space
-      s1 << r3
-      if r3.success?
-        r4 = _nt_additive_op
-        s1 << r4
-        if r4.success?
-          r5 = _nt_space
-          s1 << r5
-          if r5.success?
-            r6 = _nt_additive
-            s1 << r6
-          end
-        end
-      end
-    end
-    if s1.last.success?
-      r1 = (BinaryOperation).new(input, i1...index, s1)
-      r1.extend(Additive0)
-    else
-      self.index = i1
-      r1 = ParseFailure.new(input, i1)
-    end
-    if r1.success?
-      r0 = r1
-    else
-      r7 = _nt_multitive
-      if r7.success?
-        r0 = r7
-      else
-        self.index = i0
-        r0 = ParseFailure.new(input, i0)
-      end
-    end
-    
-    node_cache[:additive][start_index] = r0
-    
-    return 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
-    cached = node_cache[:additive_op][index]
-    if cached
-      @index = cached.interval.end
-      return cached
-    end
-    
-    i0 = index
-    r1 = parse_terminal('+', SyntaxNode, AdditiveOp0)
-    if r1.success?
-      r0 = r1
-    else
-      r2 = parse_terminal('-', SyntaxNode, AdditiveOp1)
-      if r2.success?
-        r0 = r2
-      else
-        self.index = i0
-        r0 = ParseFailure.new(input, i0)
-      end
-    end
-    
-    node_cache[:additive_op][start_index] = r0
-    
-    return r0
-  end
-  
-  module Multitive0
-    def operand_1
-      elements[0]
-    end
-    
-    def space
-      elements[1]
-    end
-    
-    def operator
-      elements[2]
-    end
-    
-    def space
-      elements[3]
-    end
-    
-    def operand_2
-      elements[4]
-    end
-  end
-  
-  def _nt_multitive
-    start_index = index
-    cached = node_cache[:multitive][index]
-    if cached
-      @index = cached.interval.end
-      return cached
-    end
-    
-    i0 = index
-    i1, s1 = index, []
-    r2 = _nt_primary
-    s1 << r2
-    if r2.success?
-      r3 = _nt_space
-      s1 << r3
-      if r3.success?
-        r4 = _nt_multitive_op
-        s1 << r4
-        if r4.success?
-          r5 = _nt_space
-          s1 << r5
-          if r5.success?
-            r6 = _nt_multitive
-            s1 << r6
-          end
-        end
-      end
-    end
-    if s1.last.success?
-      r1 = (BinaryOperation).new(input, i1...index, s1)
-      r1.extend(Multitive0)
-    else
-      self.index = i1
-      r1 = ParseFailure.new(input, i1)
-    end
-    if r1.success?
-      r0 = r1
-    else
-      r7 = _nt_primary
-      if r7.success?
-        r0 = r7
-      else
-        self.index = i0
-        r0 = ParseFailure.new(input, i0)
-      end
-    end
-    
-    node_cache[:multitive][start_index] = r0
-    
-    return 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
-    cached = node_cache[:multitive_op][index]
-    if cached
-      @index = cached.interval.end
-      return cached
-    end
-    
-    i0 = index
-    r1 = parse_terminal('*', SyntaxNode, MultitiveOp0)
-    if r1.success?
-      r0 = r1
-    else
-      r2 = parse_terminal('/', SyntaxNode, MultitiveOp1)
-      if r2.success?
-        r0 = r2
-      else
-        self.index = i0
-        r0 = ParseFailure.new(input, i0)
-      end
-    end
-    
-    node_cache[:multitive_op][start_index] = r0
-    
-    return r0
-  end
-  
-  module Primary0
-    def space
-      elements[1]
-    end
-    
-    def expression
-      elements[2]
-    end
-    
-    def space
-      elements[3]
-    end
-    
-  end
-  
-  module Primary1
-    def eval(env={})
-      expression.eval(env)
-    end
-  end
-  
-  def _nt_primary
-    start_index = index
-    cached = node_cache[:primary][index]
-    if cached
-      @index = cached.interval.end
-      return cached
-    end
-    
-    i0 = index
-    r1 = _nt_variable
-    if r1.success?
-      r0 = r1
-    else
-      r2 = _nt_number
-      if r2.success?
-        r0 = r2
-      else
-        i3, s3 = index, []
-        r4 = parse_terminal('(', SyntaxNode)
-        s3 << r4
-        if r4.success?
-          r5 = _nt_space
-          s3 << r5
-          if r5.success?
-            r6 = _nt_expression
-            s3 << r6
-            if r6.success?
-              r7 = _nt_space
-              s3 << r7
-              if r7.success?
-                r8 = parse_terminal(')', SyntaxNode)
-                s3 << r8
-              end
-            end
-          end
-        end
-        if s3.last.success?
-          r3 = (SyntaxNode).new(input, i3...index, s3)
-          r3.extend(Primary0)
-          r3.extend(Primary1)
-        else
-          self.index = i3
-          r3 = ParseFailure.new(input, i3)
-        end
-        if r3.success?
-          r0 = r3
-        else
-          self.index = i0
-          r0 = ParseFailure.new(input, i0)
-        end
-      end
-    end
-    
-    node_cache[:primary][start_index] = r0
-    
-    return r0
-  end
-  
-  module Variable0
-    def eval(env={})
-      env[name]
-    end
-    
-    def name
-      text_value
-    end
-  end
-  
-  def _nt_variable
-    start_index = index
-    cached = node_cache[:variable][index]
-    if cached
-      @index = cached.interval.end
-      return cached
-    end
-    
-    s0, i0 = [], index
-    loop do
-      r1 = parse_char_class(/[a-z]/, 'a-z', SyntaxNode)
-      if r1.success?
-        s0 << r1
-      else
-        break
-      end
-    end
-    if s0.empty?
-      self.index = i0
-      r0 = ParseFailure.new(input, i0)
-    else
-      r0 = SyntaxNode.new(input, i0...index, s0)
-      r0.extend(Variable0)
-    end
-    
-    node_cache[:variable][start_index] = r0
-    
-    return r0
-  end
-  
-  module Number0
-  end
-  
-  module Number1
-    def eval(env={})
-      text_value.to_i
-    end
-  end
-  
-  def _nt_number
-    start_index = index
-    cached = node_cache[:number][index]
-    if cached
-      @index = cached.interval.end
-      return cached
-    end
-    
-    i0 = index
-    i1, s1 = index, []
-    r2 = parse_char_class(/[1-9]/, '1-9', SyntaxNode)
-    s1 << r2
-    if r2.success?
-      s3, i3 = [], index
-      loop do
-        r4 = parse_char_class(/[0-9]/, '0-9', SyntaxNode)
-        if r4.success?
-          s3 << r4
-        else
-          break
-        end
-      end
-      r3 = SyntaxNode.new(input, i3...index, s3)
-      s1 << r3
-    end
-    if s1.last.success?
-      r1 = (SyntaxNode).new(input, i1...index, s1)
-      r1.extend(Number0)
-    else
-      self.index = i1
-      r1 = ParseFailure.new(input, i1)
-    end
-    if r1.success?
-      r0 = r1
-      r0.extend(Number1)
-    else
-      r5 = parse_terminal('0', SyntaxNode)
-      if r5.success?
-        r0 = r5
-        r0.extend(Number1)
-      else
-        self.index = i0
-        r0 = ParseFailure.new(input, i0)
-      end
-    end
-    
-    node_cache[:number][start_index] = r0
-    
-    return r0
-  end
-  
-  def _nt_space
-    start_index = index
-    cached = node_cache[:space][index]
-    if cached
-      @index = cached.interval.end
-      return cached
-    end
-    
-    s0, i0 = [], index
-    loop do
-      r1 = parse_terminal(' ', SyntaxNode)
-      if r1.success?
-        s0 << r1
-      else
-        break
-      end
-    end
-    r0 = SyntaxNode.new(input, i0...index, s0)
-    
-    node_cache[:space][start_index] = r0
-    
-    return r0
-  end
-  
-end
-
-class ArithmeticParser < Treetop::Runtime::CompiledParser
-  include Arithmetic
-end

data/vendor/treetop/examples/lambda_calculus/arithmetic.treetop

@@ -1,97 +0,0 @@
-grammar Arithmetic  
-  rule expression
-    comparative / additive
-  end
-  
-  rule comparative
-    operand_1:additive space operator:equality_op space operand_2:additive <BinaryOperation>
-  end
-  
-  rule equality_op
-    '==' {
-      def apply(a, b)
-        a == b
-      end
-    }
-  end
-  
-  rule additive
-    operand_1:multitive
-    space operator:additive_op space
-    operand_2:additive <BinaryOperation>
-    /
-    multitive
-  end
-  
-  rule additive_op
-    '+' {
-      def apply(a, b)
-        a + b
-      end
-    }
-    /
-    '-' {
-      def apply(a, b)
-        a - b
-      end
-    }
-  end
-
-  rule multitive
-    operand_1:primary
-    space operator:multitive_op space
-    operand_2:multitive <BinaryOperation>
-    /
-    primary
-  end
-  
-  rule multitive_op
-    '*' {
-      def apply(a, b)
-        a * b
-      end
-    }
-    /
-    '/' {
-      def apply(a, b)
-        a / b
-      end
-    }
-  end  
-  
-  rule primary
-    variable
-    /
-    number
-    /
-    '(' space expression space ')' {
-      def eval(env={})
-        expression.eval(env)
-      end
-    }
-  end
-
-  rule variable
-    [a-z]+ {
-      def eval(env={})
-        env[name]
-      end
-      
-      def name
-        text_value
-      end
-    }
-  end
-
-  rule number
-    ([1-9] [0-9]* / '0') {
-      def eval(env={})
-        text_value.to_i
-      end
-    }
-  end
-  
-  rule space
-    ' '*
-  end
-end

data/vendor/treetop/examples/lambda_calculus/arithmetic_node_classes.rb

@@ -1,7 +0,0 @@
-module Arithmetic
-  class BinaryOperation < Treetop::Runtime::SyntaxNode
-    def eval(env={})
-      operator.apply(operand_1.eval(env), operand_2.eval(env))      
-    end
-  end
-end

data/vendor/treetop/examples/lambda_calculus/arithmetic_test.rb

@@ -1,54 +0,0 @@
-dir = File.dirname(__FILE__)
-require File.expand_path("#{dir}/test_helper")
-
-require File.expand_path("#{dir}/arithmetic_node_classes")
-Treetop.load File.expand_path("#{dir}/arithmetic")
-
-class ArithmeticParserTest < Test::Unit::TestCase
-  include ParserTestHelper
-  
-  def setup
-    @parser = ArithmeticParser.new
-  end
-  
-  def test_number
-    assert_equal 0, parse('0').eval
-    assert_equal 1, parse('1').eval
-    assert_equal 123, parse('123').eval
-  end
-  
-  def test_variable
-    assert_equal 0, parse('x').eval('x' => 0)
-    assert_equal 3, parse('x').eval('x' => 3)
-    assert_equal 10, parse('y').eval('y' => 10)
-  end
-  
-  def test_addition
-    assert_equal 10, parse('x + 5').eval('x' => 5)
-  end
-  
-  def test_subtraction
-    assert_equal 0, parse('x - 5').eval('x' => 5)
-  end
-  
-  def test_multiplication
-    assert_equal 6, parse('x * 2').eval('x' => 3)
-  end
-  
-  def test_division
-    assert_equal 3, parse('x / 2').eval('x' => 6)
-  end
-  
-  def test_order_of_operations
-    assert_equal 11, parse('1 + 2 * 3 + 4').eval
-  end
-  
-  def test_parentheses
-    assert_equal 25, parse('(5 + x) * (10 - y)').eval('x' => 0, 'y' => 5)
-  end
-  
-  def test_equality
-    assert parse('4 == 4').eval
-    assert !parse('4 == 3').eval
-  end
-end