facets 1.3.3 → 1.4.0

data/lib/facets/more/one.rb

@@ -1,25 +1,31 @@
-#--
-# One
+# = one.rb
 #
-# Copyright (c) 2005 Thmas Sawyer
+# == Copyright (c) 2005 Thomas Sawyer
 #
-# Ruby License
+#   Ruby License
 #
-# This module is free software. You may use, modify, and/or redistribute this
-# software under the same terms as Ruby.
+#   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.
+#   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.
 #
-#================================================================================
-# ChangeLog
-#================================================================================
-# 2004.10.25  trans  Initial release.
-#================================================================================
-#++
-
-# :title: One.rb
+# == Special Thanks
+#
+# Big shout-out to all the authors of fabulous one-liners!
+#
+# == Author(s)
+#
+# * Thomas Sawyer
+
+# Author::    Thomas Sawyer
+# Copyright:: Copyright (c) 2005 Thomas Sawyer
+# License::   Ruby License
+
+require 'yaml'
+
+# = One
 #
 # One liners helper library provides one letter
 # alias for a number of classes, modules and
@@ -27,19 +33,18 @@
 # This this bit of a "gag" library, but it can also
 # be used for code obsfuscation and includes examples
 # of some neat one liners.
-#
-# == Author(s)
-#
-# * Thomas Sawyer
-#
 
+# Alias Kernel
 K=Kernel
+
+# Alias Object
 O=Object
+
+# Alias Class
 C=Class
 
 module Kernel
-  alias pi p
-  alias p print
+  alias pr print
   alias ps puts
   alias s sleep
   alias l loop
@@ -63,55 +68,86 @@ class Integer
   alias t times
 end
 
+# This module contains a number of historic one-liners.
+#
+# NOTE Most of these one-liners do not use the one.rb 
+# shortcut aliases.
 
-module FamousOneLiners
+module RubyOneLiners
   extend self
 
-  ONELINERS = {}
+  ONELINERS = YAML::load(DATA)
 
-  def define_oneliner( name, &code_blk )
-    code = code_blk.call.gsub(/^ */, '').gsub("\n",'')
-    ONELINERS[name.to_sym] = code
-    define_method( name )
-      eval ONELINERS[name.to_sym]
-    end
+  ONELINERS.each do |name, code|
+    define_method( name, &eval("lambda { #{code} }") )
   end
 
   def oneliner(name)
-    ONELINERS[name.to_sym]
+    ONELINERS[name.to_s]
   end
 
   def oneliners
     ONELINERS.keys
   end
 
-  # Example one-liners
+end
+
 
-  define_oneliner :color_ruby do <<-HERE
-    "jp6iSZmkLp5ISZlEiW5C".unpack("m")[0].unpack("C*").map{|x|x.chr}.join.
-    unpack("B*")[0].scan(/.{24}/){i=7;$&.scan(/..../){print"\e[3#{i-=1};
-    1;40m  ";$&.each_byte{|z|print" #"[z-?0,1]*2}};puts"\e[0m"}
-    HERE
-  end
+if $0 == __FILE__
+  RubyOneLiners.color_ruby
+end
 
-  define_oneliner :quack do <<-HERE
-    s="\e[2J\e[0;0H         _\nQuack! >(*)____,\n        (` =~~/\n^v^v^v^v^`---'v^v^v^v^\n";i=0;
-    l{s[21,6]=i&1>0?'Quack!':' '*6;s.tr!(t='*.>v^<,"',t.r);$><<s;i+=s 1}
-    HERE
-  end
 
-  define_oneliner :quack_alt do <<-HERE
-    s="\e[2J\e[0;0H         _\nQuack! >(*)____,\n        (` =~~/\n^v^v^v^v^`---'v^v^v^v^\n";i=0;
-    loop{s[21,6]=i&1>0?'Quack!':' '*6;s.tr!(t='*.>v^<,"',t.reverse);$><<s;i+=sleep 1}
-    HERE
-  end
+__END__
 
-  define_oneliner :santa do <<-HERE
-    loop{7.times{|i|puts"\e[2J\e[0;3H_...\n / _  '.\n|.'(@@@@@)\n(*)/ %s \\
-        | .o. |\n   (  %s  ) %s"%[i==5?"- -":"e e",(i+3)%7<4?"=":"o",i>0?"-"+
-    (" Ho"*i)[0,9]+"!":""];puts"   (     )\n"*2,"    (   )\n"*3,'     "-"';
-    sleep([5,3,3,4,5,1,4][i]/6.0)}}
-    HERE
-  end
+color_ruby: |
+  "jp6iSZmkLp5ISZlEiW5C".unpack("m")[0].unpack("C*").map{|x|x.chr}.join.
+  unpack("B*")[0].scan(/.{24}/){i=7;$&.scan(/..../){print"\e[3#{i-=1};1;40m  ";
+  $&.each_byte{|z|print" #"[z-?0,1]*2}};puts"\e[0m"}
 
-end
+quack: |
+  s="\e[2J\e[0;0H         _\nQuack! >(*)____,\n        (` =~~/\n^v^v^v^v^`---'v^v^v^v^\n";
+  i=0;l{s[21,6]=i&1>0?'Quack!':' '*6;s.tr!(t='*.>v^<,"',t.r);$><<s;i+=s 1}
+
+quack2: |
+  s="\e[2J\e[0;0H         _\nQuack! >(*)____,\n        (` =~~/\n^v^v^v^v^`---'v^v^v^v^\n";i=0;
+  loop{s[21,6]=i&1>0?'Quack!':' '*6;s.tr!(t='*.>v^<,"',t.reverse);$><<s;i+=sleep 1}
+
+santa: |
+  loop{7.times{|i|puts"\e[2J\e[0;3H_...\n / _  '.\n|.'(@@@@@)\n(*)/ %s \\
+     | .o. |  \n   (  %s  ) %s"%[i==5?"- -":"e e",(i+3)%7<4?"=":"o",i>0?"-"+
+  (" Ho"*i)[0,9]+"!":""];puts"   (     )\n"*2,"    (   )\n"*3,'     "-"';
+  sleep([5,3,3,4,5,1,4][i]/6.0)}}
+
+# This one can take two parameter but block aren't nice about defaults :(
+fractree: |
+  n||=32;l||="A";
+  #n.times{|y|print" "*(n-1-y);(y+1).times{|x|print~y&x>0?" .":" #{l[0.1]}"};puts}
+  n.times{|y|print" "*(n-1-y),(0..y).map{|x|~y&x>0?" .":" #{l}"},$/}
+
+fractree2: |
+  a=[];10.times{|n|a<<1;puts" "*(9-n)*3+"%6d"*(n+1)%a;n.times{|i|a[n]+=a[n-=1]}}
+
+fractree3: |
+  a=[];10.times{|n|a<<1;puts" "*(9-n)*3+"%6d"*-~n%a;n.times{|i|a[n]+=a[n-=1]}}
+
+duck: |
+  s="\033[2J\033[0;0H          _\n Quack! >(')____,\n         (` =~~/\n~^~^~^~^~^`---'~^~^~^~^";
+  (1..(1/0.0)).each{|i|s[23,6]=(i%2)==0?"Quack!":" "*6;s.tr!('>~^^~<','<^~~^>');puts s;sleep 1}
+
+duck2: |
+  s="\e[2J\e[0;0H         _\nQuack! >(*)____,\n        (` =~~/\n^v^v^v^v^`---'v^v^v^v^\n";
+  i=0;loop{s[21,6]=i&1>0?'Quack!':' '*6;s.tr!(t='*.>v^<,"',t.reverse);$><<s;i+=sleep 1}
+
+duck3: |
+  q,w='Quack! >','~^'*11;t="\e[2J\e[0;0H         _\n%8s(')____,\n        (` =^^/\n%20s\n";
+  i=0;loop{s=t%[i&1>0?q:'<',w[i%2,20]];$><<s;i+=sleep 1}
+
+duck4: |
+  i=1;loop{puts"\e[2J\e[0;0H#{' '*10}_\n %8s(*)____,\n#{' '*9}
+  (` =~~/\n#{'~^~'[i%2,2]*9}"%(i&1>0?'<':'Quack! >');i+=sleep 1}
+
+ruby_quiz: |
+  "bp6siZmijp5CiZlCiW5CgAAChpbiiZYiiZZCi5aCZ2bs".unpack("m")[0].unpack("C*").map{|x|
+  x.chr}.join.unpack("B*")[0].scan(/.{24}/){i=7;$&.scan(/..../){
+  print"\e[3#{i-=1};1;40m  ";$&.each_byte{|z|print" #"[z-?0,1]*2}};puts"\e[0m"}

data/lib/facets/more/opencascade.rb

@@ -0,0 +1,187 @@
+# = opencascade.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
+#
+# == Developer Notes
+#
+#   TODO Think about this more!
+#
+#   What about parent when descending downward?
+#   Should parent even be part of OpenObject?
+#   Maybe that should be in a differnt class?
+#
+#   Should cascading work via hash on the fly like this?
+#   Or perhaps converted all at once?
+#
+#   Returning nil doesn't work if assigning!
+
+# Author::    Thomas Sawyer
+# Copyright:: Copyright (c) 2006 Thomas Sawyer
+# License::   Ruby License
+
+require 'facets/core/kernel/bool.rb'
+require 'facets/more/openobject.rb'
+#require 'facets/more/nullclass'
+
+# = OpenCascade
+#
+# OpenCascade is subclass of OpenObject, but differs in a few
+# significant ways.
+#
+# Mainly, and why it's labeled a "cascade", every internal Hash
+# is trandformed into an OpenCascade dynamically upon access.
+# This makes it easy to create "cascading" references.
+#
+#   h = { :a => { :b => { :c => 1 } } }
+#   o = OpenCascade.new(h)
+#   o.a.b.c  #=> 1
+#
+# OpenCascade also has an inheritance feature which allows lookup
+# to be passed on to a "parent" if a key is not found. Simple use
+# the keyword option ++:inherit++ (or ++:parent++).
+#
+#    p = { :a => 1 }
+#    o = OpenCascade.new( {}, :inherit => p }
+#    o.a  #=> 1
+#
+# OpenCascade also supports acquisition which applies inheritance
+# to every sub-access. Eg.
+#
+#    o = OpenCascade.new( { :a => 1, :q => {} }, :acquisition => true }
+#    o.q.a  #=> 1
+#
+# The two can, of course, be used together.
+#--
+# Last, when an entry is not found, 'null' is returned rather then 'nil'.
+# This allows for run-on entries withuot error. Eg.
+#
+#   o = OpenCascade.new
+#   o.a.b.c  #=> null
+#
+# Unfortuately this requires an explict test for of nil? in 'if' conditions,
+#
+#   if o.a.b.c.null?  # True if null
+#   if o.a.b.c.nil?   # True if nil or null
+#   if o.a.b.c.not?   # True if nil or null or false
+#
+# So be sure to take that into account.
+#++
+
+class OpenCascade < OpenObject
+
+  def initialize( init=nil, opt={} )
+    super( init )
+    @parent = opt[:inherit] || opt[:parent]
+    @acquire = opt[:acquisition] ? true : false
+  end
+
+  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]
+          if @acquire
+            self.__class__.new( @table[name], :inherit => self, :acquisition => true )
+          else
+            self.__class__.new( @table[name] )
+          end
+        else
+          @table[name]
+        end
+      elsif @parent
+        # error catch?
+        @parent.__send__(name)
+      else
+        nil
+        # Kernel.null
+        # @table[name] = instance.class.new
+      end
+    end
+  end
+
+  def __parent__ ; @parent ; end
+  def __parent__=(x) ; @parent = x ; end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin testing
+
+  require 'test/unit'
+
+  class TC01 < Test::Unit::TestCase
+
+    def test_01_001
+      f0 = OpenCascade.new
+      f0[:a] = 1
+      assert_equal( [1], f0.to_a )
+      assert_equal( {:a=>1}, f0.to_h )
+    end
+
+    def test_01_002
+      f0 = OpenCascade.new( {:a=>1} )
+      f0[:b] = 2
+      assert_equal( {:a=>1,:b=>2}, f0.to_h )
+    end
+  end
+
+  class TC02 < Test::Unit::TestCase
+
+    def test_02_001
+      f0 = OpenCascade.new( :f0=>"f0" )
+      h0 = { :h0=>"h0" }
+      assert_equal( OpenCascade.new( :f0=>"f0", :h0=>"h0" ), f0.__merge__( h0 ) )
+      assert_equal( {:f0=>"f0", :h0=>"h0"}, h0.merge( f0 ) )
+    end
+
+    def test_02_002
+      f1 = OpenCascade.new( :f1=>"f1" )
+      h1 = { :h1=>"h1" }
+      f1.__update__( h1 )
+      h1.update( f1 )
+      assert_equal( OpenCascade.new( :f1=>"f1", :h1=>"h1" ), f1 )
+      assert_equal( {:f1=>"f1", :h1=>"h1"}, h1 )
+    end
+
+  end
+
+  class TC03 < Test::Unit::TestCase
+
+    def test_01_001
+      fo = OpenCascade.new
+      99.times{ |i| fo.__send__( "n#{i}=", 1 ) }
+      99.times{ |i|
+        assert_equal( 1, fo.__send__( "n#{i}" ) )
+      }
+    end
+
+  end
+
+=end

data/lib/facets/more/openobject.rb

@@ -1,26 +1,31 @@
-#--
-# OpenObject
+# = openobject.rb
 #
-# Copyright (c) 2005 Thomas Sawyer & George Moschovitis
+# == Copyright (c) 2005 Thomas Sawyer, George Moschovitis
 #
-# Ruby License
+#   Ruby License
 #
-# This module is free software. You may use, modify, and/or redistribute this
-# software under the same terms as Ruby.
+#   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.
+#   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
-#======================================================================
-# 2005-09-01  trans
-#   Created as a more robust alternative to OpenStruct.
-#======================================================================
-#++
+# == Authors and Contributors
+#
+# * Thomas Sawyer
+# * George Moschovitis
+
+# Author::    Thomas Sawyer, George Moschovitis
+# Copyright:: Copyright (c) 2005 Thomas Sawyer, George Moschovitis
+# License::   Ruby License
 
-# :title: OpenObject
+require 'facets/core/hash/keys_to_sym'
+require 'facets/core/hash/to_proc'
+require 'facets/more/basicobject'
+#require 'facets/more/nullclass'
+
+# = OpenObject
 #
 # OpenObject is similar to OpenStruct, but differs in a few
 # significant ways.
@@ -32,27 +37,15 @@
 # but rather strictly uses a hash. OpenStruct creates methods, but is
 # actaully inconsitant in their use --try #dup on an OpenStruct and
 # all the methods disappear. Morevoer, I beleive this feature was added
-# to OpenStruct for speed. But I have not been able to find this
+# to OpenStruct for speed, but I have not been able to find this
 # advantage in benchmark tests.
 #
 #--
-#
 # 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)
-#
-# * George Moschovitis
-# * Thomas Sawyer
-#
-
-require 'facets/core/hash/keys_to_sym'
-require 'facets/more/basicobject'
-#require 'facets/more/nullclass'
 
 class OpenObject < BasicObject
 
@@ -71,10 +64,24 @@ class OpenObject < BasicObject
     end
   end
 
+  def to_openobject ; self    ; end
+
   def to_a    ; @table.values ; end
   def to_h    ; @table.dup    ; end
   def to_hash ; @table.dup    ; end
 
+  # OpenObejct can be converted to an assignment Proc.
+  #
+  #   o = OpenObject.new( :a=>1 )
+  #   p = o.to_proc
+  #   x = OpenObject.new
+  #   p[x]
+  #   x.a #=> 1
+  #
+  def to_proc
+    @table.to_proc
+  end
+
   # duplicate
   def initialize_copy( orig )
     super
@@ -113,11 +120,10 @@ class OpenObject < BasicObject
     else
       if @table.key?(name)
         @table[name]
-      elsif @parent
-        @parent.__send__(name)
+      #elsif @parent
+      #  @parent.__send__(name)
       else
         nil
-        #  Kernel.null #@table[name] = instance.class.new
       end
     end
   end
@@ -136,23 +142,28 @@ class OpenObject < BasicObject
   end
 
   # For compatibility with other types of hash-like objects.
+  # Also make OpenObject usable via Enumerator.
   def each(&yld)
     @table.each( &yld )
   end
 
-  # shadow methods
+  # Shadow methods
 
+  # Access to internal table.
   def __table__ ; @table ; end
 
-  def __parent__ ; @parent ; end
-  def __parent__=(x) ; @parent = x ; end
+  #--
+  # TODO Parent feature? Or better only for OpenCascade?
+  #++
+  #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 __fetch__(k) ; @table.key?(k.to_sym) ? @table[k.to_sym] : null ; end
+  def __fetch__(k)  ; @table[k.to_sym] ; end
+  def __store__(k)  ; @table[k.to_sym]=v ; end
 
   def __key__?(k) ; @table.key?(k.to_sym) ; end
-  def __keys__ ; @table.keys ; end
+  def __keys__    ; @table.keys ; end
 
   def __update__( other )
     other = Hash[*other] if other.is_a?(Array)
@@ -165,33 +176,33 @@ class OpenObject < BasicObject
     o
   end
 
-end
+  # Core Extensions
 
+  class ::Hash
+    # Convert a Hash into an OpenObject.
+    def to_openobject
+      OpenObject.new( self )
+    end
+  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
+  class ::Proc
+    # Translates a Proc into an OpenObject. By droping an OpenObject into
+    # the Proc, the resulting assignments incured as the procedure is
+    # evaluated produce the OpenObject. This technique is simlar to that
+    # of MethodProbe.
+    #
+    #   p = lambda { |x|
+    #     x.word = "Hello"
+    #   }
+    #   o = p.to_openobject
+    #   o.word #=> "Hello"
+    #
+    # NOTE The Proc must have an arity of one --no more and no less.
+    def to_openobject
+      raise ArgumentError, 'bad arity for converting Proc to openobject' if arity != 1
+      o = OpenObject.new
+      self.call( o )
+      o
     end
   end
 
@@ -247,7 +258,7 @@ end
 
   class TC03 < Test::Unit::TestCase
 
-    def test_01_001
+    def test_03_001
       fo = OpenObject.new
       99.times{ |i| fo.__send__( "n#{i}=", 1 ) }
       99.times{ |i|
@@ -257,4 +268,16 @@ end
 
   end
 
+  class TC04 < Test::Unit::TestCase
+
+    def test_04_001
+      p = lambda { |x|
+        x.word = "Hello"
+      }
+      o = p.to_openobject
+      assert_equal( "Hello", o.word )
+    end
+
+  end
+
 =end