mail 2.1.5.2 → 2.1.5.3

data/lib/mail/vendor/treetop-1.4.4/lib/treetop/runtime/interval_skip_list.rb

@@ -1,3 +0,0 @@
-require 'treetop/runtime/interval_skip_list/interval_skip_list'
-require 'treetop/runtime/interval_skip_list/head_node'
-require 'treetop/runtime/interval_skip_list/node'

data/lib/mail/vendor/treetop-1.4.4/lib/treetop/runtime/interval_skip_list/head_node.rb

@@ -1,15 +0,0 @@
-class IntervalSkipList
-  class HeadNode
-    attr_reader :height, :forward, :forward_markers
-
-    def initialize(height)
-      @height = height
-      @forward = Array.new(height, nil)
-      @forward_markers = Array.new(height) {|i| []}
-    end
-
-    def top_level
-      height - 1
-    end
-  end
-end

data/lib/mail/vendor/treetop-1.4.4/lib/treetop/runtime/interval_skip_list/interval_skip_list.rb

@@ -1,200 +0,0 @@
-class IntervalSkipList
-  attr_reader :probability
-
-  def initialize
-    @head = HeadNode.new(max_height)
-    @ranges = {}
-    @probability = 0.5
-  end
-
-  def max_height
-    3
-  end
-
-  def empty?
-    head.forward[0].nil?
-  end
-
-  def expire(range, length_change)
-    expired_markers, first_node_after_range = overlapping(range)
-    expired_markers.each { |marker| delete(marker) }
-    first_node_after_range.propagate_length_change(length_change)    
-  end
-
-  def overlapping(range)
-    markers, first_node = containing_with_node(range.first)
-
-    cur_node = first_node
-    begin
-      markers.concat(cur_node.forward_markers.flatten)
-      cur_node = cur_node.forward[0]
-    end while cur_node.key < range.last
-
-    return markers.uniq, cur_node
-  end
-
-  def containing(n)
-    containing_with_node(n).first
-  end
-
-  def insert(range, marker)
-    ranges[marker] = range
-    first_node = insert_node(range.first)
-    first_node.endpoint_of.push(marker)
-    last_node = insert_node(range.last)
-    last_node.endpoint_of.push(marker)
-
-    cur_node = first_node
-    cur_level = first_node.top_level
-    while next_node_at_level_inside_range?(cur_node, cur_level, range)
-      while can_ascend_from?(cur_node, cur_level) && next_node_at_level_inside_range?(cur_node, cur_level + 1, range)
-        cur_level += 1
-      end
-      cur_node = mark_forward_path_at_level(cur_node, cur_level, marker)
-    end
-
-    while node_inside_range?(cur_node, range)
-      while can_descend_from?(cur_level) && next_node_at_level_outside_range?(cur_node, cur_level, range)
-        cur_level -= 1 
-      end
-      cur_node = mark_forward_path_at_level(cur_node, cur_level, marker)
-    end
-  end
-
-  def delete(marker)
-    range = ranges[marker]
-    path_to_first_node = make_path
-    first_node = find(range.first, path_to_first_node)
-
-    cur_node = first_node
-    cur_level = first_node.top_level
-    while next_node_at_level_inside_range?(cur_node, cur_level, range)
-      while can_ascend_from?(cur_node, cur_level) && next_node_at_level_inside_range?(cur_node, cur_level + 1, range)
-        cur_level += 1
-      end
-      cur_node = unmark_forward_path_at_level(cur_node, cur_level, marker)
-    end
-
-    while node_inside_range?(cur_node, range)
-      while can_descend_from?(cur_level) && next_node_at_level_outside_range?(cur_node, cur_level, range)
-        cur_level -= 1
-      end
-      cur_node = unmark_forward_path_at_level(cur_node, cur_level, marker)
-    end
-    last_node = cur_node
-
-    first_node.endpoint_of.delete(marker)
-    if first_node.endpoint_of.empty?
-      first_node.delete(path_to_first_node)
-    end
-
-    last_node.endpoint_of.delete(marker)
-    if last_node.endpoint_of.empty?
-      path_to_last_node = make_path
-      find(range.last, path_to_last_node)
-      last_node.delete(path_to_last_node)
-    end
-  end
-
-  protected
-  attr_reader :head, :ranges
-
-  def insert_node(key)
-    path = make_path
-    found_node = find(key, path)
-    if found_node && found_node.key == key
-      return found_node
-    else
-      return Node.new(key, next_node_height, path)
-    end
-  end  
-
-  def containing_with_node(n)
-    containing = []
-    cur_node = head
-    (max_height - 1).downto(0) do |cur_level|
-      while (next_node = cur_node.forward[cur_level]) && next_node.key <= n
-        cur_node = next_node
-        if cur_node.key == n
-          return containing + (cur_node.markers - cur_node.endpoint_of), cur_node
-        end
-      end
-      containing.concat(cur_node.forward_markers[cur_level])
-    end
-
-    return containing, cur_node
-  end
-
-  def delete_node(key)
-    path = make_path
-    found_node = find(key, path)
-    found_node.delete(path) if found_node.key == key
-  end
-  
-  def find(key, path)
-    cur_node = head
-    (max_height - 1).downto(0) do |cur_level|
-      while (next_node = cur_node.forward[cur_level]) && next_node.key < key
-        cur_node = next_node
-      end
-      path[cur_level] = cur_node
-    end
-    cur_node.forward[0]
-  end
-
-  def make_path
-    Array.new(max_height, nil)
-  end
-
-  def next_node_height
-    height = 1
-    while rand < probability && height < max_height
-      height += 1
-    end
-    height
-  end
-
-  def can_ascend_from?(node, level)
-    level < node.top_level
-  end
-
-  def can_descend_from?(level)
-    level > 0
-  end
-
-  def node_inside_range?(node, range)
-    node.key < range.last
-  end
-
-  def next_node_at_level_inside_range?(node, level, range)
-    node.forward[level] && node.forward[level].key <= range.last
-  end
-
-  def next_node_at_level_outside_range?(node, level, range)
-    (node.forward[level].nil? || node.forward[level].key > range.last)
-  end
-
-  def mark_forward_path_at_level(node, level, marker)
-    node.forward_markers[level].push(marker)
-    next_node = node.forward[level]
-    next_node.markers.push(marker)
-    node = next_node
-  end
-
-  def unmark_forward_path_at_level(node, level, marker)
-    node.forward_markers[level].delete(marker)
-    next_node = node.forward[level]
-    next_node.markers.delete(marker)
-    node = next_node
-  end
-
-  def nodes
-    nodes = []
-    cur_node = head.forward[0]
-    until cur_node.nil?
-      nodes << cur_node
-      cur_node = cur_node.forward[0]
-    end
-    nodes
-  end 
-end

data/lib/mail/vendor/treetop-1.4.4/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/mail/vendor/treetop-1.4.4/lib/treetop/runtime/syntax_node.rb

@@ -1,114 +0,0 @@
-module Treetop
-  module Runtime
-    class SyntaxNode
-      attr_reader :input, :interval
-      attr_accessor :parent
-
-      def initialize(input, interval, elements = nil)
-        @input = input
-        @interval = interval
-        @elements = elements
-      end
-
-      def elements
-        return @elements if terminal?
-        # replace the character class placeholders in the sequence (lazy instantiation)
-        last_element = nil
-        @comprehensive_elements ||= @elements.map do |element|
-          if element == true
-            index = last_element ? last_element.interval.last : interval.first
-            element = SyntaxNode.new(input, index...(index + 1))
-          end
-          element.parent = self
-          last_element = element
-        end
-
-        @comprehensive_elements
-      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
-
-      @@dot_id_counter = 0
-
-      def dot_id
-        @dot_id ||= @@dot_id_counter += 1
-      end
-
-      def write_dot(io)
-        io.puts "node#{dot_id} [label=\"'#{text_value}'\"];"
-        if nonterminal? then
-          elements.each do
-            |x|
-            io.puts "node#{dot_id} -> node#{x.dot_id};"
-            x.write_dot(io)
-          end
-        end
-      end
-
-      def write_dot_file(fname)
-        File.open(fname + ".dot","w") do
-          |file|
-          file.puts "digraph G {"
-          write_dot(file)
-          file.puts "}"
-        end
-      end
-    end
-  end
-end