facets 2.8.4 → 2.9.0.pre.1

data/lib/more/facets/linkedlist.rb

@@ -1,195 +0,0 @@
-# LinkedList
-#
-# Copyright (C) 2006 Kirk Haines <khaines@enigo.com>.
-#
-# 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 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.
-#
-# LinkedList was ported from the original in Kirk Hanes IOWA web framework.
-#
-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/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
-

data/lib/more/facets/memoize.rb

@@ -1 +0,0 @@
-require 'facets/once'

data/lib/more/facets/memoizer.rb

@@ -1,64 +0,0 @@
-# Memoizer
-#
-# Copyright (c) 2006 Erik Veenstra
-#
-# See http://javathink.blogspot.com/2008/09/what-is-memoizer-and-why-should-you.html
-
-# Memoizer wraps objects to provide cached method calls.
-#
-#   class X
-#     def initialize ; @tick = 0 ; end
-#     def tick; @tick + 1; end
-#     def memo; @memo ||= Memoizer.new(self) ; end
-#   end
-#
-#   x = X.new
-#   x.tick       #=> 1
-#   x.memo.tick  #=> 2
-#   x.tick       #=> 3
-#   x.memo.tick  #=> 2
-#   x.tick       #=> 4
-#   x.memo.tick  #=> 2
-#
-# You can also use to cache collections of objects to gain code speed ups.
-#
-#   points = points.collect{|point| Memoizer.cache(point)}
-#
-# After our algorithm has finished using points, we want to get rid of
-# these Memoizer objects. That's easy:
-#
-#    points = points.collect{|point| point.__self__ }
-#
-# Or if you prefer (it is ever so slightly safer):
-#
-#    points = points.collect{|point| Memoizer.uncache(point)}
-#
-class Memoizer
-
-  #private :class, :clone, :display, :type, :method, :to_a, :to_s
-  private *instance_methods(true).select{ |m| m.to_s !~ /^__/ }
-
-  def initialize(object)
-    @self  = object
-    @cache = {}
-  end
-
-  def __self__ ; @self ; end
-
-  # Not thread-safe! Speed is important in caches... ;]
-  def method_missing(method_name, *args, &block)
-    @cache[[method_name, args, block]] ||= @self.__send__(method_name, *args, &block)
-  end
-
-  #def self; @self; end
-
-  def self.cache(object)
-    new(object)
-  end
-
-  def self.uncache(cached_object)
-    cached_object.instance_variable_get('@self')
-  end
-
-end
-

data/lib/more/facets/methodspace.rb

@@ -1,146 +0,0 @@
-# = Method Namespaces
-#
-# Create method namespaces, allowing for method
-# chains but still accessing the object's instance.
-#
-# == Todo
-#
-# * May need to cahnge name, to avoid conflict with Rake's method by the same name.
-# * Maybe can become part of core once name is changed.
-#
-# == Authors
-#
-# * Thomas Sawyer
-# * Pit Captain
-#
-# == Copying
-#
-# Copyright (c) 2006 Thomas Sawyer, Pit Captain
-#
-# 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.
-
-require 'facets/functor'
-require 'facets/module' # for Module#basename
-
-class Module
-
-  # Define a simple method namespace.
-  #
-  #   class A
-  #     attr_writer :x
-  #     method_space :inside do
-  #       def x; @x; end
-  #     end
-  #   end
-  #
-  #   a = A.new
-  #   a.x = 10
-  #   a.inside.x #=> 10
-  #   a.x  # no method error
-
-  def method_space(name, mod=nil, &blk)
-
-    # If block is given then create a module, otherwise
-    # get the name of the module.
-    if block_given?
-      name = name.to_s
-      raise ArgumentError if mod
-      mod  = Module.new(&blk)
-    else
-      if Module === name
-        mod = name
-        name = mod.basename.downcase
-      end
-      mod  = mod.dup
-    end
-
-    # Include the module. This is neccessary, otherwise
-    # Ruby won't let us bind the instance methods.
-    include mod
-
-    # Save the instance methods of the module and
-    # replace them with a "transparent" version.
-    methods = {}
-    mod.instance_methods(false).each do |m|
-      methods[m.to_sym] = mod.instance_method(m)
-      mod.module_eval %{
-        def #{m}(*a,&b)
-          super(*a,&b)
-        end
-      }
-      #mod.instance_eval do
-        #define_method(m)
-        #  super
-        #end
-      #end
-    end
-
-    # Add a method for the namespace that delegates
-    # via the Functor to the saved instance methods.
-    define_method(name) do
-      mtab = methods
-      Functor.new do |op, *args|
-        mtab[op].bind(self).call(*args)
-      end
-    end
-  end
-
-  # Include a module via a specified space.
-  #
-  #   module T
-  #     def t ; "HERE" ; end
-  #   end
-  #
-  #   class X
-  #     include_as :test => T
-  #     def t ; test.t ; end
-  #   end
-  #
-  #   X.new.t  #=> "HERE"
-  #
-  def include_as(h)
-    h.each{ |name, mod| method_space(name, mod) }
-  end
-
-end
-
-
-
-
-# demonstration
-
-=begin demo
-
-  module T
-    def t ; p self ; end
-    def r ; p self ; end
-    def q ; super ; end
-  end
-
-  class N
-    def q ; puts "ho" ; end
-  end
-
-  class X < N
-    include_as :test => T
-
-    def n ; p test ; end
-    def m ; test.t ; end
-    def o ; test.r ; end
-  end
-
-  x = X.new
-  x.n
-  x.m
-  x.o
-  x.q
-
-=end
-