facets 1.7.46 → 1.8.0

data/lib/facets/more/openobject.rb

@@ -1,188 +1,13 @@
-# = openobject.rb
-#
-# == Copyright (c) 2005,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.
-#
-# == Authors and Contributors
-#
-# * Thomas Sawyer
-# * George Moschovitis
+# TO BE DEPRECTATED!!!
 
-# Author::    Thomas Sawyer
-# Copyright:: Copyright (c) 2005 Thomas Sawyer
-# License::   Ruby License
+require 'facets/more/openhash'
 
-require 'facets/core/hash/to_h'
-require 'facets/core/hash/to_proc'
-require 'facets/core/hash/symbolize_keys'
-require 'facets/core/kernel/object_class'
-require 'facets/core/kernel/object_hexid'
-
-#require 'facets/more/methodfilter'
-
-# = OpenObject
-#
-# OpenObject is similar to OpenStruct, but differs in a couple ways.
-#
-# OpenObject is a subclass of Hash and can do just about everything
-# a Hash can do, except that most public methods have been made
-# protected and thus only available internally or via #send.
-# A small number, like #each are stillexposed publically though
-# b/c of their importance.
-#
-# 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 careful. OpenObject should be used in highly
-# controlled scenarios. If you want to pass one off to a general
-# rountine, it is best to convert it to a Hash first and convert it
-# back to an OpenObject when finished. To facilitate this the method
-# #as_hash! is provided.
-#
-#   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.
-#
-#--
-# Also, 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
-#++
-
-class OpenObject < Hash
-
-  PUBLIC_METHODS = /(^__|^instance__|^object__|^\W|^send$|^class$|\?$)/
-
-  protected *public_instance_methods.select{ |m| m !~ PUBLIC_METHODS }
-
-  def self.[](hash=nil)
-    new(hash)
-  end
-
-  # Inititalizer for OpenObject is slightly differnt than taht 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() super end
-
-  def to_hash() super 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
-
-  # Set the default value.
-
-  def default!(default)
-    self.default = default
-  end
-
-  # Preform action on OpenObject as if it were a regular Hash.
-
-  def as_hash!
-    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)
-    super(k.to_sym,v)
-    define_slot(k)
-  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 )
-      (class << self; self; end).class_eval {
-        protected key rescue nil
-        #def #{key}()   self[:#{key}]    end
-        #def #{key}=(o) self[:#{key}]=o  end
-      }
-      self[key.to_sym] = value if value
-    end
-
-    def merge( other )
-      d = dup
-      d.send(:update, other)
-      d
-    end
-
-    def update( other )
-      other.each { |k,v| define_slot(k,v) }
-    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
-
-end
+OpenObject = OpenHash
 
 # Core Extensions
 
 class NilClass
-  # Nil converts to an empty OpenObject.
+  # Nil converts to an empty OpenHash.
 
   def to_openobject
     OpenObject.new
@@ -190,7 +15,7 @@ class NilClass
 end
 
 class Hash
-  # Convert a Hash into an OpenObject.
+  # Convert a Hash into an OpenHash.
 
   def to_openobject
     OpenObject[self]
@@ -198,145 +23,23 @@ class Hash
 end
 
 class Proc
-  # Translates a Proc into an OpenObject. By droping an OpenObject into
+  # Translates a Proc into an OpenHash. By droping an OpenHash into
   # the Proc, the resulting assignments incured as the procedure is
-  # evaluated produce the OpenObject. This technique is simlar to that
+  # evaluated produce the OpenHash. This technique is simlar to that
   # of MethodProbe.
   #
   #   p = lambda { |x|
   #     x.word = "Hello"
   #   }
-  #   o = p.to_openobject
+  #   o = p.to_openhash
   #   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
+    raise ArgumentError, 'bad arity for converting Proc to openhash' if arity != 1
     o = OpenObject.new
     self.call( o )
     o
   end
 end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-  require 'test/unit'
-
-  class TestOpenObject1 < Test::Unit::TestCase
-
-    def test_1_01
-      o = OpenObject.new
-      assert( o.respond_to?(:key?) )
-    end
-
-    def test_1_02
-      assert_instance_of( OpenObject, OpenObject[{}] )
-    end
-
-    def test_1_03
-      f0 = OpenObject.new
-      f0[:a] = 1
-      #assert_equal( [1], f0.to_a )
-      assert_equal( {:a=>1}, f0.to_h )
-    end
-
-    def test_1_04
-      f0 = OpenObject[:a=>1]
-      f0[:b] = 2
-      assert_equal( {:a=>1,:b=>2}, f0.to_h )
-    end
-
-    def test_1_05
-      f0 = OpenObject[:class=>1]
-      assert_equal( 1, f0.class )
-    end
-  end
-
-  class TestOpenObject2 < Test::Unit::TestCase
-
-    def test_2_01
-      f0 = OpenObject[:f0=>"f0"]
-      h0 = { :h0=>"h0" }
-      assert_equal( OpenObject[:f0=>"f0", :h0=>"h0"], f0.send(:merge,h0) )
-      assert_equal( {:f0=>"f0", :h0=>"h0"}, h0.merge( f0 ) )
-    end
-
-    def test_2_02
-      f1 = OpenObject[:f1=>"f1"]
-      h1 = { :h1=>"h1" }
-      f1.send(:update,h1)
-      h1.update( f1 )
-      assert_equal( OpenObject[:f1=>"f1", :h1=>"h1"], f1 )
-      assert_equal( {:f1=>"f1", :h1=>"h1"}, h1 )
-    end
-
-    def test_2_03
-      o = OpenObject[:a=>1,:b=>{:x=>9}]
-      assert_equal( 9, o[:b][:x] )
-      assert_equal( 9, o.b[:x] )
-    end
-
-    def test_2_04
-      o = OpenObject["a"=>1,"b"=>{:x=>9}]
-      assert_equal( 1, o["a"] )
-      assert_equal( 1, o[:a] )
-      assert_equal( {:x=>9}, o["b"] )
-      assert_equal( {:x=>9}, o[:b] )
-      assert_equal( 9, o["b"][:x] )
-      assert_equal( nil, o[:b]["x"] )
-    end
-
-  end
-
-  class TestOpenObject3 < Test::Unit::TestCase
-    def test_3_01
-      fo = OpenObject.new
-      9.times{ |i| fo.send( "n#{i}=", 1 ) }
-      9.times{ |i|
-        assert_equal( 1, fo.send( "n#{i}" ) )
-      }
-    end
-  end
-
-  class TestOpenObject4 < Test::Unit::TestCase
-
-    def test_4_01
-      ho = {}
-      fo = OpenObject.new
-      5.times{ |i| ho["n#{i}".to_sym]=1 }
-      5.times{ |i| fo.send( "n#{i}=", 1 ) }
-      assert_equal(ho, fo.to_h)
-    end
-
-  end
-
-  class TestOpenObject5 < Test::Unit::TestCase
-
-    def test_5_01
-      p = lambda { |x|
-        x.word = "Hello"
-      }
-      o = p.to_openobject
-      assert_equal( "Hello", o.word )
-    end
-
-    def test_5_02
-      p = lambda { |x|
-        x.word = "Hello"
-      }
-      o = OpenObject[:a=>1,:b=>2]
-      assert_instance_of( Proc, o.to_proc )
-    end
-
-  end
-
-=end

data/lib/facets/more/populate.rb

@@ -0,0 +1,37 @@
+# = populate.rb
+
+require 'facet/kernel/populate'
+
+# A class mixin for objects which initialize using a hash or block
+# to simply populate attr_writers/accessors.
+# 
+#   class MyClass
+#     include Populate
+#     attr :a
+#   end
+#
+#   m = MyClass.new(:a=>1)
+#   m.a  #=> 1
+#
+#   m = MyClass.new{ |s| s.a = 1 }
+#   m.a  #=> 1
+#   
+
+module Populate
+
+  # Populating initializer.
+
+  def initialize( data=nil, &block ) #:yield:
+    before_initialize_populate
+    populate(data, &block)
+    after_initialize_populate
+  end
+
+  # When using, a class should generally leave the initializer
+  # alone and just fillout these two callbacks as needed.
+
+  def before_initialize_populate  ; end
+  def after_initialize_populate ; end
+
+end
+

data/lib/facets/more/script.rb

@@ -0,0 +1,157 @@
+# A module which is an instance of the Script class encapsulates in its scope
+# the top-level methods, top-level constants, and instance variables defined in
+# a ruby script file (and its subfiles) loaded by a ruby program. This allows
+# use of script files to define objects that can be loaded into a program in
+# much the same way that objects can be loaded from YAML or Marshal files.
+#
+# See intro.txt[link:files/intro_txt.html] for an overview.
+
+class Script < Module
+  # The file with which the Script was instantiated.
+  attr_reader :main_file
+
+  # The directory in which main_file is located, and relative to which
+  # #load searches for files before falling back to Kernel#load.
+  #attr_reader :dir
+
+  # An array of paths to search for scripts. This has the same
+  # semantics as <tt>$:</tt>, alias <tt>$LOAD_PATH</tt>, excpet
+  # that it is local to this script. The path of the current
+  # script is added automatically (equivalent to '.')
+  attr_reader :load_path
+
+  # A hash that maps <tt>filename=>true</tt> for each file that has been
+  # required locally by the script. This has the same semantics as <tt>$"</tt>,
+  # alias <tt>$LOADED_FEATURES</tt>, except that it is local to this script.
+  attr_reader :loaded_features
+
+  class << self
+    alias load new
+  end
+
+  # Creates new Script, and loads _main_file_ in the scope of the Script. If a
+  # block is given, the script is passed to it before loading from the file, and
+  # constants can be defined as inputs to the script.
+
+  def initialize(main_file, options=nil, &block)
+    extend self
+
+    options ||= {}
+
+    @main_file       = File.expand_path(main_file)
+    @load_path       = options[:load_path] || []
+    #@load_path |= [File.dirname(@main_file)]  # before or after?
+    @loaded_features = options[:loaded_features] || {}
+
+    # TODO In order to load/require at the instance level.
+    # This needs to be in a separate namespace however
+    # b/c it can interfere with what is expected.
+    #[ :require, :load ].each{ |meth|
+    #  m = method(meth)
+    #  define_method(meth) do |*args| m.call(*args) end
+    #}
+
+    module_eval(&block) if block
+    extend self
+
+    load_in_module(main_file)
+  end
+
+  # Lookup feature in load path.
+
+  def load_path_lookup(feature)
+    paths = File.join('{' + @load_path.join(',') + '}', feature + '{,.rb,.rbs}')
+    files = Dir.glob(paths)
+    match = files.find{ |f| ! @loaded_features.include?(f) }
+    return match
+  end
+
+  # Loads _file_ into this Script. Searches relative to the local dir, that is,
+  # the dir of the file given in the original call to
+  # <tt>Script.load(file)</tt>, loads the file, if found, into this Script's
+  # scope, and returns true. If the file is not found, falls back to
+  # <tt>Kernel.load</tt>, which searches on <tt>$LOAD_PATH</tt>, loads the file,
+  # if found, into global scope, and returns true. Otherwise, raises
+  # <tt>LoadError</tt>.
+  #
+  # The _wrap_ argument is passed to <tt>Kernel.load</tt> in the fallback case,
+  # when the file is not found locally.
+  #
+  # Typically called from within the main file to load additional sub files, or
+  # from those sub files.
+  #
+  #--
+  # TODO Need to add load_path lookup.
+  #++
+
+  def load(file, wrap = false)
+    load_in_module(File.join(@dir, file))
+    true
+  rescue MissingFile
+    super
+  end
+
+  # Analogous to <tt>Kernel#require</tt>. First tries the local dir, then falls
+  # back to <tt>Kernel#require</tt>. Will load a given _feature_ only once.
+  #
+  # Note that extensions (*.so, *.dll) can be required in the global scope, as
+  # usual, but not in the local scope. (This is not much of a limitation in
+  # practice--you wouldn't want to load an extension more than once.) This
+  # implementation falls back to <tt>Kernel#require</tt> when the argument is an
+  # extension or is not found locally.
+  #
+  #--
+  # This was using load_in_module rather than include_script. Maybe is still should
+  # and one should have to call include_script instead? Think about this.
+  #++
+
+  def require(feature)
+    file = load_path_lookup(feature)
+    return super unless file
+    begin
+      @loaded_features[file] = true
+      load_in_module(file)
+    rescue MissingFile
+      @loaded_features[file] = false
+      super
+    end
+  end
+
+  # Raised by #load_in_module, caught by #load and #require.
+  class MissingFile < LoadError; end
+
+  # Loads _file_ in this module's context. Note that <tt>\_\_FILE\_\_</tt> and
+  # <tt>\_\_LINE\_\_</tt> work correctly in _file_.
+  # Called by #load and #require; not normally called directly.
+
+  def load_in_module(file)
+    module_eval(IO.read(file), File.expand_path(file))
+  rescue Errno::ENOENT => e
+    if /#{file}$/ =~ e.message
+      raise MissingFile, e.message
+    else
+      raise
+    end
+  end
+
+  def include_script(file)
+    include self.class.new(file, :load_path=>load_path, :loaded_features=>loaded_features)
+  rescue Errno::ENOENT => e
+    if /#{file}$/ =~ e.message
+      raise MissingFile, e.message
+    else
+      raise
+    end
+  end
+
+  #
+  def include(*mods)
+    super
+    extend self
+  end
+
+  def to_s # :nodoc:
+    "#<#{self.class}:#{main_file}>"
+  end
+
+end #class Script