mack-facets 0.8.2 → 0.8.3

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

@@ -1,267 +0,0 @@
-# = 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

@@ -1,60 +0,0 @@
-# = 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

@@ -1,37 +0,0 @@
-# = 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

@@ -1,94 +0,0 @@
-# = 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
-