facets 2.6.0 → 2.7.0

data/lib/more/facets/iteration.rb

@@ -1,65 +0,0 @@
-# = Iteration
-#
-#
-
-class It
-  attr_reader :index, :value, :prior, :after
-  def initialize(array)
-    @array = array
-    @index = 0
-    @value = array[0]
-    @prior = []
-    @after = array[1..-1]
-  end
-  def first? ; @index == 0 ; end
-  def last?
-    if Enumerable === self
-      nil
-    else
-      @index == @array.length
-    end
-  end
-  private
-  def next_iteration
-    @index += 1
-    @prior << @value
-    @value = @after.shift
-  end
-end
-
-class Array
-  # Iterate over each element of array using an iteration object.
-  #
-  #   [1,2,3].each_iteration do |it|
-  #     p it.index
-  #     p it.value
-  #     p it.first?
-  #     p it.last?
-  #     p it.prior
-  #     p it.after
-  #   end
-  #
-  # on each successive iteration produces:
-  #
-  #   0          1          2
-  #   1          2          3
-  #   true       false      false
-  #   false      false      true
-  #   []         [1]        [1,2]
-  #   [2,3]      [3]        []
-  #
-  # CREDIT: Trans
-
-  def each_iteration
-    if block_given?
-      it = It.new(self)
-      each do |e|
-        yield(it)
-        it.send(:next_iteration)
-      end
-    else
-      return Enumerable::Enumerator.new(self, :each_iteration)
-    end
-  end
-end
-

data/lib/more/facets/linkedlist.rb

@@ -1,222 +0,0 @@
-# = LinkedList
-#
-# LinkedList implements a simple doubly linked list with efficient
-# hash-like element access.
-#
-# This is a simple linked list implementation with efficient random
-# access of data elements.  It was inspired by George Moscovitis'
-# LRUCache implementation found in Facets 1.7.30, but unlike the
-# linked list in that cache, this one does not require the use of a
-# mixin on any class to be stored.  The linked list provides the
-# push, pop, shift, unshift, first, last, delete and length methods
-# which work just like their namesakes in the Array class, but it
-# also supports setting and retrieving values by key, just like a
-# hash.
-#
-# == History
-#
-# LinkedList was ported from the original in Kirk Hanes IOWA web framework.
-#
-# == Todo
-#
-# * Create an example of usage for docs.
-#
-# == Authors
-#
-# * Kirk Haines <khaines@enigo.com>.
-#
-# == Copying
-#
-# Copyright (C) 2006 Kirk Haines
-#
-# General Public License (GPL)
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-require 'enumerator'
-
-# = LinkedList
-#
-# LinkedList implements a simple doubly linked list with efficient
-# hash-like element access.
-#
-# This is a simple linked list implementation with efficient random
-# access of data elements.  It was inspired by George Moscovitis'
-# LRUCache implementation found in Facets 1.7.30, but unlike the
-# linked list in that cache, this one does not require the use of a
-# mixin on any class to be stored.  The linked list provides the
-# push, pop, shift, unshift, first, last, delete and length methods
-# which work just like their namesakes in the Array class, but it
-# also supports setting and retrieving values by key, just like a
-# hash.
-#
-class LinkedList
-
-        include Enumerable
-
-        # Represents a single node of the linked list.
-
-        class Node
-                attr_accessor :key, :value, :prev_node, :next_node
-
-                def initialize(key=nil,value=nil,prev_node=nil,next_node=nil)
-                        @key = key
-                        @value = value
-                        @prev_node = prev_node
-                        @next_node = next_node
-                end
-        end
-
-        def initialize
-                @head = Node.new
-                @tail = Node.new
-                @lookup = Hash.new
-                node_join(@head,@tail)
-        end
-
-        def [](v)
-                @lookup[v].value
-        end
-
-        def []=(k,v)
-                if @lookup.has_key?(k)
-                        @lookup[k].value = v
-                else
-                        n = Node.new(k,v,@head,@head.next_node)
-                        node_join(n,@head.next_node)
-                        node_join(@head,n)
-                        @lookup[k] = n
-                end
-                v
-        end
-
-        def empty?
-                @lookup.empty?
-        end
-
-        def delete(k)
-                n = @lookup.delete(k)
-                v = n ? node_purge(n) : nil
-                v
-        end
-
-        def first
-                @head.next_node.value
-        end
-
-        def last
-                @tail.prev_node.value
-        end
-
-        def shift
-                k = @head.next_node.key
-                n = @lookup.delete(k)
-                node_delete(n) if n
-        end
-
-        def unshift(v)
-                if @lookup.has_key?(v)
-                        n = @lookup[v]
-                        node_delete(n)
-                        node_join(n,@head.next_node)
-                        node_join(@head,n)
-                else
-                        n = Node.new(v,v,@head,@head.next_node)
-                        node_join(n,@head.next_node)
-                        node_join(@head,n)
-                        @lookup[v] = n
-                end
-                v
-        end
-
-        def pop
-                k = @tail.prev_node.key
-                n = @lookup.delete(k)
-                node_delete(n) if n
-        end
-
-        def push(v)
-                if @lookup.has_key?(v)
-                        n = @lookup[v]
-                        node_delete(n)
-                        node_join(@tail.prev_node,n)
-                        node_join(n,@tail)
-                else
-                        n = Node.new(v,v,@tail.prev_node,@tail)
-                        node_join(@tail.prev_node,n)
-                        node_join(n,@tail)
-                        @lookup[v] = n
-                end
-                v
-        end
-
-        def queue
-                r = []
-                n = @head
-                while (n = n.next_node) and n != @tail
-                        r << n.key
-                end
-                r
-        end
-
-        def to_a
-                r = []
-                n = @head
-                while (n = n.next_node) and n != @tail
-                        r << n.value
-                end
-                r
-        end
-
-        def length
-                @lookup.length
-        end
-
-        def each
-                n = @head
-                while (n = n.next_node) and n != @tail
-                        yield(n.key,n.value)
-                end
-        end
-
-        private
-
-        def node_delete(n)
-                node_join(n.prev_node,n.next_node)
-                v = n.value
-        end
-
-        def node_purge(n)
-                node_join(n.prev_node,n.next_node)
-                v = n.value
-                n.value = nil
-                n.key = nil
-                n.next_node = nil
-                n.prev_node = nil
-                v
-        end
-
-        def node_join(a,b)
-                a.next_node = b
-                b.prev_node = a
-        end
-
-end
-

data/lib/more/facets/lrucache.rb

@@ -1,157 +0,0 @@
-# = LRUCache
-#
-# A cache utilizing a simple LRU (Least Recently Used) policy.
-# The items managed by this cache must respond to the #key method.
-# Attempts to optimize reads rather than inserts!
-#
-# LRU semantics are enforced by inserting the items in a queue.
-# The lru item is always at the tail. Two special sentinels
-# (head, tail) are used to simplify (?) the code.
-#
-# == Authors
-#
-# * George Moschovitis
-# * Anastasios Koutoumanos
-#
-# == Copying
-#
-# Copyright 2004 George Moschovitis, Anastasios Koutoumanos
-#
-# Ruby License
-#
-# This module is free software. You may use, modify, and/or redistribute this
-# software under the same terms as Ruby.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE.
-
-# = LRUCache
-#
-# A cache utilizing a simple LRU (Least Recently Used) policy.
-# The items managed by this cache must respond to the #key method.
-# Attempts to optimize reads rather than inserts!
-#
-# LRU semantics are enforced by inserting the items in a queue.
-# The lru item is always at the tail. Two special sentinels
-# (head, tail) are used to simplify (?) the code.
-#
-class LRUCache < Hash
-
-  # Mix this in your class to make LRU-managable.
-
-  module Item
-    attr_accessor :lru_key, :lru_prev, :lru_next
-  end
-
-  # head-tail sentinels
-
-  class Sentinel; include Item; end
-
-  # the maximum number of items in the cache.
-
-  attr_accessor :max_items
-
-  # the head sentinel and the tail sentinel, tail.prev points to the lru item.
-
-  attr_reader :head, :tail
-
-  def initialize(max_items)
-    @max_items = max_items
-    lru_clear()
-  end
-
-  # Lookup an item in the cache.
-
-  def [](key)
-    if item = super
-      return lru_touch(item)
-    end
-  end
-
-  # The inserted item is considered mru!
-
-  def []=(key, item)
-    item = super
-    item.lru_key = key
-    lru_insert(item)
-  end
-
-  # Delete an item from the cache.
-
-  def delete(key)
-    if item = super
-      lru_delete(item)
-    end
-  end
-
-  # Clear the cache.
-
-  def clear
-    super
-    lru_clear()
-  end
-
-  # The first (mru) element in the cache.
-
-  def first
-    @head.lru_next
-  end
-
-  # The last (lru) element in the cache.
-
-  def last
-    @tail.lru_prev
-  end
-  alias_method :lru, :last
-
-  private
-
-  # Delete an item from the lru list.
-
-  def lru_delete(item)
-    lru_join(item.lru_prev, item.lru_next)
-    return item
-  end
-
-  # Join two items in the lru list.
-  # Return y to allow for chaining.
-
-  def lru_join(x, y)
-    x.lru_next = y
-    y.lru_prev = x
-    return y
-  end
-
-  # Append a child item to a parent item in the lru list
-  # (Re)inserts the child in the list.
-
-  def lru_append(parent, child)
-    lru_join(child, parent.lru_next)
-    lru_join(parent, child)
-  end
-
-  # Insert an item
-
-  def lru_insert(item)
-    delete(last.lru_key) if size() > @max_items
-    lru_append(@head, item)
-  end
-
-  # Touch an item, make mru!
-  # Returns the item.
-
-  def lru_touch(item)
-    lru_append(@head, lru_delete(item))
-  end
-
-  # Clear the lru.
-
-  def lru_clear
-    @head = Sentinel.new
-    @tail = Sentinel.new
-    lru_join(@head, @tail)
-  end
-
-end
-

data/lib/more/facets/matcher.rb

@@ -1,140 +0,0 @@
-#= Matcher
-#
-# Matcher derives from Ruby Quiz #103, the DictionaryMatcher quiz.
-#
-class Matcher
-  attr_reader :word_count
-
-  #Contains the index matched, and the word matched
-  class MatchData < Struct.new(:index,:match)
-    def inspect
-      "#{match.inspect}@#{index}"
-    end
-  end
-
-  def inspect
-    to_s
-  end
-
-  #Create a DictionaryMatcher with no words in it
-  def initialize
-    @trie = {}
-    @word_count = 0
-  end
-
-  #Add a word to the DictionaryMatcher
-  def add(word)
-    @word_count += 1
-    container = @trie
-    containers=[]
-
-    i=0
-    word.each_byte do |b|
-      container[b] = {} unless container.has_key? b
-      container[:depth]=i
-      containers << container
-      container = container[b]
-      i+=1
-    end
-    containers << container
-
-    container[0] = true # Mark end of word
-    container[:depth]=i
-
-    ff=compute_failure_function word
-    ff.zip(containers).each do |pointto,container|
-      container[:failure]=containers[pointto] if pointto
-    end
-
-    self
-
-  end
-
-  alias << add
-
-  def compute_failure_function p
-    m=p.size
-    pi=[nil,0]
-    k=0
-    2.upto m do |q|
-      k=pi[k] while k>0 and p[k] != p[q-1]
-      k=k+1 if p[k]==p[q-1]
-      pi[q]=k
-    end
-    pi
-  end
-  private :compute_failure_function
-
-   #Determine whether +string+ was previously <tt>add</tt>ed to the
-   #Trie.
-  def include?(word)
-    container = @trie
-    word.each_byte do |b|
-      break unless container.has_key? b
-      container = container[b]
-    end
-    container[0]
-  end
-
-   #Determines whether one of the words in the DictionaryMatcher is a
-   #substring of
-   #+string+. Returns the index of the match if found, +nil+ if not
-   #found.
-  def =~ text
-    internal_match(text){|md| return md.index}
-    nil
-  end
-
-   #Determine whether one of the words in the DictionaryMatcher is a
-   #substring of
-   #+string+. Returns a DictionaryMatcher::MatchData object if found,
-   #+nil+ if not #found.
-  def match text
-    internal_match(text){|md| return md}
-    nil
-  end
-
-  def internal_match string
-      node=@trie
-      pos=0
-      string.each_byte do |b|
-	 advance=false
-	 until advance
-	    nextnode=node[b]
-	    if not nextnode
-	       if node[:failure]
-		  node=node[:failure]
-	       else
-		  advance=true
-	       end
-	    elsif nextnode[0]
-	       yield MatchData.new(pos, string[pos+1-nextnode[:depth],nextnode[:depth]])
-	       advance=true
-	       node=@trie
-	    else
-	       advance=true
-	       node=nextnode
-	    end
-	    pos+=1
-	 end
-      end
-  end
-  private :internal_match
-
-   #Scans +string+ for all occurrances of strings in the
-   #DictionaryMatcher.
-   #Overlapping matches are skipped (only the first one is yielded), and
-   #when some strings in the
-   #DictionaryMatcher are substrings of others, only the shortest match
-   #at a given position is found.
-  def scan(text, &block)
-    matches=[]
-    block= lambda{ |md| matches << md } unless block
-    internal_match(text,&block)
-    matches
-  end
-
-  #Case equality. Similar to =~.
-  alias_method :===, :=~
-end
-