facets 1.7.46 → 1.8.0

data/lib/facets/more/consoleutils.rb

@@ -0,0 +1,45 @@
+# = consoleutils.rb
+
+module ConsoleUtils
+
+  module_function
+
+  # Convenient method to get simple console reply.
+
+  def ask( question, answers=nil )
+    print "#{question}"
+    print " [#{answers}] " if answers
+    until inp = $stdin.gets[0,1] ; sleep 1 ; end ; puts
+    inp
+  end
+
+  # Convenience method for puts. Use this instead of
+  # puts when the output should be supressed if the
+  # global $QUIET option is set.
+
+  def say( statement )
+    puts statement unless $QUIET
+  end
+  alias :tell :say  # TODO deprecate
+
+  #
+
+  def password(forwhat=nil)
+    if forwhat
+      ask("password for #{forwhat}: ")
+    else
+      ask("password: ")
+    end
+  end
+
+  #
+
+  def password_cached(forwhat=nil)
+    if forwhat
+      @password ||= ask("password for #{forwhat}: ")
+    else
+      @password ||= ask("password: ")
+    end
+  end
+
+end

data/lib/facets/more/cookie.rb

@@ -27,8 +27,10 @@
 #
 # == Develop Notes
 #
-#   TODO Perhaps move to HTTP containter.
+# TODO Perhaps move to HTTP containter.
 #
+# NOTE Fixed domain_match bug (assuming it's correct). The adjustment
+# was borrowed from the Rubyforge class (see Ratchets).
 
 # Author::    TAKAHASHI `Maki' Masayoshi
 # Copyright:: Copyright (c) 2004 TAKAHASHI `Maki' Masayoshi
@@ -68,7 +70,8 @@ class Web
       when '.'
         return true
       when /^\./
-        return tail_match?(domain, host)
+        #return tail_match?(domain, host)
+        return tail_match?(host, domain)  # CORRECT?
       else
         return (host == domain)
       end

data/lib/facets/more/dependency.rb

@@ -0,0 +1,199 @@
+# = dependency.rb
+#
+# == Copyright (c) 2006 Thomas Sawyer
+#
+#   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.
+#
+# == Author(s)
+#
+# * Thomas Sawyer
+#
+# == Developers Notes
+#
+# NOTE The #included call back does a comparison to Object.
+# This is a bit of a hack b/c there is actually no way to
+# check if it is the toplevel --a flaw w/ Ruby's toplevel proxy.
+#
+# TODO Need to be more flexible with passing arguments to
+# dependency methods.
+
+# Author::    Thomas Sawyer
+# Copyright:: Copyright (c) 2006 Thomas Sawyer
+# License::   Ruby License
+
+require 'facets/core/hash/to_h.rb'
+
+$toplevel = self
+
+# = MethodDependency
+#
+# This module is included in Object and allows methods to be given prerequisite
+# dependencies, i.e. methods that must be run before they are.
+#
+# A dependency will only ever be run once per method call.
+#
+# == Synopis
+#
+#   include MethodDependency
+#
+#   def one; @str << '1'; end
+#   def two; @str << '2'; end
+#
+#   def show; @str ; end
+#
+#   depend :show => [ :x, :y ]
+#
+#   show  #=> '12'
+#
+# You can add this functionality to the whole system
+# by simply including it at the toplevel.
+
+class Module
+
+  #def self.included( base )
+  #  if base == Object #$toplevel
+  #    require 'facets/more/main_as_module.rb'
+  #  end
+  #end
+
+  #
+
+  def depend( name_and_deps=nil )
+    if Hash === name_and_deps
+      name_and_deps.to_h.each do |name, deps|
+        deps = [deps].flatten
+        define_dependency(name, *deps)
+      end
+    elsif name_and_deps
+      @dependency ||= {}
+      @dependency[name_and_deps.to_sym]
+    else
+      @dependency ||= {}
+    end
+  end
+
+  # Compile list of all unique prerequisite calls.
+
+  def dependencies(name, build=[])
+    @dependency ||= {}
+    deps = @dependency[name.to_sym]
+    return build unless deps
+    deps.each do |dep|
+      build.unshift(dep)
+      dependencies(dep,build)
+    end
+    build.uniq!
+    build
+  end
+
+  #
+
+  def define_dependency( name, *deps )
+    @dependency ||= {}
+    if @dependency[name.to_sym]
+      @dependency[name.to_sym] = deps
+    else
+      @dependency[name.to_sym] = deps
+      deplist = lambda{ dependencies(name) }
+      alias_method("#{name}:execute",name)
+      define_method(name) do |*a|
+        # run dependencies
+        deplist.call.each do |d|
+          if respond_to?("#{d}:execute")
+            send("#{d}:execute",*a) #,&b)
+          else
+            send(d,*a) #,&b)
+          end
+        end
+        # run core method
+        send("#{name}:execute",*a) #,&b)
+      end
+    end
+  end
+
+end
+
+class RecursiveDependency < StandardError; end
+
+
+#class Module
+#  include MethodDependency
+#end
+
+
+=begin test
+
+  #require 'test/unit'
+
+  class DependableTest1 < Test::Unit::TestCase
+
+    class C
+      #extend MethodDependency
+
+      attr :s
+      def initialize
+        @s = ''
+      end
+
+      def x ; @s << 'x'; end
+      def y ; @s << 'y'; end
+      def z ; @s << 'z'; end
+
+      depend :x => :y
+      depend :z => [:x, :y]
+    end
+
+    module M
+      #extend MethodDependency
+
+      attr :s
+      def initialize
+        @s = ''
+      end
+
+      def x ; @s << 'x'; end
+      def y ; @s << 'y'; end
+      def z ; @s << 'z'; end
+
+      depend :x => :y
+      depend :z => [:x, :y]
+    end
+
+    class D
+      include M
+    end
+
+    def test_01
+      c = C.new
+      c.x
+      assert_equal( 'yx', c.s )
+    end
+
+    def test_02
+      c = C.new
+      c.z
+      assert_equal( 'yxz', c.s )
+    end
+
+    def test_03
+      c = D.new
+      c.x
+      assert_equal( 'yx', c.s )
+    end
+
+    def test_04
+      c = D.new
+      c.z
+      assert_equal( 'yxz', c.s )
+    end
+
+  end
+
+=end

data/lib/facets/more/dictionary.rb

@@ -84,7 +84,9 @@ class Dictionary < Hash
       elsif (args.size % 2) != 0
         raise ArgumentError, "odd number of elements for Hash"
       else
-        hsh[args.shift] = args.shift while args.size > 0
+        while !args.empty?
+          hsh[args.shift] = args.shift
+        end
       end
       hsh
     end
@@ -205,26 +207,44 @@ class Dictionary < Hash
     @order
   end
 
-  def store_only( a,b )
-    store( a,b )
-  end
+  #def store_only( a,b )
+  #  store( a,b )
+  #end
+  #alias_method :store_only, :store
 
   alias_method :orig_store, :store
   protected :orig_store
 
   def insert( i,k,v )
-    @order.insert( i,k )
-    orig_store( k,v )
+    @order.insert(i,k)
+    orig_store(k,v)
   end
 
-  alias_method :unordered_store, :store
-  private :unordered_store
+  #alias_method :unordered_store, :store
+  #private :unordered_store
 
   def store( a,b )
     @order.push( a ) unless has_key? a
     super( a,b )
   end
-  alias []= store
+
+  # Store operator.
+  #
+  #   h[key] = value
+  #
+  # Or with additional index.
+  #
+  #  h[key,index] = value
+
+  def []=(k, i=nil, v=nil)
+    if v
+      insert(i,k,v)
+    else
+      store(k,i)
+    end
+  end
+
+  #
 
   def ==( hsh2 )
     return false if @order != hsh2.order
@@ -355,7 +375,7 @@ class Dictionary < Hash
   end
   alias :merge! update
 
-  def merge hsh2
+  def merge( hsh2 )
     self.dup.update(hsh2)
   end
 
@@ -365,6 +385,14 @@ class Dictionary < Hash
     ary
   end
 
+  def first
+    self[order.first]
+  end
+
+  def last
+    self[order.last]
+  end
+
 end
 
 
@@ -382,7 +410,7 @@ end
   class TC_Dictionary < Test::Unit::TestCase
 
     def test_create
-      hsh = Dictionary['z', 1, 'a', 2, 'c', 3] 
+      hsh = Dictionary['z', 1, 'a', 2, 'c', 3]
       assert_equal( ['z','a','c'], hsh.keys )
     end
 
@@ -456,6 +484,16 @@ end
       assert_equal( ['c','b','a'], h1.keys )
     end
 
+    def test_op_store
+      h1 = Dictionary[]
+      h1[:a] = 1
+      h1[:c] = 3
+      assert_equal( [1,3], h1.values )
+      h1[:b,1] = 2
+      assert_equal( [1,2,3], h1.values )
+      assert_equal( [:a,:b,:c], h1.keys )
+    end
+
   end
 
 =end

data/lib/facets/more/functor.rb

@@ -11,16 +11,24 @@
 #   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 #   FOR A PARTICULAR PURPOSE.
 #
+# == Developer Notes
+#
+# TODO Consider renaming Functor to Dispatch or Dispatcher, or Func ?
+#
 # == Author(s)
 #
 # * Thomas Sawyer
 
+# LOG 2006-11-04 trans Made Functor a subclass of Proc rather then use delgation.
+# LOG 2006-11-04 trans Deprecated #self. Call #self on the #binding instead.
+# LOG 2006-11-04 trans Deprecated #functor_function since there's no delegate anymore.
+# LOG 2006-11-04 trans Deprecated #functor_passthru, renamed to #passing.
+# LOG 2006-11-04 trans All methods are now private except #binding and operators.
+
 # Author::    Thomas Sawyer
 # Copyright:: Copyright (c) 2006 Thomas Sawyer
 # License::   Ruby License
 
-require 'facets/core/kernel/as'
-require 'facets/core/kernel/object_class'
 require 'facets/core/binding/self'
 
 # = Functor
@@ -41,46 +49,44 @@ require 'facets/core/binding/self'
 #   f * 3  #=> 9
 #
 
-class Functor
+class Functor < Proc
 
-  # Privatize a few Kernel methods that are most likely to clash,
-  # but arn't essential here.
+  # Privatize all methods except #binding an operators.
 
-  private :class, :clone, :display, :type, :method, :to_a, :to_s
+  private *instance_methods.select { |m| m !~ /(^__|^\W|^binding$)/ }
 
-  # Functor is created with a block whose first argument is always
-  # the operator-method the functor will recieve. You can pass thru
-  # additional arguments along with the operator.
+  # Functor is created with a block the first argument of which is always
+  # the operator/method the functor will recieve. You can pass thru
+  # additional arguments along with the function that will be passed
+  # to the function as the initial parameters after the operator.
 
-  def initialize(*passthru, &function)
-    @self     = function.binding.self
-    @passthru = passthru
-    @function = function
+  def initialize(*arguments, &function)
+    @arguments = arguments
+    super(&function)
   end
 
   # Any acton against the functor is processesd by the function.
 
   def method_missing(op, *args, &blk)
-    if block_given?
-      @function.call(op, *(@passthru + args), &blk)
-    else
-      @function.call(op, *(@passthru + args))
-    end
+    call(op, *(@arguments + args), &blk)
   end
 
-  # Returns the binding context in which the Functor was defined.
-
-  def self; @self; end
+  # Returns the arguments passing through the initializer.
 
-  # Returns the Proc passed to the initializer.
+  def throughput ; @arguments ; end
 
-  def functor_function ; @function ; end
-
-  # Returns the passthru objects passed to the initializer.
+end
 
-  def functor_passthru ; @passthru ; end
 
-end
+#--
+#module Kernel
+#
+#  def dispatch( *targets, &dispatch )
+#    Dispatch.new( *targets, &dispatch )
+#  end
+#
+#end
+#++