facets 0.9.0 → 1.0.0

data/lib/mega/nilcomparable.rb

@@ -1,128 +0,0 @@
-#--
-# 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 ::
-# --------------------------------------------------------------------------
-#  5.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/mega/notcopyable.rb

@@ -1,146 +0,0 @@
-#--
-# NotCopyable
-#
-# Adapted from Ruby Treasures 0.4, Copyright (C) 2002 Paul Brannan
-#
-# 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:
-# --------------------------------------------------------------------------
-#  2004.04  Trans
-#    Ported to Mega Modules
-# ==========================================================================
-#
-# TODO: Method Clash
-# If one is reopening a class and including this, it will not work
-# if the class defined #dub, #clone or #copy (and #deep_copy) itself.
-# It only work if it's ancestors are responsible for those methods.
-# So how to fix?
-#
-#++
-
-#:title: NotCopyable
-#
-# Disable copying via dup and clone (and copy).
-#
-# == Usage
-#
-#   require 'mega/notcopyable.rb'
-#
-#   Class FixedString < String
-#     include NotCopyable
-#   end
-#
-#   s = FixedString.new("Don't tred on me!")
-#   puts s
-#   s2 = s.dup
-#
-# _produces_
-#
-#   Don't tred on me!
-#   TypeError, "Object not copyable"
-#
-# == Notes
-#
-# * I don't think this will prove very useful, but just in case
-#   here it is.
-#
-# == Author(s)
-#
-# * Paul Brannan <paul at atdesk.com>
-# * Thomas Sawyer
-#
-
-module NotCopyable
-
-  def clone
-    raise TypeError, "Object not copyable"
-  end
-  def dup
-    raise TypeError, "Object not copyable"
-  end
-  # if object/copy has been required?
-  def copy
-    raise TypeError, "Object not copyable"
-  end
-  alias_method( :deep_copy, :copy )
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-  require 'test/unit'
-
-  # fixture
-
-  class Foo
-    include NotCopyable
-  end
-
-  class Bar < Foo
-  end
-
-  class Foo2
-  end
-
-  # test
-
-  class TC_NotCopyable < Test::Unit::TestCase
-
-    def test_dup
-      f = Foo.new
-      assert_raises(TypeError) do
-        g = f.dup
-      end
-    end
-
-    def test_dup_derived
-      f = Bar.new
-      assert_raises(TypeError) do
-        g = f.dup
-      end
-    end
-
-    def test_dup_okay
-      f = Foo2.new
-      g = f.dup
-    end
-
-    def test_clone
-      f = Foo.new
-      assert_raises(TypeError) do
-        g = f.clone
-      end
-    end
-
-    def test_clone_derived
-      f = Bar.new
-      assert_raises(TypeError) do
-        g = f.clone
-      end
-    end
-
-    def test_clone_okay
-      f = Foo2.new
-      g = f.clone
-    end
-
-  end
-
-=end

data/lib/mega/null.rb

@@ -1,40 +0,0 @@
-
-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
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin #testing
-=end

data/lib/mega/ohash.rb

@@ -1,3 +0,0 @@
-warn 'OrderedHash (ohash.rb) is deprecated --use Dictionary (dictionary.rb) instead.'
-require 'mega/dictionary'
-OrderedHash = Dictionary

data/lib/mega/one.rb

@@ -1,72 +0,0 @@
-# 1.rb one-liners helper lib.
-
-require 'nano/string/tabto'
-
-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 self.define_one_liner( name, &code_blk_str )
-    ONELINERS[name.to_sym] = code_blk_str.call.tabto(0)
-    define_method( name )
-      eval ONELINERS[name.to_sym]
-    end
-  end
-
-  def one_liner(name)
-    ONELINERS[name.to_sym]
-  end
-
-
-  define_one_liner :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_one_liner :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_one_liner :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

data/lib/mega/openobject.rb

@@ -1,220 +0,0 @@
-#--
-# 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 'mega/basicobject'
-#require 'mega/null'
-
-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