facets 1.2.1 → 1.3.0

data/lib/facets/more/methodprobe.rb

@@ -41,7 +41,7 @@
 # but might prove a better means in the future.
 #
 # This script is provided for experimetnal purposes. Please inform the author
-# if you find ways to improve it or put to an interesting use.
+# if you find ways to improve it or put it to an interesting use.
 #
 # == Synopsis
 #

data/lib/facets/more/multiton.rb

@@ -44,18 +44,22 @@
 #   end
 #
 #   a = SomeMultitonClass.new(4)
-#   b = SomeMultitonClass.new(4)	 # a and b are same object
+#   b = SomeMultitonClass.new(4)   # a and b are same object
 #   c = SomeMultitonClass.new(2)   # c is a different object
 #
 # == Previous Behavior
 #
-# In previous versions of Multion the #new method was made 
+# In previous versions of Multion the #new method was made
 # private and #instance was used in its stay --just like Singleton.
-# But this has proved less desirable for Multiton b/c a Multion can
-# have multiple instances not just one. So instead we define #create
-# as a private alias of the original #new method (should it be needed)
-# and then #new is overridden with #instance as an alias for it.
-# So if you must have exact old behavior all you need do is re-alias
+# But this has proved less desirable for Multiton since Multitions can
+# have multiple instances, not just one.
+#
+# So instead Multiton now defines #create as a private alias of
+# the original #new method (jus tin case it is needed) and then
+# defines #new to handle the multion, and #instance is provided
+# as an alias for it.
+#
+# So if you must have the old behavior, all you need do is re-alias
 # #new to #create and privatize it.
 #
 #   class SomeMultitonClass
@@ -65,6 +69,8 @@
 #     ...
 #   end
 #
+# Then only #instance will be available for creating the Multiton.
+#
 # == How It Works
 #
 # A pool of objects is searched for a previously cached object,
@@ -136,6 +142,7 @@ module Multiton
 
 end
 
+#--
 # Deprecated use, now use #private_multiton method after including Multiton
 #
 #  module MultitonInstance
@@ -159,8 +166,9 @@ end
 #       return obj
 #     end
 #   end
-# 
+#
 # end
+#++
 
 
 #  _____         _

data/lib/facets/more/nilcomparable.rb

@@ -49,7 +49,7 @@
 #   end
 #  
 # To do so for a pre-existing class with a pre-existing #<=> method, you'll 
-# need to obveride the method. As an example let's make Numeric comparable to nil.
+# need to overide the method. As an example let's make Numeric comparable to nil.
 #
 #   class Numeric
 #
@@ -101,53 +101,31 @@ class NilClass
 end
 
 
-# DEPRECATED
-#
-# module NilComparable
-# 
-#   def self.included( mod )
-# 
-#     mod.class_eval %{
-# 
-#       if method_defined?( :<=> )
-#         alias_method :compare_without_nil, :<=>
-#       else
-#         def compare_without_nil( other )
-#           raise TypeError, "Cannot compare \#{self.inspect} to \#{other.inspect}"
-#         end
-#       end
-# 
-#       def <=>( other )
-#         return 1 if other.nil?
-#         compare_without_nil( other )
-#       end
-# 
-#     }
-# 
-#   end
-# 
-# end
-
-# DEPRECATED
-#
-# # Calling this method for a given class allows instances
-# # of a class to be compared to nil using <=>.
-# # Adapted from code by Paul Brannan (Ruby License)
-# def nil_comparable(klass=self)
-#   klass.class_eval %{
-#     if method_defined?( :<=> )
-#       alias_method :compare_without_nil, :<=>
-#     else
-#       def compare_without_nil( other )
-#         raise TypeError, "Cannot compare \#{self.inspect} to \#{other.inspect}"
-#       end
-#     end
-#     def <=>( other )
-#       return 1 if other.nil?
-#       compare_without_nil( other )
-#     end
-#   }
-# end
+
+=begin DEPRECATED
+
+module NilComparable
+ 
+  def self.included( mod )
+    mod.class_eval %{
+      if method_defined?( :<=> )
+        alias_method :compare_without_nil, :<=>
+      else
+        def compare_without_nil( other )
+          raise TypeError, "Cannot compare \#{self.inspect} to \#{other.inspect}"
+        end
+      end
+
+      def <=>( other )
+        return 1 if other.nil?
+        compare_without_nil( other )
+      end
+    }
+  end
+
+end
+
+=end
 
 
 
@@ -163,7 +141,11 @@ end
   require 'test/unit'
 
   class Mock < String
-    include NilComparable
+    alias_method :compare_without_nil, :<=>
+    def <=>( other )
+      return 1 if other.nil?
+      compare_without_nil( other )
+    end
   end
 
   class TC_NilClass_Comparable < Test::Unit::TestCase

data/lib/facets/more/openobject.rb

@@ -36,10 +36,12 @@
 # advantage in benchmark tests.
 #
 #--
-# Thrid, when an entry is not found 'null' is returned rather then 'nil'.
+#
+# Third, when an entry is not found 'null' is returned rather then 'nil'.
 # This allows for run-on entries withuot error. Eg.
 #
 #   OpenObject.new.a.b.c  #=> null
+#
 #++
 #
 # == Author(s)
@@ -48,6 +50,7 @@
 # * Thomas Sawyer
 #
 
+require 'facets/core/hash/keys_to_sym'
 require 'facets/more/basicobject'
 #require 'facets/more/nullclass'
 
@@ -56,15 +59,15 @@ class OpenObject < BasicObject
   def initialize( init=nil )
     case init
     when Array
-      @table = Hash[*init]
+      @table = Hash[*init].keys_to_sym
     when Hash
-      @table = init.dup
+      @table = init.keys_to_sym
     when NilClass
       @table = {}
     when OpenObject
       @table = init.__table__.dup
     else
-      @table = init.to_h.dup
+      @table = init.to_h.keys_to_sym
     end
   end
 
@@ -108,11 +111,14 @@ class OpenObject < BasicObject
       @table[name] = args[0]
       self
     else
-      #if @table.key?(name)
+      if @table.key?(name)
         @table[name]
-      #else
-      #  Kernel.null #@table[name] = instance.class.new
-      #end
+      elsif @parent
+        @parent.__send__(name)
+      else
+        nil
+        #  Kernel.null #@table[name] = instance.class.new
+      end
     end
   end
 
@@ -134,18 +140,23 @@ class OpenObject < BasicObject
     @table.each( &yld )
   end
 
+  # shadow methods
+
   def __table__ ; @table ; end
 
+  def __parent__ ; @parent ; end
+  def __parent__=(x) ; @parent = x ; end
+
   #def __get__(k) ; @table.key?(k.to_sym) ? @table[k.to_sym] : null ; end
   def __get__(k) ; @table[k.to_sym] ; end
   def __set__(k) ; @table[k.to_sym]=v ; end
 
-  def __key__?(key) ; @table.key?(key) ; end
+  def __key__?(k) ; @table.key?(k.to_sym) ; end
   def __keys__ ; @table.keys ; end
 
   def __update__( other )
     other = Hash[*other] if other.is_a?(Array)
-    other.each{ |k, v| @table[k] = v }
+    other.each{ |k, v| @table[k.to_sym] = v }
   end
 
   def __merge__( other )
@@ -158,6 +169,35 @@ end
 
 
 
+class CascadingOpenObject < OpenObject
+
+  def method_missing( sym, *args )
+    type = sym.to_s[-1,1]
+    name = sym.to_s.gsub(/[=!?]$/, '').to_sym
+    if type == '='
+      @table[name] = args[0]
+    elsif type == '!' and args.size > 0
+      @table[name] = args[0]
+      self
+    else
+      if @table.key?(name)
+        if Hash === @table[name]
+          self.__class__.new( @table[name] )
+        else
+          @table[name]
+        end
+      elsif @parent
+        @parent.__send__(name)
+      else
+        nil
+        #  Kernel.null #@table[name] = instance.class.new
+      end
+    end
+  end
+
+end
+
+
 #  _____         _
 # |_   _|__  ___| |_
 #   | |/ _ \/ __| __|

data/lib/facets/more/recorder.rb

@@ -0,0 +1,125 @@
+#--
+# Multiton
+#
+# Copyright (c) 2005 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.
+#
+#
+# ==========================================================================
+# Revision History ::
+# --------------------------------------------------------------------------
+#  2006-04-04   trans    * Created
+# ==========================================================================
+#++
+
+require 'facets/more/basicobject'
+
+#:title: Recorder
+#
+# Recorder is similar essentially a method probe. It records everthing
+# that happens to it, building an internal parse tree. You can then
+# pass a substitute object and apply the recoding to it. Or you can
+# utilize the parse tree.
+#
+# The only limitation of Recorder is with special operators, like if, &&, ||, etc.
+# Since they are not true methods they can't be recorded. (Too bad for Ruby.)
+#
+# == Synopsis
+#
+#   class Z
+#     def name ; 'George' ; end
+#     def age ; 12 ; end
+#   end
+#
+#   z = Z.new
+#
+#   r = Recorder.new
+#   q = proc { |x| (x.name == 'George') & (x.age > 10) }
+#   x = q[r]
+#   x.__call__(z)
+#
+# produces
+#
+#   true
+#
+# == Author(s)
+#
+# * Thomas Sawyer
+#
+
+class Recorder < BasicObject
+
+  def initialize( msg=nil )
+    @msg = msg
+  end
+
+  def inspect
+    "<Recorder #{@msg.inspect}>"
+  end
+
+  def __call__( orig )
+    return orig unless @msg
+
+    sym  = @msg[0]
+    args = @msg[1..-1].collect do |a|
+      Recorder === a ? a.__call__(orig) : a
+    end
+    obj  = args.shift
+
+    obj.__send__( sym, *args )
+  end
+
+  def method_missing( sym, *args, &blk )
+    self.__class__.new( [ sym, self, *args ] )
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin test
+
+  require 'test/unit'
+
+  #class Object
+  #  def &(o)
+  #    self && o
+  #  end
+  #end
+
+  class TCRecorder < Test::Unit::TestCase
+
+    class Z
+      def name ; 'George' ; end
+      def age ; 12 ; end
+    end
+
+    def setup
+      @z = Z.new
+    end
+
+    def test_001
+      r = Recorder.new
+      q = proc { |x| (x.name == 'George') & (x.age > 10) }
+      x = q[r]
+      assert( x.__call__(@z) )
+    end
+
+  end
+
+=end

data/lib/facets/more/rtals.rb

@@ -1,14 +1,209 @@
-warn 'ALPHAWARE! rtals.rb is still under development.'
+#--
+# RubyTals
+# 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.
+#++
 
-require 'rexml'
+require 'rexml/document'
+
+# RubyTals
+#
+# RubyTals is a Ruby variation on Zope Page Templates and it's TAL specification.
+# It differs from TAL in that it is specifically geared for use by Ruby.
+#
+# == Usage
+#
+#   s = %q{
+#     <html>
+#     <body>
+#       <h1 rtal:content="x">[X]</h1>
+#       <div rtal:each="animal" rtal:do="a">
+#         <b rtal:content="a">[ANIMAL]</b>
+#       </div>
+#       <div rtal:if="animal.size > 1">
+#         There are <b rtal:body="animal.size">[ANIMAL SIZE]</b> animals.
+#       </div>
+#     </body>
+#     </html>
+#   }
+#
+#   x = 'Our Little Zoo'
+#   animal = ['Zebra', 'Monkey', 'Tiger' ]
+#   out = ''
+#
+#   prg = RubyTals.compile( s )
+#   puts eval(prg)
+#
+#
+# == Note
+#
+# WARNING! This library is only minimally functional at this point.
+# If you would like to use it please consider improving upon it!
+#
+# Presently rTAL clauses can run arbitraty Ruby code. Although
+# upping the safety level before executing a compiled template
+# should be sufficiently protective in most cases, perhaps it would
+# be better to limit valid expressions to single object references,
+# ie. 'this.that', and then use a substitution of '.' for '/'.
+# Not only would this be highly protective, it would also be more
+# compatible with the original TAL spec; albiet this isn't exacty
+# how TALs interprets the '/' divider.
+#
+# On the other hand perhaps it is too much restraint. For instance
+# it would require the if-clause in the above exmaple to be
+# something like:
+#
+#       <div rtal:if="animal/plenty">
+#
+# and have a definition in the evaluateing code:
+#
+#   def animal.plenty
+#     size > 1
+#   end
+#
+# It's a classic Saftey vs. Usability trade-off.
+# And something to consider for the future.
+#
+# == Author(s)
+#
+# * Thomas Sawyer
+#
 
 module RubyTals
 
-  def parse( xmlstr )
+  def self.compile( xmlstr )
+    rxml = REXML::Document.new( xmlstr.strip )
+    parse( rxml )
+  end
+
+  #def self.evaluate( xomp, out='' )
+  #  eval xomp
+  #end
+
+  def self.parse( xml )
+    building = ''
+    body = []
+
+    xml.each do |elem|
+      #p elem.class
+
+      tag, mode = [], nil
+      case elem
+      when REXML::Element
+
+        attributes, ruby_attributes = {}, {}
+        elem.attributes.each { |k, v|
+          if k =~ /^ruby:/i
+            ruby_attributes[k.sub(/^rtal:/i,'')] = v
+          else
+            attributes[k] = v
+          end
+        }
+
+        if ruby_attributes.empty?
+          tag = add_tag( elem.name, parse( elem ), attributes )
+
+        else
+          if bd = ruby_attributes["content"]
+            tag << "out << #{bd}.to_s"
+          elsif bd = ruby_attributes["replace"]
+            tag << "out << #{bd}.to_s"
+            mode = :replace
+          else
+            tag << parse( elem )
+          end
+
+          if cond = ( ruby_attributes["if"] || ruby_attributes["condition"] )
+            #mode = :replace
+            tag = ([ "if #{cond}" ].concat( tag ) << "end")
+          end
+
+          if enum = ( ruby_attributes["each"] || ruby_attributes["repeat"] )
+            loopf = "#{enum}.each do"
+            if d = ruby_attributes["do"]
+              loopf << " |#{d}|"
+            end
+            tag = ([ loopf ].concat( tag ) << "end")
+          end
+
+          unless mode == :replace  #unless attributes.empty? #
+            tag = add_tag( elem.name, tag, attributes )
+          end
+
+        end
+
+      else
+        tag << "out << #{elem.to_s.inspect}"
 
-    rxml = REXML::load( xmlstr )
+      end
 
+      body.concat tag
+    end
+
+    building << body.flatten.join("\n")
+    return building
+  end
+
+  def self.add_tag( name, body, attributes={} )
+    b = []
+    if attributes.empty?
+      b << "out << '<#{name}>'"
+      b << body
+      b << "out << '</#{name}>'"
+    else
+      s = ''
+      s << "out << '<#{name} "
+      s << attributes.collect { |k,v| %{#{k}="#{v}"} }.join(' ')
+      s << ">'"
+      b << s
+      b << body
+      b << "out << '</#{name}>'"
+    end
+    b
+  end
+
+  def self.loop_structure
 
   end
 
 end
+
+
+
+
+=begin
+
+s = %q{
+  <html>
+  <body>
+    <test>This is a test.</test>
+    <h1 rtal:content="x">[X]</h1>
+    <div rtal:each="animal" rtal:do="a">
+      <b rtal:content="a">[ANIMAL]</b>
+    </div>
+    <div rtal:if="animal.size >= 1">
+      <b rtal:body="animal.size">[ANIMAL SIZE]</b>
+    </div>
+  </body>
+  </html>
+}
+
+x = '10'  # problem with numbers
+animal = ['Zebra', 'Monkey', 'Tiger' ]
+out = ''
+
+prg = RubyTals.compile( s )
+puts
+puts prg
+puts
+puts eval(prg)
+
+=end