less 1.1.13 → 1.2.9

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

@@ -1,164 +0,0 @@
-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

@@ -1,72 +0,0 @@
-module Treetop
-  module Runtime
-    class SyntaxNode
-      attr_reader :input, :interval, :elements
-      attr_accessor :parent
-
-      def initialize(input, interval, elements = nil)
-        @input = input
-        @interval = interval
-        if @elements = elements
-          elements.each do |element|
-            element.parent = self
-          end
-        end
-      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 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

@@ -1,16 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

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

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

@@ -1,36 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,182 +0,0 @@
-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 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
-
-end