mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/more/facets/iteration.rb

@@ -0,0 +1,65 @@
+# = 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/gems/facets-2.4.5/lib/more/facets/kernel/meta.rb

@@ -0,0 +1,32 @@
+require 'facets/functor'
+
+module Kernel
+
+  # Provides access to an object's metaclass (ie. singleton)
+  # by-passsing access provisions. So for example:
+  #
+  #   class X
+  #     meta.attr_accesser :a
+  #   end
+  #
+  #   X.a = 1
+  #   X.a #=> 1
+  #
+  # The fact that some class methods are private and thus inaccessable
+  # via use of metaclass, is really a problem with them being private --which
+  # is probably not really neccessary. Short of making them public though, thiere
+  # is this method or one could use the #instance functor.
+  #
+  # TODO: Don't see any reason this can't go into core, but there is
+  # a conflict with URI prior to 1.8.6, so it will have to wait.
+  #
+  #  CREDIT: Trans
+
+  def meta
+    @_meta_functor ||= Functor.new do |op,*args|
+      (class << self; self; end).send(op,*args)
+    end
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/more/facets/linkedlist.rb

@@ -0,0 +1,222 @@
+# = 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/gems/facets-2.4.5/lib/more/facets/lrucache.rb

@@ -0,0 +1,157 @@
+# = 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
+