facets 2.7.0 → 2.8.0

data/lib/more/facets/matcher.rb

@@ -0,0 +1,140 @@
+#= 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/memoizer.rb

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

@@ -70,11 +70,16 @@ class Module
     methods = {}
     mod.instance_methods(false).each do |m|
       methods[m.to_sym] = mod.instance_method(m)
-      mod.instance_eval do
-        define_method(m) do
-          super
+      mod.module_eval %{
+        def #{m}(*a,&b)
+          super(*a,&b)
         end
-      end
+      }
+      #mod.instance_eval do
+        #define_method(m)
+        #  super
+        #end
+      #end
     end
 
     # Add a method for the namespace that delegates

data/lib/more/facets/module/class_extend.rb

@@ -1,122 +1,3 @@
-# = Class Extension
-#
-# Normally when including modules, class/module methods are not
-# extended. To achieve this behavior requires some clever
-# Ruby Karate. Instead class_extension provides an easy to use
-# and clean solution. Simply place the extending class methods
-# in a block of the special module method #class_extension.
-#
-#   module Mix
-#     def inst_meth
-#       puts 'inst_meth'
-#     end
-#
-#     class_extend do
-#       def class_meth
-#         "Class Method!"
-#       end
-#     end
-#   end
-#
-#   class X
-#     include Mix
-#   end
-#
-#   X.class_meth  #=> "Class Method!"
-#
-# == History
-#
-# Thanks to Trans, Nobu and Ulysses for their original on this concept.
-#
-# == Authors
-#
-# * Daniel Schierbeck
-# * Thomas Sawyer
-# * Nobu Nakada
-# * Ulysses
-#
-# == Copying
-#
-# Copyright (c) 2006 Daniel Schierbeck
-#
-# 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.
-
-#
-class Module
-
-  alias_method :append_features_without_class_extension, :append_features
-
-  # Normally when including modules, class/module methods are not
-  # extended. To achieve this behavior requires some clever
-  # Ruby Karate. Instead class_extension provides an easy to use
-  # and clean solution. Simply place the extending class methods
-  # in a block of the special module method #class_extension.
-  #
-  #   module Mix
-  #     def inst_meth
-  #       puts 'inst_meth'
-  #     end
-  #
-  #     class_extend do
-  #       def class_meth
-  #         "Class Method!"
-  #       end
-  #     end
-  #   end
-  #
-  #   class X
-  #     include Mix
-  #   end
-  #
-  #   X.class_meth  #=> "Class Method!"
-  #
-  # NOTE: This old #class_extension version of this method
-  # did not extend the containing class automatically --it had
-  # to be done by hand. With #class_extend, that is no longer
-  # the case.
-  #
-  def class_extend(*mods, &block)
-    @class_extension ||= Module.new do
-      def self.append_features(mod)
-        append_features_without_class_extension(mod)
-      end
-    end
-    @class_extension.__send__(:include, *mods)
-    @class_extension.module_eval(&block) if block_given?
-    extend(@class_extension)  # extend this module too
-    @class_extension
-  end
-
-  # TODO: DEPRECATE
-  alias_method :class_extension, :class_extend
-
-  #private :class_extend
-
-  # Override +append_features+ to handle class-inheritable extensions.
-  def append_features(mod)
-    append_features_without_class_extension(mod)
-    mod.extend(class_extend)
-    if mod.instance_of? Module
-      mod.__send__(:class_extend).__send__(:include, class_extend)
-    end
-  end
-
-end
-
-class Class
-  # For Class, #class_extend is the same as class_eval.
-  # The alternative is to "undef_method :class_extend",
-  # but this seems uneccessarily limited.
-  #
-  def class_extend(&blk)
-    class_eval(&blk)
-  end
-end
+warn "use 'facets/class_extend' for future versions"
+require 'facets/class_extend'
 

data/lib/more/facets/ostruct.rb

@@ -34,13 +34,13 @@ class OpenStruct
   #     o.name    = 'John Smith'
   #     o.gender  = :M
   #     o.age     = 71
-  #   end 
+  #   end
   #
   # You can still provide a hash for initialization purposes, and even combine
   # the two approaches if you wish.
   #
   #   person = OpenStruct.new(:name => 'John Smith', :age => 31) do |p|
-  #     p.gender = :M 
+  #     p.gender = :M
   #   end
   #
   # Alternatively you can provide a default block:
@@ -201,13 +201,6 @@ class Hash
     OpenStruct.new(self)
   end
 
-  # CREDIT Alison Rowland, Jamie Macey, Mat Schaffer
-
-  #--
-  # Special thanks to Alison Rowland, Jamie Macey and Mat Schaffer
-  # for inspiring recursive improvements.
-  #++
-
   # Like to_ostruct but recusively objectifies all hash elements as well.
   #
   #     o = { 'a' => { 'b' => 1 } }.to_ostruct_recurse
@@ -223,6 +216,8 @@ class Hash
   #     o = h.to_ostruct_recurse( { h['a'] => h['a'] } )
   #     o.a['b']  #=> 1
   #
+  # CREDIT: Alison Rowland, Jamie Macey, Mat Schaffer
+
   def to_ostruct_recurse(exclude={})
     return exclude[self] if exclude.key?( self )
     o = exclude[self] = OpenStruct.new
@@ -233,5 +228,10 @@ class Hash
     o.__update__(h)
   end
 
+  #--
+  # Special thanks to Alison Rowland, Jamie Macey and Mat Schaffer
+  # for inspiring recursive improvements.
+  #++
+
 end
 

data/lib/more/facets/pathlist.rb

@@ -89,16 +89,8 @@ $:.find_ext = 'rb'
 # Doesn't work
 #ENV['PATH'] = PathList.new(ENV['PATH'])
 
-#++
 
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin #testing
+=begin test
 
   require 'test/unit'
 

data/lib/more/facets/pathname.rb

@@ -129,7 +129,7 @@ class Pathname
     flags = 0
     opts.each do |opt|
       case opt when Symbol, String
-        flags += File.const_get("FNM_#{opt}".upcase)
+        flags += ::File.const_get("FNM_#{opt}".upcase)
       else
         flags += opt
       end
@@ -156,10 +156,17 @@ class Pathname
     Dir.glob(::File.join(self.to_s, '*')).empty?
   end
 
-end
+  #
+  def uptodate?(*sources)
+    ::FileUtils.uptodate?(to_s, sources.flatten)
+  end
 
-# Constant alias of Pathname (short is better!)
-Path = Pathname
+  #
+  def outofdate?(*sources)
+    ::FileUtils.outofdate?(to_s, sources.flatten)
+  end
+
+end
 
 class NilClass
   # Provide platform dependent null path.