treetop 1.4.15 → 1.5.1

data/lib/treetop/compiler/metagrammar.treetop

@@ -389,19 +389,19 @@ module Treetop
       end
 
       rule quoted_string
-        (single_quoted_string / double_quoted_string) {
+        qs:(single_quoted_string / double_quoted_string) insens:'i'? <Terminal> {
           def string
-            super.text_value
+            qs.text_value
           end
         }
       end
 
       rule double_quoted_string
-        '"' string:(!'"' ("\\\\" / '\"' / .))* '"' <Terminal>
+        '"' string:(!'"' ("\\\\" / '\"' / .))* '"'
       end
 
       rule single_quoted_string
-        "'" string:(!"'" ("\\\\" / "\\'" / .))* "'" <Terminal>
+        "'" string:(!"'" ("\\\\" / "\\'" / .))* "'"
       end
 
       rule character_class

data/lib/treetop/compiler/node_classes/anything_symbol.rb

@@ -4,8 +4,12 @@ module Treetop
       def compile(address, builder, parent_expression = nil)
         super
         builder.if__ "index < input_length" do
-          assign_result "instantiate_node(#{node_class_name},input, index...(index + 1))"
-          extend_result_with_inline_module
+          if address == 0 || decorated?
+	    assign_result "instantiate_node(#{node_class_name},input, index...(index + 1))"
+	    extend_result_with_inline_module
+          else
+            assign_lazily_instantiated_node
+          end
           builder << "@index += 1"
         end
         builder.else_ do
@@ -15,4 +19,4 @@ module Treetop
       end
     end
   end
-end
+end

data/lib/treetop/compiler/node_classes/character_class.rb

@@ -3,8 +3,8 @@ module Treetop
     class CharacterClass < AtomicExpression
       def compile(address, builder, parent_expression = nil)
         super
-        
-        builder.if__ "has_terminal?(#{grounded_regexp(text_value)}, true, index)" do
+
+        builder.if__ "has_terminal?(@regexps[gr = #{grounded_regexp(text_value)}] ||= Regexp.new(gr), :regexp, index)" do
           if address == 0 || decorated?
             assign_result "instantiate_node(#{node_class_name},input, index...(index + 1))"
             extend_result_with_inline_module

data/lib/treetop/compiler/node_classes/choice.rb

@@ -13,6 +13,8 @@ module Treetop
         obtain_new_subexpression_address
         alternatives.first.compile(subexpression_address, builder)
         builder.if__ subexpression_success? do
+	  # Undo lazy instantiation:
+	  builder << "#{subexpression_result_var} = SyntaxNode.new(input, (index-1)...index) if #{subexpression_result_var} == true"
           assign_result subexpression_result_var
           extend_result_with_declared_module
           extend_result_with_inline_module
@@ -28,4 +30,4 @@ module Treetop
       end
     end
   end
-end
+end

data/lib/treetop/compiler/node_classes/parsing_rule.rb

@@ -33,9 +33,11 @@ module Treetop
       
       def generate_cache_lookup(builder)
         builder.if_ "node_cache[:#{name}].has_key?(index)" do
-          builder.assign 'cached', "node_cache[:#{name}][index]"
+	  cache_address = "node_cache[:#{name}][index]"
+          builder.assign 'cached', cache_address
           builder.if_ "cached" do
-            builder << 'cached = SyntaxNode.new(input, index...(index + 1)) if cached == true'
+            # Handle lazily instantiated nodes:
+            builder << "#{cache_address} = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true"
             builder << '@index = cached.interval.end'
           end
           builder << 'return cached'

data/lib/treetop/compiler/node_classes/terminal.rb

@@ -3,15 +3,21 @@ module Treetop
     class Terminal < AtomicExpression
       def compile(address, builder, parent_expression = nil)
         super
-        string_length = eval(text_value).length
-        
-        builder.if__ "has_terminal?(#{text_value}, false, index)" do
-          assign_result "instantiate_node(#{node_class_name},input, index...(index + #{string_length}))"
-          extend_result_with_inline_module
+	insensitive = insens.text_value.length > 0
+	str = insensitive ? string.downcase : string
+        string_length = eval(str).length
+
+        builder.if__ "has_terminal?(#{str}, #{insensitive ? ':insens' : false}, index)" do
+          if address == 0 || decorated? || string_length > 1
+	    assign_result "instantiate_node(#{node_class_name},input, index...(index + #{string_length}))"
+	    extend_result_with_inline_module
+          else
+            assign_lazily_instantiated_node
+	  end
           builder << "@index += #{string_length}"
         end
         builder.else_ do
-          builder << "terminal_parse_failure(#{text_value})"
+          builder << "terminal_parse_failure(#{str})"
           assign_result 'nil'
         end
       end

data/lib/treetop/runtime/compiled_parser.rb

@@ -92,12 +92,17 @@ module Treetop
         end
       end
 
-      def has_terminal?(terminal, regex, index)
-        if regex
+      def has_terminal?(terminal, mode, index)
+	case mode
+	when :regexp	# A Regexp has been passed in, probably a character class
+          input.index(terminal, index) == index
+	when false	# The terminal is a string which must match exactly
+          input[index, terminal.size] == terminal
+	when :insens	# The terminal is a downcased string which must match input downcased
+          input[index, terminal.size].downcase == terminal
+	when true	# Only occurs with old compiled grammars, for character classes
           rx = @regexps[terminal] ||= Regexp.new(terminal)
           input.index(rx, index) == index
-        else
-          input[index, terminal.size] == terminal
         end
       end
 

data/lib/treetop/version.rb

@@ -1,8 +1,8 @@
 module Treetop #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 1
-    MINOR = 4
-    TINY  = 15
+    MINOR = 5
+    TINY  = 1
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/spec/compiler/character_class_spec.rb

@@ -228,19 +228,19 @@ module CharacterClassSpec
   end
   
   describe "a character class mixed with other expressions" do
-    testing_expression '[A-Z] "a"'
+    testing_expression '[A-Z] "a" "bc"'
     it "lazily instantiates a node for the character" do
-      result = parse('Aa')
+      result = parse('Aabc')
       result.instance_variable_get("@elements").should include(true)
       result.elements.should_not include(true)
-      result.elements.size.should == 2
+      result.elements.size.should == 3
     end
   end
   
   describe "a character class with a node class declaration mixed with other expressions" do
-    testing_expression '([A-Z] <CharacterClassSpec::Foo>) "a"'
+    testing_expression '([A-Z] <CharacterClassSpec::Foo>) "ab"'
     it "actively generates a node for the character because it has a node class declared" do
-      result = parse('Aa')
+      result = parse('Aab')
       result.instance_variable_get("@elements").should_not include(true)
       result.elements.should_not include(true)
       result.elements.size.should == 2
@@ -248,9 +248,9 @@ module CharacterClassSpec
   end
   
   describe "a character class with a node module declaration mixed with other expressions" do
-    testing_expression '([A-Z] <CharacterClassSpec::ModFoo>) "a"'
+    testing_expression '([A-Z] <CharacterClassSpec::ModFoo>) "ab"'
     it "actively generates a node for the character because it has a node module declared" do
-      result = parse('Aa')
+      result = parse('Aab')
       result.instance_variable_get("@elements").should_not include(true)
       result.elements.should_not include(true)
       result.elements.size.should == 2
@@ -258,9 +258,9 @@ module CharacterClassSpec
   end
   
   describe "a character class with an inline block mixed with other expressions" do
-    testing_expression '([A-Z] { def a_method; end }) "a"'
+    testing_expression '([A-Z] { def a_method; end }) "ab"'
     it "actively generates a node for the character because it has an inline block" do
-      result = parse('Aa')
+      result = parse('Aab')
       result.instance_variable_get("@elements").should_not include(true)
       result.elements.should_not include(true)
       result.elements.size.should == 2
@@ -268,28 +268,28 @@ module CharacterClassSpec
   end
   
   describe "a character class with a label mixed with other expressions" do
-    testing_expression 'upper:([A-Z]) "b"'
+    testing_expression 'upper:([A-Z]) "b" "cd"'
     it "returns the correct element for the labeled expression" do
-      result = parse('Ab')
+      result = parse('Abcd')
       result.upper.text_value.should == "A"
-      result.elements.size.should == 2
+      result.elements.size.should == 3
     end
   end
   
   describe "a character class repetition mixed with other expressions" do
-    testing_expression '[A-Z]+ "a"'
+    testing_expression '[A-Z]+ "a" "bc"'
     it "lazily instantiates a node for the character" do
-      result = parse('ABCa')
+      result = parse('ABCabc')
       result.elements[0].instance_variable_get("@elements").should include(true)
       result.elements[0].elements.should_not include(true)
       result.elements[0].elements.size.should == 3
-      result.elements.size.should == 2
-      result.elements.inspect.should == %Q{[SyntaxNode offset=0, "ABC":\n  SyntaxNode offset=0, "A"\n  SyntaxNode offset=1, "B"\n  SyntaxNode offset=2, "C", SyntaxNode offset=3, "a"]}
+      result.elements.size.should == 3
+      result.elements.inspect.should == %Q{[SyntaxNode offset=0, "ABC":\n  SyntaxNode offset=0, "A"\n  SyntaxNode offset=1, "B"\n  SyntaxNode offset=2, "C", SyntaxNode offset=3, "a", SyntaxNode offset=4, "bc"]}
     end
   end
   
   describe "a character class that gets cached because of a choice" do
-    testing_expression "[A-Z] 'a' / [A-Z]"
+    testing_expression "[A-Z] 'a' 'bc' / [A-Z]"
     
     it "generates a node for the lazily-instantiated character when it is the primary node" do
       result = parse('A')

data/spec/compiler/choice_spec.rb

@@ -54,10 +54,10 @@ module ChoiceSpec
   end
 
   describe "A choice between terminals followed by a block" do  
-    testing_expression "('a'/ 'b' / 'c') { def a_method; end }"
+    testing_expression "('a'/ 'bb' / [c]) { def a_method; end }"
 
     it "extends a match of any of its subexpressions with a module created from the block" do
-      ['a', 'b', 'c'].each do |letter|
+      ['a', 'bb', 'c'].each do |letter|
         parse(letter).should respond_to(:a_method)
       end
     end
@@ -69,10 +69,10 @@ module ChoiceSpec
   end
 
   describe "a choice followed by a declared module" do  
-    testing_expression "('a'/ 'b' / 'c') <ChoiceSpec::TestModule>"
+    testing_expression "('a'/ 'bb' / [c]) <ChoiceSpec::TestModule>"
 
     it "extends a match of any of its subexpressions with a module created from the block" do
-      ['a', 'b', 'c'].each do |letter|
+      ['a', 'bb', 'c'].each do |letter|
         parse(letter).should respond_to(:a_method)
       end
     end

data/spec/compiler/not_predicate_spec.rb

@@ -29,10 +29,10 @@ module NotPredicateSpec
   end
 
   describe "A !-predicated sequence" do
-    testing_expression '!("a" "b" "c")'
+    testing_expression '!("a" "b" "cc")'
 
     it "fails to parse matching input" do
-      parse('abc').should be_nil
+      parse('abcc').should be_nil
     end
   end
 end

data/spec/compiler/repeated_subrule_spec.rb

@@ -5,7 +5,7 @@ module RepeatedSubruleSpec
     testing_grammar %{
       grammar Foo
         rule foo
-          a:'a' space b:'b' space 'c'
+          a:'a' space b:'b' space 'cc'
         end
 
         rule space
@@ -15,7 +15,7 @@ module RepeatedSubruleSpec
     }
   
     it "should produce a parser having sequence-numbered node accessor methods" do
-      parse("a b c") do |result|
+      parse("a b cc") do |result|
         result.should_not be_nil
         result.should respond_to(:space1)
         result.should respond_to(:space2)

data/spec/compiler/terminal_spec.rb

@@ -4,6 +4,50 @@ module TerminalSymbolSpec
   class Foo < Treetop::Runtime::SyntaxNode
   end
 
+  describe "a terminal symbol" do
+    testing_expression "'Foo'"
+
+    it "matches the input string" do
+      parse "Foo", :index => 0 do |result|
+        result.should_not be_nil
+        result.interval.should == (0...3)
+        result.text_value.should == 'Foo'
+      end
+    end
+
+    it "fails to match the input string other than at the start" do
+      parse " Foo", :index => 0 do |result|
+        result.should be_nil
+      end
+    end
+
+    it "fails to match the input string in the wrong case" do
+      parse "foo", :index => 0 do |result|
+        result.should be_nil
+      end
+    end
+  end
+
+  describe "a terminal symbol with case-insensitive matching" do
+    testing_expression "'Foo'i"
+
+    it "matches the input string in the same case" do
+      parse "Foo", :index => 0 do |result|
+        result.should_not be_nil
+        result.interval.should == (0...3)
+        result.text_value.should == 'Foo'
+      end
+    end
+
+    it "matches the input string in varied case" do
+      parse "foO", :index => 0 do |result|
+        result.should_not be_nil
+        result.interval.should == (0...3)
+        result.text_value.should == 'foO'
+      end
+    end
+  end
+
   describe "a terminal symbol followed by a node class declaration and a block" do
     testing_expression "'foo' <TerminalSymbolSpec::Foo> { def a_method; end }"
 

data/spec/compiler/zero_or_more_spec.rb

@@ -47,7 +47,7 @@ module ZeroOrMoreSpec
   end
 
   describe "Zero or more of a choice" do
-    testing_expression '("a" / "b")*'
+    testing_expression '("a" / "bb")*'
 
     it "successfully parses matching input" do
       parse('abba').should_not be_nil

data/spec/composition/b.treetop

@@ -1,11 +1,11 @@
 module Test
   grammar B
     rule b
-      'b'
+      'bb'
     end
     
     rule inherit
       super 'keyword'
     end
   end
-end
+end

data/spec/composition/grammar_composition_spec.rb

@@ -16,7 +16,7 @@ module GrammarCompositionSpec
     end
 
     specify "rules in C have access to rules defined in A and B" do
-      @c.parse('abc').should_not be_nil
+      @c.parse('abbc').should_not be_nil
     end
 
     specify "rules in C can override rules in A and B with super semantics" do
@@ -33,7 +33,7 @@ module GrammarCompositionSpec
     end
     
     specify "rules in F have access to rule defined in E" do
-      @f.parse('abcef').should_not be_nil
+      @f.parse('abbcef').should_not be_nil
     end
     
   end

data/spec/runtime/compiled_parser_spec.rb

@@ -11,7 +11,7 @@ module CompiledParserSpec
         end
 
         rule b
-          'b'
+          'bb'
         end
       end
     }
@@ -25,7 +25,7 @@ module CompiledParserSpec
       parser.parse('b').should be_nil
 
       # Check that the temporary-override works:
-      parser.parse('b', :root => :b).should_not be_nil
+      parser.parse('bb', :root => :b).should_not be_nil
       parser.parse('a', :root => :b).should be_nil
 
       # Check that the temporary-override isn't sticky:
@@ -33,7 +33,7 @@ module CompiledParserSpec
 
       # Try a permanent override:
       parser.root = :b
-      parser.parse('b').should_not be_nil
+      parser.parse('bb').should_not be_nil
       parser.parse('a').should be_nil
     end
 

data/treetop.gemspec

@@ -2,15 +2,17 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
+# stub: treetop 1.5.1 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "treetop"
-  s.version = "1.4.15"
+  s.version = "1.5.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
   s.authors = ["Nathan Sobo", "Clifford Heath"]
   s.autorequire = "treetop"
-  s.date = "2013-08-17"
+  s.date = "2014-03-12"
   s.email = "cliffordheath@gmail.com"
   s.executables = ["tt"]
   s.extra_rdoc_files = [
@@ -136,41 +138,37 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "https://github.com/cjheath/treetop"
   s.licenses = ["MIT"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.24"
+  s.rubygems_version = "2.2.2"
   s.summary = "A Ruby-based text parsing and interpretation DSL"
 
   if s.respond_to? :specification_version then
-    s.specification_version = 3
+    s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<polyglot>, [">= 0"])
-      s.add_development_dependency(%q<jeweler>, [">= 0"])
-      s.add_development_dependency(%q<activesupport>, [">= 0"])
-      s.add_development_dependency(%q<i18n>, ["~> 0.5.0"])
+      s.add_runtime_dependency(%q<polyglot>, ["~> 0.3"])
+      s.add_development_dependency(%q<jeweler>, ["~> 2.0"])
+      s.add_development_dependency(%q<activesupport>, ["~> 4.0"])
+      s.add_development_dependency(%q<i18n>, ["~> 0.6"])
       s.add_development_dependency(%q<rr>, ["~> 1.0"])
-      s.add_development_dependency(%q<rspec>, [">= 2.0.0"])
-      s.add_development_dependency(%q<rake>, [">= 0"])
-      s.add_runtime_dependency(%q<polyglot>, [">= 0.3.1"])
+      s.add_development_dependency(%q<rspec>, ["~> 2"])
+      s.add_development_dependency(%q<rake>, ["~> 10"])
     else
-      s.add_dependency(%q<polyglot>, [">= 0"])
-      s.add_dependency(%q<jeweler>, [">= 0"])
-      s.add_dependency(%q<activesupport>, [">= 0"])
-      s.add_dependency(%q<i18n>, ["~> 0.5.0"])
+      s.add_dependency(%q<polyglot>, ["~> 0.3"])
+      s.add_dependency(%q<jeweler>, ["~> 2.0"])
+      s.add_dependency(%q<activesupport>, ["~> 4.0"])
+      s.add_dependency(%q<i18n>, ["~> 0.6"])
       s.add_dependency(%q<rr>, ["~> 1.0"])
-      s.add_dependency(%q<rspec>, [">= 2.0.0"])
-      s.add_dependency(%q<rake>, [">= 0"])
-      s.add_dependency(%q<polyglot>, [">= 0.3.1"])
+      s.add_dependency(%q<rspec>, ["~> 2"])
+      s.add_dependency(%q<rake>, ["~> 10"])
     end
   else
-    s.add_dependency(%q<polyglot>, [">= 0"])
-    s.add_dependency(%q<jeweler>, [">= 0"])
-    s.add_dependency(%q<activesupport>, [">= 0"])
-    s.add_dependency(%q<i18n>, ["~> 0.5.0"])
+    s.add_dependency(%q<polyglot>, ["~> 0.3"])
+    s.add_dependency(%q<jeweler>, ["~> 2.0"])
+    s.add_dependency(%q<activesupport>, ["~> 4.0"])
+    s.add_dependency(%q<i18n>, ["~> 0.6"])
     s.add_dependency(%q<rr>, ["~> 1.0"])
-    s.add_dependency(%q<rspec>, [">= 2.0.0"])
-    s.add_dependency(%q<rake>, [">= 0"])
-    s.add_dependency(%q<polyglot>, [">= 0.3.1"])
+    s.add_dependency(%q<rspec>, ["~> 2"])
+    s.add_dependency(%q<rake>, ["~> 10"])
   end
 end