facets 1.1.0 → 1.2.0

data/lib/facets/more/nilcomparable.rb

@@ -0,0 +1,133 @@
+#--
+# NilComparable
+#
+# 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 ::
+# --------------------------------------------------------------------------
+#  2005-4   trans     * Documentation.
+# ==========================================================================
+#++
+
+#:title: NilComparable
+#
+# NilComparable does two things. First it makes nil comparable, such that
+# all things (except itself) are greater than it.
+#
+# Secondly it provides a module called NilComparable to include into any
+# other class to allow it to compare itself to NilClass as the greater
+# of the two.
+#
+# == Usage
+#
+#   TODO
+#
+# == Author(s)
+#
+# * Paul Brannan
+# * Thomas Sawyer
+#
+
+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
+
+
+class NilClass
+  include Comparable
+  def <=>(x)
+    x.nil? ? 0 : -1
+  end
+  alias_method( :cmp, :<=> )
+end
+
+# # 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 testing
+
+  require 'test/unit'
+
+  class Mock < String
+    include NilComparable
+  end
+
+  class TC_NilClass_Comparable < Test::Unit::TestCase
+
+    def test001
+      assert_equal( 0, nil <=> nil )
+      assert_equal( -1, nil <=> 4 )
+      assert_equal( -1, nil <=> "a" )
+      assert_equal( -1, nil <=> Object.new )
+      assert_equal( 0, nil.cmp(nil) )
+      assert( nil < 4 )
+    end
+
+    def test002
+      m = Mock.new("A")
+      assert_equal( 1, m <=> nil )
+      assert_equal( -1, m <=> "B" )
+      #assert_equal( 1, m.cmp(nil) )
+      assert( m > nil )
+    end
+
+  end
+
+=end

data/lib/facets/more/nullclass.rb

@@ -0,0 +1,68 @@
+#--
+# NullClass
+#
+# 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 ::
+# --------------------------------------------------------------------------
+#  2005.10.28  trans     * Created.
+# ==========================================================================
+
+# :title: NullClass
+#
+# NullClass is essentially NilClass but it differs in one
+# important way. When a method is called against it that it
+# deoesn't have, it will simply return null value rather then
+# raise an error.
+
+class NullClass #< NilClass
+  class << self
+    def new
+      @null ||= NullClass.allocate
+    end
+  end
+  def inspect ; 'null' ; end
+  def nil?  ; true ; end
+  def null? ; true ; end
+  def [](key); nil; end
+  def method_missing(sym, *args)
+    return nil if sym.to_s[-1,1] == '?'
+    self
+  end
+end
+
+module Kernel
+  def null
+    NullClass.new
+  end
+end
+
+class Object
+  def null?
+    false
+  end
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+# TODO
+
+=begin #testing
+=end

data/lib/facets/more/one.rb

@@ -0,0 +1,117 @@
+#--
+# One
+#
+# Copyright (c) 2005 Thmas 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.
+#
+#================================================================================
+# ChangeLog
+#================================================================================
+# 2004.10.25  trans  Initial release.
+#================================================================================
+#++
+
+# :title: One.rb
+#
+# One liners helper library provides one letter
+# alias for a number of classes, modules and
+# methods, allowing one to create very tight one-liners.
+# 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
+#
+
+K=Kernel
+O=Object
+C=Class
+
+module Kernel
+  alias pi p
+  alias p print
+  alias ps puts
+  alias s sleep
+  alias l loop
+end
+
+module Enumerable
+  alias m map
+end
+
+class Array
+  alias e each
+  alias r reverse
+end
+
+class String
+  alias e each
+  alias r reverse
+end
+
+class Integer
+  alias t times
+end
+
+
+module FamousOneLiners
+  extend self
+
+  ONELINERS = {}
+
+  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
+  end
+
+  def oneliner(name)
+    ONELINERS[name.to_sym]
+  end
+
+  def oneliners
+    ONELINERS.keys
+  end
+
+  # Example one-liners
+
+  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
+
+  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
+
+  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
+
+end

data/lib/facets/more/openobject.rb

@@ -0,0 +1,220 @@
+#--
+# OpenObject
+#
+# Copyright (c) 2005 Thomas Sawyer & George Moschovitis
+#
+# 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
+#======================================================================
+# 2005-09-01  trans
+#   Created as a more robust alternative to OpenStruct.
+#======================================================================
+#++
+
+# :title: OpenObject
+#
+# OpenObject is similar to OpenStruct, but differs in a few
+# significant ways.
+#
+# OpenObject is a sublcass of BasicObject, so there are
+# many fewer reserved Kernel methods in the object's namespace.
+#
+# Also it does not create any instance methods for the added entries,
+# 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
+# advantage in benchmark tests.
+#
+#--
+# Thrid, 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/more/basicobject'
+#require 'facets/more/nullclass'
+
+class OpenObject < BasicObject
+
+  def initialize( init=nil )
+    case init
+    when Array
+      @table = Hash[*init]
+    when Hash
+      @table = init.dup
+    when NilClass
+      @table = {}
+    when OpenObject
+      @table = init.__table__.dup
+    else
+      @table = init.to_h.dup
+    end
+  end
+
+  def to_a    ; @table.values ; end
+  def to_h    ; @table.dup    ; end
+  def to_hash ; @table.dup    ; end
+
+  # duplicate
+  def initialize_copy( orig )
+    super
+    @table = @table.dup
+  end
+
+  def inspect
+    s = "<#{__class__}"
+    s << " " << @table.collect{|k,v| "#{k}=#{v.inspect}"}.join(' ') unless @table.empty?
+    s << ">"
+  end
+
+  def marshal_dump
+    @table
+  end
+
+  def marshal_load( tbl )
+    @table = tbl
+  end
+
+  # Compare this object and +other+ for equality.
+  def ==(other)
+    return false unless other.kind_of?( __class__ )
+    return @table == other.__table__
+  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)
+        @table[name]
+      #else
+      #  Kernel.null #@table[name] = instance.class.new
+      #end
+    end
+  end
+
+  def [](name)
+    name = name.to_sym
+    #if @table.key?(name)
+      @table[name]
+    #else
+    #  Kernel.null
+    #end
+  end
+
+  def []=(name,val)
+    @table[name.to_sym] = val
+  end
+
+  # For compatibility with other types of hash-like objects.
+  def each(&yld)
+    @table.each( &yld )
+  end
+
+  def __table__ ; @table ; 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 __keys__ ; @table.keys ; end
+
+  def __update__( other )
+    other = Hash[*other] if other.is_a?(Array)
+    other.each{ |k, v| @table[k] = v }
+  end
+
+  def __merge__( other )
+    o = dup
+    o.__update__( other )
+    o
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin testing
+
+  require 'test/unit'
+
+  class TC01 < Test::Unit::TestCase
+
+    def test_01_001
+      f0 = OpenObject.new
+      f0[:a] = 1
+      assert_equal( [1], f0.to_a )
+      assert_equal( {:a=>1}, f0.to_h )
+    end
+
+    def test_01_002
+      f0 = OpenObject.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 = OpenObject.new( :f0=>"f0" )
+      h0 = { :h0=>"h0" }
+      assert_equal( OpenObject.new( :f0=>"f0", :h0=>"h0" ), f0.__merge__( h0 ) )
+      assert_equal( {:f0=>"f0", :h0=>"h0"}, h0.merge( f0 ) )
+    end
+
+    def test_02_002
+      f1 = OpenObject.new( :f1=>"f1" )
+      h1 = { :h1=>"h1" }
+      f1.__update__( h1 )
+      h1.update( f1 )
+      assert_equal( OpenObject.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 = OpenObject.new
+      99.times{ |i| fo.__send__( "n#{i}=", 1 ) }
+      99.times{ |i|
+        assert_equal( 1, fo.__send__( "n#{i}" ) )
+      }
+    end
+
+  end
+
+=end