less 0.8.13 → 1.0.4

data/lib/vendor/treetop/lib/treetop/runtime/interval_skip_list/node.rb

@@ -0,0 +1,164 @@
+class IntervalSkipList
+  class Node < HeadNode
+    attr_accessor :key
+    attr_reader :markers, :endpoint_of
+
+    def initialize(key, height, path)
+      super(height)
+      @key = key
+      @markers = []
+      @endpoint_of = []
+      update_forward_pointers(path)
+      promote_markers(path)
+    end
+
+    def all_forward_markers
+      markers.flatten
+    end
+
+    def delete(path)
+      0.upto(top_level) do |i|
+        path[i].forward[i] = forward[i]
+      end
+      demote_markers(path)
+    end
+
+    def propagate_length_change(length_change)
+      cur_node = self
+      while cur_node do
+        cur_node.key += length_change
+        cur_node = cur_node.forward[0]
+      end
+    end
+
+    protected
+
+    def update_forward_pointers(path)
+      0.upto(top_level) do |i|
+        forward[i] = path[i].forward[i]
+        path[i].forward[i] = self
+      end
+    end
+
+    def promote_markers(path)
+      promoted = []
+      new_promoted = []
+      0.upto(top_level) do |i|
+        incoming_markers = path[i].forward_markers[i]
+        markers.concat(incoming_markers)
+
+        incoming_markers.each do |marker|
+          if can_be_promoted_higher?(marker, i)
+            new_promoted.push(marker)
+            forward[i].delete_marker_from_path(marker, i, forward[i+1])
+          else
+            forward_markers[i].push(marker)
+          end
+        end
+
+        promoted.each do |marker|
+          if can_be_promoted_higher?(marker, i)
+            new_promoted.push(marker)
+            forward[i].delete_marker_from_path(marker, i, forward[i+1])
+          else
+            forward_markers[i].push(marker)
+          end
+        end
+
+        promoted = new_promoted
+        new_promoted = []
+      end
+    end
+
+
+    def can_be_promoted_higher?(marker, level)
+      level < top_level && forward[level + 1] && forward[level + 1].markers.include?(marker)
+    end
+
+    def delete_marker_from_path(marker, level, terminus)
+      cur_node = self
+      until cur_node == terminus
+        cur_node.forward_markers[level].delete(marker)
+        cur_node.markers.delete(marker)
+        cur_node = cur_node.forward[level]
+      end
+    end
+
+    def demote_markers(path)
+      demote_inbound_markers(path)
+      demote_outbound_markers(path)
+    end
+
+    def demote_inbound_markers(path)
+      demoted = []
+      new_demoted = []
+
+      top_level.downto(0) do |i|
+        incoming_markers = path[i].forward_markers[i].dup
+        incoming_markers.each do |marker|
+          unless forward_node_with_marker_at_or_above_level?(marker, i)
+            path[i].forward_markers[i].delete(marker)
+            new_demoted.push(marker)
+          end
+        end
+
+        demoted.each do |marker|
+          path[i + 1].place_marker_on_inbound_path(marker, i, path[i])
+
+          if forward[i].markers.include?(marker)
+            path[i].forward_markers[i].push(marker)
+          else
+            new_demoted.push(marker)
+          end
+        end
+
+        demoted = new_demoted
+        new_demoted = []
+      end
+    end
+
+    def demote_outbound_markers(path)
+      demoted = []
+      new_demoted = []
+
+      top_level.downto(0) do |i|
+        forward_markers[i].each do |marker|
+          new_demoted.push(marker) unless path[i].forward_markers[i].include?(marker)
+        end
+
+        demoted.each do |marker|
+          forward[i].place_marker_on_outbound_path(marker, i, forward[i + 1])
+          new_demoted.push(marker) unless path[i].forward_markers[i].include?(marker)
+        end
+
+        demoted = new_demoted
+        new_demoted = []
+      end
+    end
+
+    def forward_node_with_marker_at_or_above_level?(marker, level)
+      level.upto(top_level) do |i|
+        return true if forward[i].markers.include?(marker)
+      end
+      false
+    end
+
+    def place_marker_on_outbound_path(marker, level, terminus)
+      cur_node = self
+      until cur_node == terminus
+        cur_node.forward_markers[level].push(marker)
+        cur_node.markers.push(marker)
+        cur_node = cur_node.forward[level]
+      end
+    end
+
+    def place_marker_on_inbound_path(marker, level, terminus)
+      cur_node = self
+      until cur_node == terminus
+        cur_node.forward_markers[level].push(marker)
+        cur_node = cur_node.forward[level]
+        cur_node.markers.push(marker)
+      end
+    end
+  end
+end

data/lib/vendor/treetop/lib/treetop/runtime/syntax_node.rb

@@ -0,0 +1,90 @@
+module Treetop
+  module Runtime
+    class SyntaxNode
+      attr_reader :input, :interval
+      attr_accessor :parent
+
+      def initialize(input, interval, elements = nil)
+        @input = input
+        @interval = interval
+        if @elements = elements
+          @comprehensive_elements = @elements unless @elements.delete(true)
+          @elements.each do |element|
+            element.parent = self
+          end
+        end
+      end
+
+      def elements
+        return @elements if terminal?
+        # fill in any gaps in the sequence (lazy instantiation) if needed
+        @comprehensive_elements ||= interval.inject(@elements) do |elements, index|
+          unless @elements.any? {|element| element.interval.include?(index) }
+            node = SyntaxNode.new(input, index...(index + 1))
+            node.parent = self
+            elements << node
+          end
+          elements
+        end.sort
+      end
+
+      def terminal?
+        @elements.nil?
+      end
+
+      def nonterminal?
+        !terminal?
+      end
+
+      def text_value
+        input[interval]
+      end
+
+      def empty?
+        interval.first == interval.last && interval.exclude_end?
+      end
+      
+      def <=>(other)
+        self.interval.first <=> other.interval.first
+      end
+
+      def extension_modules
+        local_extensions =
+          class <<self
+            included_modules-Object.included_modules
+          end
+        if local_extensions.size > 0
+          local_extensions
+        else
+          []    # There weren't any; must be a literal node
+        end
+      end
+
+      def inspect(indent="")
+        em = extension_modules
+        interesting_methods = methods-[em.last ? em.last.methods : nil]-self.class.instance_methods
+        im = interesting_methods.size > 0 ? " (#{interesting_methods.join(",")})" : ""
+        tv = text_value
+        tv = "...#{tv[-20..-1]}" if tv.size > 20
+
+        indent +
+        self.class.to_s.sub(/.*:/,'') +
+          em.map{|m| "+"+m.to_s.sub(/.*:/,'')}*"" +
+          " offset=#{interval.first}" +
+          ", #{tv.inspect}" +
+          im +
+          (elements && elements.size > 0 ?
+            ":" +
+              (@elements||[]).map{|e|
+          begin
+            "\n"+e.inspect(indent+"  ")
+          rescue  # Defend against inspect not taking a parameter
+            "\n"+indent+" "+e.inspect
+          end
+              }.join("") :
+            ""
+          )
+      end
+    end
+  end
+end

data/lib/vendor/treetop/lib/treetop/runtime/terminal_parse_failure.rb

@@ -0,0 +1,16 @@
+module Treetop
+  module Runtime
+    class TerminalParseFailure
+      attr_reader :index, :expected_string
+
+      def initialize(index, expected_string)
+        @index = index
+        @expected_string = expected_string
+      end
+
+      def to_s
+        "String matching #{expected_string} expected."
+      end
+    end
+  end
+end

data/lib/vendor/treetop/lib/treetop/runtime/terminal_syntax_node.rb

@@ -0,0 +1,17 @@
+module Treetop
+  module Runtime
+    class TerminalSyntaxNode < SyntaxNode
+
+      def initialize(input, interval)
+        super(input, interval, [])
+      end
+
+      def inspect(indent="")
+	indent+
+	  self.class.to_s.sub(/.*:/,'') +
+	  " offset=#{interval.first}" +
+	  " #{text_value.inspect}"
+      end
+    end
+  end
+end

data/lib/vendor/treetop/lib/treetop/version.rb

@@ -0,0 +1,9 @@
+module Treetop #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 1
+    MINOR = 2
+    TINY  = 6
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/vendor/treetop/spec/compiler/and_predicate_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+
+module AndPredicateSpec
+  describe "An &-predicated terminal symbol" do
+    testing_expression '&"foo"'
+
+    it "successfully parses input matching the terminal symbol, returning an epsilon syntax node" do
+      parse('foo', :consume_all_input => false) do |result|
+        result.should_not be_nil
+        result.interval.should == (0...0)
+      end
+    end
+  end
+
+  describe "A sequence of a terminal and an and another &-predicated terminal" do
+    testing_expression '"foo" &"bar"'
+
+    it "matches input matching both terminals, but only consumes the first" do
+      parse('foobar', :consume_all_input => false) do |result|
+        result.should_not be_nil
+        result.text_value.should == 'foo'
+      end
+    end
+  
+    it "fails to parse input matching only the first terminal, with a terminal failure recorded at index 3" do
+      parse('foo') do |result|
+        result.should be_nil
+        terminal_failures = parser.terminal_failures
+        terminal_failures.size.should == 1
+        failure = terminal_failures[0]
+        failure.index.should == 3
+        failure.expected_string.should == 'bar'
+      end
+    end
+  end
+end

data/lib/vendor/treetop/spec/compiler/anything_symbol_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+
+module AnythingSymbolSpec
+  class Foo < Treetop::Runtime::SyntaxNode
+  end
+
+  describe "an anything symbol followed by a node class declaration and a block" do
+    testing_expression '. <AnythingSymbolSpec::Foo> { def a_method; end }'
+  
+    it "matches any single character in a big range, returning an instance of the declared node class that responds to methods defined in the inline module" do
+      (33..127).each do |digit|
+        parse(digit.chr) do |result|
+          result.should_not be_nil
+          result.should be_an_instance_of(Foo)
+          result.should respond_to(:a_method)
+          result.interval.should == (0...1)
+        end
+      end
+    end
+  
+    it "fails to parse epsilon" do
+      parse('').should be_nil
+    end
+  end
+
+  module ModFoo
+  end
+
+  describe "an anything symbol followed by a module declaration and a block" do
+    testing_expression '. <AnythingSymbolSpec::ModFoo> { def a_method; end }'
+  
+    it "matches any single character in a big range, returning an instance of SyntaxNode extended by the declared module that responds to methods defined in the inline module" do
+      (33..127).each do |digit|
+        parse(digit.chr) do |result|
+          result.should_not be_nil
+          result.should be_an_instance_of(Treetop::Runtime::SyntaxNode)
+          result.should be_a_kind_of(ModFoo)
+          result.should respond_to(:a_method)
+          result.interval.should == (0...1)
+        end
+      end
+    end
+  end
+end

data/lib/vendor/treetop/spec/compiler/character_class_spec.rb

@@ -0,0 +1,247 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+module CharacterClassSpec
+  class Foo < Treetop::Runtime::SyntaxNode
+  end
+
+  describe "a character class followed by a node class declaration and a block" do
+
+    testing_expression "[A-Z] <CharacterClassSpec::Foo> { def a_method; end }"
+
+    it "matches single characters within that range, returning instances of the declared node class that respond to the method defined in the inline module" do
+      result = parse('A')
+      result.should be_an_instance_of(Foo)
+      result.should respond_to(:a_method)
+      result = parse('N')
+      result.should be_an_instance_of(Foo)
+      result.should respond_to(:a_method)
+      result = parse('Z')
+      result.should be_an_instance_of(Foo)
+      result.should respond_to(:a_method)
+    end
+
+    it "does not match single characters outside of that range" do
+      parse('8').should be_nil
+      parse('a').should be_nil
+    end
+
+    it "matches a single character within that range at index 1" do
+      parse(' A', :index => 1).should_not be_nil
+    end
+
+    it "fails to match a single character out of that range at index 1" do
+      parse(' 1', :index => 1).should be_nil
+    end
+  end
+
+  module ModFoo
+  end
+
+  describe "a character class followed by a node module declaration and a block" do
+
+    testing_expression "[A-Z] <CharacterClassSpec::ModFoo> { def a_method; end }"
+
+    it "matches single characters within that range, returning instances of SyntaxNode extended by the specified module" do
+      result = parse('A')
+      result.should be_an_instance_of(Treetop::Runtime::SyntaxNode)
+      result.should be_a_kind_of(ModFoo)
+      result.should respond_to(:a_method)
+      result = parse('N')
+      result.should be_an_instance_of(Treetop::Runtime::SyntaxNode)
+      result.should be_a_kind_of(ModFoo)
+      result.should respond_to(:a_method)
+      result = parse('Z')
+      result.should be_an_instance_of(Treetop::Runtime::SyntaxNode)
+      result.should be_a_kind_of(ModFoo)
+      result.should respond_to(:a_method)
+    end
+
+    it "does not match single characters outside of that range" do
+      parse('8').should be_nil
+      parse('a').should be_nil
+    end
+
+    it "matches a single character within that range at index 1" do
+      parse(' A', :index => 1).should_not be_nil
+    end
+
+    it "fails to match a single character out of that range at index 1" do
+      parse(' 1', :index => 1).should be_nil
+    end
+  end
+  
+  describe "a character class followed by a node class declaration and a block" do
+
+    testing_expression "[A-Z] <CharacterClassSpec::Foo>"
+    
+    it "actively generates nodes for the character when it is the primary node" do
+      result = parse('A')
+      result.should be_a(Treetop::Runtime::SyntaxNode)
+      result.elements.should be_nil
+    end
+    
+  end
+
+  describe "A character class containing quotes" do
+    testing_expression "[\"']"
+
+    it "matches a quote" do
+      parse("'").should_not be_nil
+    end
+
+    it "matches a double-quote" do
+      parse('"').should_not be_nil
+    end
+  end
+
+  describe "A character class containing a special character" do
+    testing_expression "[\t]"
+    it "matches that character only" do
+      parse("\t").should_not be_nil
+      parse('t').should be_nil
+    end
+  end
+
+  describe "A character class containing an escaped backslash" do
+    slash = "\\"  # Make it explicit that there are *two* backslashes here
+    testing_expression "[#{slash}#{slash}]"
+    it "matches a backslash only" do
+      parse("\\").should_not be_nil
+      parse('t').should be_nil
+    end
+  end
+
+  describe "A character class containing a hex escape" do
+    slash = "\\"
+    testing_expression "[#{slash}x41]"
+    it "matches that character only" do
+      parse('A').should_not be_nil
+      parse('\\').should be_nil
+      parse('x').should be_nil
+      parse('4').should be_nil
+      parse('1').should be_nil
+    end
+  end
+
+  describe "A character class containing an octal escape" do
+    slash = "\\"
+    testing_expression "[#{slash}101]"
+    it "matches that character only" do
+      parse('A').should_not be_nil
+      parse('\\').should be_nil
+      parse('1').should be_nil
+      parse('0').should be_nil
+    end
+  end
+
+  describe "A character class containing a \\c control-char escape" do
+    slash = "\\"
+    testing_expression "[#{slash}cC]"
+    it "matches that character only" do
+      parse("\003").should_not be_nil
+      parse('\\').should be_nil
+      parse('c').should be_nil
+      parse('C').should be_nil
+    end
+  end
+
+  describe "A character class containing a \\C- control-char escape" do
+    slash = "\\"
+    testing_expression "[#{slash}C-C]"
+    it "matches that character only" do
+      parse("\003").should_not be_nil
+      parse('\\').should be_nil
+      parse('C').should be_nil
+      parse('-').should be_nil
+    end
+  end
+
+  describe "A character class containing a \\M- meta-char escape" do
+    slash = "\\"
+    testing_expression "[#{slash}M- ]"
+    it "matches that character only" do
+      parse("\240").should_not be_nil
+      parse('\\').should be_nil
+      parse('M').should be_nil
+      parse('-').should be_nil
+      parse(' ').should be_nil
+    end
+  end
+
+  describe "A character class containing an escaped non-special character" do
+    slash = "\\"
+    testing_expression "[#{slash}y]"
+    it "matches that character only" do
+      parse("y").should_not be_nil
+      parse('\\').should be_nil
+    end
+  end
+
+  describe "A character class containing an \#{...} insertion" do
+    testing_expression "[\#{raise 'error'}]"
+    it "doesn't evaluate the insertion" do
+      x = true
+      lambda{
+	x = parse("y")
+      }.should_not raise_error
+      x.should be_nil
+      parse('#').should_not be_nil
+      parse("'").should_not be_nil
+      parse("0").should be_nil
+    end
+  end
+  
+  describe "a character class" do
+    testing_expression "[A-Z]"
+    it "actively generates a node for the character because it is the primary node" do
+      result = parse('A')
+      result.should be_a(Treetop::Runtime::SyntaxNode)
+      result.elements.should be_nil
+    end
+  end
+  
+  describe "a character class mixed with other expressions" do
+    testing_expression '[A-Z] "a"'
+    it "lazily instantiates a node for the character" do
+      result = parse('Aa')
+      result.instance_variable_get("@elements").size.should == 1
+      result.elements.size.should == 2
+    end
+  end
+  
+  describe "a character class with a node class declaration mixed with other expressions" do
+    testing_expression '([A-Z] <CharacterClassSpec::Foo>) "a"'
+    it "actively generates a node for the character because it has a node class declared" do
+      result = parse('Aa')
+      result.instance_variable_get("@elements").size.should == 2
+      result.elements.size.should == 2
+    end
+  end
+  
+  describe "a character class with a node module declaration mixed with other expressions" do
+    testing_expression '([A-Z] <CharacterClassSpec::ModFoo>) "a"'
+    it "actively generates a node for the character because it has a node module declared" do
+      result = parse('Aa')
+      result.instance_variable_get("@elements").size.should == 2
+      result.elements.size.should == 2
+    end
+  end
+  
+  describe "a character class with an inline block mixed with other expressions" do
+    testing_expression '([A-Z] { def a_method; end }) "a"'
+    it "actively generates a node for the character because it has an inline block" do
+      result = parse('Aa')
+      result.instance_variable_get("@elements").size.should == 2
+      result.elements.size.should == 2
+    end
+  end
+  
+  describe "a character class with a label mixed with other expressions" do
+    testing_expression 'upper:([A-Z]) "b"'
+    it "returns the correct element for the labeled expression" do
+      result = parse('Ab')
+      result.upper.text_value.should == "A"
+    end
+  end
+
+end