facets 2.8.4 → 2.9.0.pre.1

data/lib/more/facets/module/attr.rb

@@ -1,83 +0,0 @@
-class Module
-
-  # Create a toggle attribute. This creates two methods for
-  # each given name. One is a form of tester and the other
-  # is used to toggle the value.
-  #
-  #   attr_accessor! :a
-  #
-  # is equivalent to
-  #
-  #   def a?
-  #     @a
-  #   end
-  #
-  #   def a!(value=true)
-  #     @a = value
-  #     self
-  #   end
-  #
-  # CREDIT: Trans
-
-  def attr_switch_accessor(*args)
-    attr_reader!(*args) + attr_writer!(*args)
-  end
-
-  alias_method :attr_toggler,  :attr_accessor!
-
-  # Create aliases for flag accessors.
-  #
-  # CREDIT: Trans
-
-  def alias_accessor!(*args)
-    orig = args.last
-    args = args - [orig]
-    args.each do |name|
-      alias_method("#{name}?", "#{orig}?")
-      alias_method("#{name}!", "#{orig}!")
-    end
-  end
-  alias_method :alias_switcher, :alias_accessor!
-  alias_method :alias_toggler,  :alias_accessor!
-
-  # Create a flaggable attribute. This creates a single methods
-  # used to set an attribute to "true".
-  #
-  #   attr_writer! :a
-  #
-  # is equivalent to
-  #
-  #   def a!(value=true)
-  #     @a = value
-  #     self
-  #   end
-  #
-  def attr_writer!(*args)
-    code, made = '', []
-    args.each do |a|
-      code << %{
-        def #{a}!(value=true)
-          @#{a} = value
-          self
-        end
-      }
-      made << "#{a}!".to_sym
-    end
-    module_eval code
-    made
-  end
-
-  # Create aliases for flag writer.
-  #
-  # CREDIT: Trans
-
-  def alias_writer!(*args)
-    orig = args.last
-    args = args - [orig]
-    args.each do |name|
-      alias_method("#{name}!", "#{orig}!")
-    end
-  end
-
-end
-

data/lib/more/facets/module/attr_toggler.rb

@@ -1,59 +0,0 @@
-require 'facets/attr_tester'
-
-class Module
-
-  # Create a flaggable attribute. This creates a single methods
-  # used to set an attribute to "true".
-  #
-  #   attr_toggler :a
-  #
-  # is equivalent to
-  #
-  #   def a?
-  #     @a ? true : @a
-  #   end
-  #
-  #   def a!(value=Exception)
-  #     if Exception
-  #       @a = @a ? false : true
-  #     else 
-  #       @a = value
-  #     end
-  #     self
-  #   end
-  #
-  def attr_toggler(*args)
-    code, made = '', []
-    args.each do |a|
-      code << %{
-        def #{a}!(value=Excception)
-          if Exception
-            @a = @a ? false : true
-          else 
-            @a = value
-          end
-          self
-        end
-      }
-      made << "#{a}!".to_sym
-    end
-    module_eval code
-    made.concat(attr_tester(*args))
-    made
-  end
-
-  # Create aliases for attr_toggler.
-  #
-  # CREDIT: Trans
-
-  def alias_toggler(*args)
-    orig = args.last
-    args = args - [orig]
-    args.each do |name|
-      alias_method("#{name}!", "#{orig}!")
-      alias_method("#{name}?", "#{orig}?")
-    end
-  end
-
-end
-

data/lib/more/facets/module/class_extend.rb

@@ -1,3 +0,0 @@
-warn "use 'facets/class_extend' for future versions"
-require 'facets/class_extend'
-

data/lib/more/facets/once.rb

@@ -1,59 +0,0 @@
-module Kernel #:nodoc:
-
-  # Directive for making your functions faster by trading
-  # space for time. When you "memoize" a method/function
-  # using #once its results are cached so that later calls
-  # with the same arguments return results from the cache
-  # instead of recalculating them.
-  #
-  #   class T
-  #     def initialize(a)
-  #       @a = a
-  #     end
-  #     def a
-  #       "#{@a ^ 3 + 4}"
-  #     end
-  #     once :a
-  #   end
-  #
-  #   t = T.new
-  #   t.a.__id__ == t.a.__id__  #=> true
-  #
-  # This method can also be used at the instance level
-  # to cache singleton/eigen methods.
-  #
-  # Note, this method used to be called +cache+ along with
-  # it's other alias #memoize, but +once+ is the term used
-  # in PickAxe so it has been adopted instead. The #memoize
-  # alias has also been retained.
-  #
-  # CREDIT Robert Feldt
-  #
-  def once(*ids)
-    if ids.empty?
-      @_once ||= Hash::new{|h,k| h[k]={}}
-    else
-      base = (Module === self ? self : (class << self; self; end))
-      ids.each do |m|
-        base.module_eval <<-code
-          alias_method '#{ m }:once', '#{ m }'
-          private '#{ m }:once'
-          def #{ m }(*__a__,&__b__)
-            c = once['#{ m }']
-            k = [__a__,__b__]
-            if c.has_key? k
-              c[k]
-            else
-              c[k] = __send__('#{ m }:once',*__a__,&__b__)
-            end
-          end
-        code
-      end
-    end
-  end
-
-  # +once+ is also widely known as +memoize+.
-  alias_method :memoize, :once
-
-end
-

data/lib/more/facets/opencascade.rb

@@ -1,94 +0,0 @@
-# = 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.
-
-require 'facets/boolean' # bool
-require 'facets/openobject'
-#require 'facets/nullclass'
-
-# = OpenCascade
-#
-# OpenCascade is subclass of OpenObject. It differs in a few
-# significant ways.
-#
-# The main reason this class is labeled "cascade", every internal
-# Hash is transformed into an OpenCascade dynamically upon access.
-# This makes it easy to create "cascading" references.
-#
-#   h = { :x => { :y => { :z => 1 } } }
-#   c = OpenCascade[h]
-#   c.x.y.z  #=> 1
-#
-# As soon as you access a node it automatically becomes an OpenCascade.
-#
-#   c = OpenCascade.new   #=> #<OpenCascade:0x7fac3680ccf0 {}>
-#   c.r                   #=> #<OpenCascade:0x7fac368084c0 {}>
-#   c.a.b                 #=> #<OpenCascade:0x7fac3680a4f0 {}>
-#
-# But if you set a node, then that will be it's value.
-#
-#   c.a.b = 4             #=> 4
-#
-# To query a node without causing the auto-creation of an OpenCasade
-# object, use the ?-mark.
-#
-#   c.a.z?                #=> nil
-#
-# Finally, you can set a node and get the reciever back using
-# the !-mark.
-#
-#   c = OpenCascade.new   #=> #<OpenCascade:0x7fac3680ccf0 {}>
-#   c.x!(4).y!(3)         #=> #<OpenCascade:0x7fac3680ccf0 {:x=>4, :y=>3}>
-#
-#--
-# 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 method_missing( sym, arg=nil )
-    type = sym.to_s[-1,1]
-    name = sym.to_s.gsub(/[=!?]$/, '').to_sym
-    if type == '='
-      self[name] = arg
-    elsif type == '!'
-      self[name] = arg
-      self
-    elsif type == '?'
-      self[name]
-    else
-      if val = self[name]
-        if Hash === val
-          self[name] = self.class.new(val)
-        else
-          self[name]
-        end
-      else
-        self[name] = self.class.new
-      end
-    end
-  end
-
-end
-

data/lib/more/facets/opencollection.rb

@@ -1,43 +0,0 @@
-# = OpenCollection
-#
-# A mapping OpenObject.
-#
-# == Authors
-#
-# * Thomas Sawyer
-#
-# == 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/openobject'
-
-# = OpenCollection
-#
-# Mapping OpenObject.
-#
-class OpenCollection
-
-  def initialize(*hash)
-    @opens = hash.map do |h|
-      OpenObject.new(h)
-    end
-  end
-
-  def method_missing(sym)
-    @opens.map do |o|
-      o.send(sym)
-    end
-  end
-
-end
-

data/lib/more/facets/openhash.rb

@@ -1,39 +0,0 @@
-# = OpenHash
-#
-# OpenHash is akin to an OpenStruct or an OpenObject,
-# but it is much simplier in nature. It is a hash with
-# an method_missing definition that routes to [] and []=.
-#
-# == Author
-#
-# * Trans
-
-# = OpenHash
-#
-# OpenHash is akin to an OpenStruct or an OpenObject,
-# but it is much simplier in nature. It is a hash with
-# an method_missing definition that routes to [] and []=.
-#
-class OpenHash < Hash
-  #private *instance_methods.select{|m| m !~ /^__/}
-
-  # New OpenHash.
-
-  def initialize(data)
-    super()
-    update(data)
-  end
-
-  # Route get and set calls.
-
-  def method_missing(s, *a)
-    if s =~ /=$/
-      self[s] = a[0]
-    elsif a.empty?
-      self[s]
-    else
-      super
-    end
-  end
-
-end

data/lib/more/facets/openmodule.rb

@@ -1,16 +0,0 @@
-#
-class OpenModule < Module
-
-  def initialize(&block)
-    instance_eval(&block) if block_given?
-  end
-
-  def method_missing(s, *a, &b)
-    if block_given?
-      define_method(s, &b)
-    else
-      super
-    end
-  end
-
-end

data/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
-