mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/more/facets/openobject.rb

@@ -0,0 +1,267 @@
+# = OpenObject
+#
+# OpenObject is very similar to Ruby's own OpenStruct, but it offers some
+# useful advantages. With OpenStruct slots with the same name's as predefined
+# Object methods can not be used. With OpenObject any slot can be defined,
+# OpendObject is also a bit faster becuase it is based on a Hash, not
+# method signitures.
+#
+# Because OpenObject is a subclass of Hash, it can do just about
+# everything a Hash can do, except that most public methods have been
+# made protected and thus available only internally or via #send.
+#
+# OpenObject will also clobber any method for which a slot is defined.
+# Even generally very important methods can be clobbered, like
+# instance_eval. So be aware of this. OpenObject should be used in well
+# controlled scenarios.
+#
+# If you wish to pass an OpenObject to a routine that normal takes a Hash,
+# but are uncertain it can handle the distictions properly  you can convert
+# easily to a Hash using #to_hash! and the result will automatically be
+# converted back to an OpenObject on return.
+#
+#   o = OpenObject.new(:a=>1,:b=>2)
+#   o.as_hash!{ |h| h.update(:a=>6) }
+#   o #=> #<OpenObject {:a=>6,:b=>2}>
+#
+# Finally, unlike a regular Hash, all OpenObject's keys are symbols and
+# all keys are converted to such using #to_sym on the fly.
+#
+# == Authors
+#
+# * Thomas Sawyer
+# * George Moschovitis
+#
+# == Copying
+#
+# 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.
+
+require 'facets/hash/to_h'
+require 'facets/hash/to_proc'
+require 'facets/kernel/object_class'
+require 'facets/kernel/object_hexid'
+
+# = OpenObject
+#
+# OpenObject is very similar to Ruby's own OpenStruct, but it offers some
+# useful advantages. With OpenStruct slots with the same name's as predefined
+# Object methods can not be used. With OpenObject any slot can be defined,
+# OpendObject is also a bit faster becuase it is based on a Hash, not
+# method signitures.
+#
+# Because OpenObject is a subclass of Hash, it can do just about
+# everything a Hash can do, except that most public methods have been
+# made protected and thus available only internally or via #send.
+#
+# OpenObject will also clobber any method for which a slot is defined.
+# Even generally very important methods can be clobbered, like
+# instance_eval. So be aware of this. OpenObject should be used in well
+# controlled scenarios.
+#
+# If you wish to pass an OpenObject to a routine that normal takes a Hash,
+# but are uncertain it can handle the distictions properly  you can convert
+# easily to a Hash using #to_hash! and the result will automatically be
+# converted back to an OpenObject on return.
+#
+#   o = OpenObject.new(:a=>1,:b=>2)
+#   o.as_hash!{ |h| h.update(:a=>6) }
+#   o #=> #<OpenObject {:a=>6,:b=>2}>
+#
+# Finally, unlike a regular Hash, all OpenObject's keys are symbols and
+# all keys are converted to such using #to_sym on the fly.
+
+class OpenObject < Hash
+
+  PUBLIC_METHODS = /(^__|^instance_|^object_|^\W|^as$|^send$|^class$|\?$)/
+
+  protected(*public_instance_methods.select{ |m| m !~ PUBLIC_METHODS })
+
+  def self.[](hash=nil)
+    new(hash)
+  end
+
+old_verbose = $VERBOSE
+$VERBOSE = false  # shut warnings up while redefining these methods.
+
+  # Inititalizer for OpenObject is slightly differnt than that of Hash.
+  # It does not take a default parameter, but an initial priming Hash
+  # as with OpenStruct. The initializer can still take a default block
+  # however. To set the degault value use ++#default!(value)++.
+  #
+  #   OpenObject(:a=>1).default!(0)
+
+  def initialize( hash=nil, &yld )
+    super( &yld )
+    hash.each { |k,v| define_slot(k,v) } if hash
+  end
+
+  def initialize_copy( orig )
+    orig.each { |k,v| define_slot(k,v) }
+  end
+
+  # Object inspection. (Careful, this can be clobbered!)
+
+  def inspect
+    "#<#{object_class}:#{object_hexid} #{super}>"
+  end
+
+  # Conversion methods. (Careful, these can be clobbered!)
+
+  def to_a() super end
+
+  def to_h() {}.update(self) end
+  def to_hash() {}.update(self) end
+
+  def to_proc() super  end
+
+  def to_openobject() self end
+
+  # Iterate over each key-value pair. (Careful, this can be clobbered!)
+
+  def each(&yld) super(&yld) end
+
+  # Merge one OpenObject with another creating a new OpenObject.
+
+  def merge( other )
+    d = dup
+    d.send(:update, other)
+    d
+  end
+
+  # Update this OpenObject with another.
+
+  def update( other )
+    begin
+      other.each { |k,v| define_slot(k,v) }
+    rescue
+      other = other.to_h
+      retry
+    end
+  end
+
+  #
+
+  def delete(key)
+    super(key.to_sym)
+  end
+
+  # Set the default value.
+
+  def default!(default)
+    self.default = default
+  end
+
+  # Preform inplace action on OpenObject as if it were a regular Hash.
+  #--
+  # TODO Not so sure about #as_hash!. For starters if it doesn't return a hash it will fail.
+  # TODO Replace by using #as(Hash). Perhaps as_hash and as_object shortcuts? Why?
+  #++
+
+  def as_hash!(&yld)
+    replace(yld.call(to_hash))
+  end
+
+  # Check equality. (Should equal be true for Hash too?)
+
+  def ==( other )
+    return false unless OpenObject === other
+    super(other) #(other.send(:table))
+  end
+
+  def []=(k,v)
+    protect_slot(k)
+    super(k.to_sym,v)
+  end
+
+  def [](k)
+    super(k.to_sym)
+  end
+
+  protected
+
+    def store(k,v)
+      super(k.to_sym,v)
+      define_slot(k)
+    end
+
+    def fetch(k,*d,&b)
+      super(k.to_sym,*d,&b)
+    end
+
+    def define_slot( key, value=nil )
+      protect_slot( key )
+      self[key.to_sym] = value
+    end
+
+    def protect_slot( key )
+      (class << self; self; end).class_eval {
+        protected key rescue nil
+      }
+    end
+
+    def method_missing( sym, arg=nil, &blk)
+      type = sym.to_s[-1,1]
+      key = sym.to_s.sub(/[=?!]$/,'').to_sym
+      if type == '='
+        define_slot(key,arg)
+      elsif type == '!'
+        define_slot(key,arg)
+        self
+      else
+        self[key]
+      end
+    end
+
+$VERBOSE = old_verbose
+
+end
+
+# Core Extensions
+
+class NilClass
+  # Nil converts to an empty OpenObject.
+
+  def to_openobject
+    OpenObject.new
+  end
+end
+
+class Hash
+  # Convert a Hash into an OpenObject.
+
+  def to_openobject
+    OpenObject[self]
+  end
+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
+

data/lib/gems/facets-2.4.5/lib/more/facets/opesc.rb

@@ -0,0 +1,60 @@
+# = OpEsc
+#
+module OpEsc
+
+  OPERATORS = %w{ +@ -@ + - ** * / % ~ <=> << >> < > === == =~ <= >= | & ^ []= [] }
+  OPERATORS_REGEXP = Regexp.new( '(' << OPERATORS.collect{ |k| Regexp.escape(k) }.join('|') << ')' )
+  OPERATORS_ESC_TABLE = {
+      "+@"   => "op_plus_self",
+      "-@"   => "op_minus_self",
+      "+"    => "op_plus",
+      "-"    => "op_minus",
+      "**"   => "op_pow",
+      "*"    => "op_mul",
+      "/"    => "op_div",
+      "%"    => "op_mod",
+      "~"    => "op_tilde",
+      "<=>"  => "op_cmp",
+      "<<"   => "op_lshift",
+      ">>"   => "op_rshift",
+      "<"    => "op_lt",
+      ">"    => "op_gt",
+      "==="  => "op_case_eq",
+      "=="   => "op_equal",
+      "=~"   => "op_apply",
+      "<="   => "op_lt_eq",
+      ">="   => "op_gt_eq",
+      "|"    => "op_or",
+      "&"    => "op_and",
+      "^"    => "op_xor",
+      "[]="  => "op_store",
+      "[]"   => "op_fetch"
+  }
+
+  # Applies operator escape's according to OPERATORS_ESCAPE_TABLE.
+  #
+  #   op_esc('-') #=> "op_minus"
+  #
+  #   CREDIT: Trans
+
+  def self.escape(str)
+    str.gsub(OPERATORS_REGEXP){ OPERATORS_ESC_TABLE[$1] }
+  end
+
+  # NOTE: op_esc used to support the method require_esc.
+  #
+  #   # Require a file with puncuation marks escaped.
+  #   #
+  #   #   require_esc '[].rb'
+  #   #
+  #   # in actuality requires the file 'op_fetch.rb'.
+  #
+  #   def require_esc( fpath )
+  #     fdir, fname = File.split(fpath)
+  #     ename = op_esc( fname )
+  #     case ename[-1,1] ; when '!','=','?' then ename = ename[0...-1] ; end
+  #     epath = File.join( fdir, ename )
+  #     require( epath )
+  #   end
+
+end

data/lib/gems/facets-2.4.5/lib/more/facets/orderedhash.rb

@@ -0,0 +1,37 @@
+# = OrderedHash
+#
+# Another name for Dictionary.
+#
+# == Todo
+#
+# * Make this an alternative to Dictionary that
+#   is more "slim", not having the extra sorting
+#   features of dictionary.
+#
+# = Copying
+#
+# 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.
+
+require 'facets/dictionary'
+
+# = OrderedHash
+#
+# OrderedHash is an alias for the Dictionary class
+
+OrderedHash = Dictionary
+
+# = AutoOrderedHash
+#
+# AutoOrderedHash is an alias for the AutoDictionary class
+
+#AutoOrderedHash = AutoDictionary  # was replaced by Dictionary.auto() (or autonew?)
+

data/lib/gems/facets-2.4.5/lib/more/facets/overload.rb

@@ -0,0 +1,94 @@
+# = Overload
+#
+# Write methods with signitures.
+#
+# == Copying
+#
+# 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.
+#
+# == Authors
+#
+# * Thomas Sawyer
+
+#
+class Module
+
+  def method_overloads
+    @method_overloads ||= {}
+  end
+
+  # Overload methods.
+  #
+  #   class X
+  #     def x
+  #       "hello"
+  #     end
+  #
+  #     overload :x, Integer do |i|
+  #       i
+  #     end
+  #
+  #     overload :x, String, String do |s1, s2|
+  #       [s1, s2]
+  #     end
+  #   end
+  #
+  def overload( name, *signiture, &block )
+    raise ArgumentError unless signiture.all?{|s| s.instance_of?(Class)} 
+
+    name = name.to_sym
+
+    if method_overloads.key?( name )
+      method_overloads[name][signiture] = block
+
+    else
+      method_overloads[name] = {}
+      method_overloads[name][signiture] = block
+
+      if method_defined?( name )
+        #method_overloads[name][nil] = instance_method( name ) #true
+        alias_method( "#{name}Generic", name )
+        has_generic = true
+      else
+        has_generic = false
+      end
+
+      define_method( name ) do |*args|
+        ovr = self.class.method_overloads["#{name}".to_sym]
+        sig = args.collect{ |a| a.class }
+        hit = nil
+        faces = ovr.keys #.sort { |a,b| b.size <=> a.size }
+        faces.each do |cmp|
+          next unless cmp.size == sig.size
+          if (0...cmp.size).all?{ |i| cmp[i] >= sig[i] }
+            break hit = cmp
+          end
+        end 
+        if hit
+          ovr[hit].call(*args)
+        else
+          if has_generic #ovr[nil]
+            send( "#{name}Generic", *args )
+            #ovr[nil].bind(self).call(*args)
+          else
+            raise NoMethodError
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end
+