facets 1.3.1 → 1.3.2

data/CHANGELOG

@@ -3,10 +3,16 @@
 == 1.3.1
 * Deprecated string/to_arr, and slightly adjusted string#to_a.
   (Not commonly used so not a major change.)
+* Minor bug fixes.
 
 == 1.3.0
+* Ported parts of Nitro's Glue library to Facets.
+  * more/aspects.rb
+  * core/module/on_included.rb
+  * core/module/expirable.rb
+  * core/enumerable/accumulate.rb
 * Added xoxo.rb, json.rb and rtals.rb.
-* Minor bug fixes.
+* Repaired missing data files for units.rb.
 * Moved cattr methods from module/ to class/.
 * mattr methods are in limbo at the moment.
   (They were aliases for cattr.)

data/ProjectInfo

@@ -2,8 +2,8 @@
 
 title    : Facets
 name     : facets
-version  : '1.3.1'
-date     : '2006-04-17'
+version  : '1.3.2'
+#date     : '2006-04-17'
 status   : Beta/Stable
 
 author   : Thomas Sawyer
@@ -43,7 +43,7 @@ package:
     - web
     - note
 
-testext:
+extest:
   files: 'lib/facets/**/*.rb'
 
 rdoc:
@@ -81,4 +81,5 @@ announce:
   links:
     - http://facets.rubyforge.org
 
+install: ~
 

data/data/facets/index.yml

@@ -92,10 +92,6 @@ module:
 - instance_methods
 - integrate
 - is
-- mattr
-- mattr_accessor
-- mattr_reader
-- mattr_writer
 - memoize
 - modspace
 - namespace
@@ -223,6 +219,7 @@ date:
 - to_time
 gem: 
 - self/active
+- self/gemdir
 - self/gempath
 - self/gemspec
 proc: 

data/lib/facet/gem/self/gemdir.rb

@@ -0,0 +1 @@
+require 'facets/core/gem/self/gemdir.rb'

data/lib/facet/htmlbuilder.rb

@@ -0,0 +1 @@
+require 'facets/more/htmlbuilder.rb'

data/lib/facet/htmlhelper.rb

@@ -0,0 +1 @@
+require 'facets/more/htmlhelper.rb'

data/lib/facet/xmlbuilder.rb

@@ -0,0 +1 @@
+require 'facets/more/xmlbuilder.rb'

data/lib/facet/xmlhelper.rb

@@ -0,0 +1 @@
+require 'facets/more/xmlhelper.rb'

data/lib/facets/core/class/cattr.rb

@@ -1,37 +1,27 @@
 #--
-# Original credit goes to DHH.
+# Credit for original goes to David Heinemeier Hansson.
 #++
 
-class Module
+class Class
 
   # Creates a class-variable attribute that can
   # be accessed both on an instance and class level.
   #
-  # NOTE mattr used to be an alias for cattr,
-  # and likewise for the other cattr methods.
-  # These aliases have been deprecated in favor of
-  # new module/mattr methods that use class-level 
-  # instance variables instead of class variables.
-  # The mattr methods are more versitile.
+  # NOTE These used to be a Module methods. But turns out
+  # these to work as expected when included. The class-level
+  # method is not carried along. So the are now just class
+  # methods. Accordingly, #mattr will eventually be deprecated
+  # so use #cattr instead.
 
   def cattr( *syms )
-    writer = false
-    syms.reject! do |s|
-      case s
-      when TrueClass
-        writer = true
-      when FalseClass, NilClass
-        true
-      else
-        false
-      end
-    end
-    if writer
-      cattr_accessor( *syms )
-    else
-      cattr_reader( *syms )
-    end
+    accessors, readers = syms.flatten.partition { |a| a.to_s =~ /=$/ }
+    writers = accessors.collect{ |e| e.to_s.chomp('=').to_sym }
+    readers.concat( writers )
+    cattr_writer( *writers )
+    cattr_reader( *readers )
+    return readers + accessors
   end
+  alias_method :mattr, :cattr  # deprecate
 
   # Creates a class-variable attr_reader that can
   # be accessed both on an instance and class level.
@@ -45,23 +35,19 @@ class Module
   #   MyClass.new.a       #=> 10
   #
   def cattr_reader( *syms )
-    hsyms = ( syms.last.is_a?(Hash) ? syms.pop : {} )
-    hsyms.update( Hash[*(syms.zip([nil]*syms.size).flatten)] )
-    hsyms.each_pair do |sym, val|
-      class_eval <<-EOS
-        if ! defined? @@#{sym}
-          @@#{sym} = val
-        end
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
         def self.#{sym}
           @@#{sym}
         end
         def #{sym}
-          self.class.#{sym}
+          @@#{sym}
         end
       EOS
     end
-    return hsyms.keys
+    return syms
   end
+  alias_method :mattr_reader, :cattr_reader  # deprecate
 
   # Creates a class-variable attr_writer that can
   # be accessed both on an instance and class level.
@@ -79,23 +65,19 @@ class Module
   #   MyClass.a            #=> 29
   #
   def cattr_writer(*syms)
-    hsyms = ( syms.last.is_a?(Hash) ? syms.pop : {} )
-    hsyms.update( Hash[*(syms.zip([nil]*syms.size).flatten)] )
-    hsyms.each_pair do |sym, val|
-      class_eval <<-EOS
-        if ! defined? @@#{sym}
-          @@#{sym} = val
-        end
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
         def self.#{sym}=(obj)
           @@#{sym} = obj
         end
         def #{sym}=(obj)
-          self.class.#{sym}=(obj)
+          @@#{sym}=(obj)
         end
       EOS
     end
-    return hsyms.keys
+    return syms
   end
+  alias_method :mattr_writer, :cattr_writer  # deprecate
 
   # Creates a class-variable attr_accessor that can
   # be accessed both on an instance and class level.
@@ -115,6 +97,7 @@ class Module
     m.concat( cattr_writer(*syms) )
     m
   end
+  alias_method :mattr_accessor, :cattr_accessor  # deprecate
 
 end
 

data/lib/facets/core/gem.rb

@@ -1,3 +1,4 @@
 require 'facets/core/gem/self/active'
+require 'facets/core/gem/self/gemdir'
 require 'facets/core/gem/self/gempath'
 require 'facets/core/gem/self/gemspec'

data/lib/facets/core/gem/self/gemdir.rb

@@ -0,0 +1,12 @@
+require 'Facets/core/gem/self/gempath'
+
+module Gem
+    
+  def gemdir(gemname, dir)
+    if active?(gemname)
+      File.join(gempath, dir)
+    end
+  end
+    
+end
+

data/lib/facets/core/gem/self/gempath.rb

@@ -3,8 +3,14 @@ require 'facet/gem/self/active'
 
 module Gem
 
-  def self.gempath(gemname)
-    @loaded_specs[gemname].full_gem_path if active?(gemname)
+  def self.gempath(gemname, subdir=nil)
+    if active?(gemname)
+      if subdir
+        File.join( @loaded_specs[gemname].full_gem_path, subdir )
+      else
+        @loaded_specs[gemname].full_gem_path
+      end
+    end
   end
 
 end

data/lib/facets/core/kernel/as.rb

@@ -19,7 +19,7 @@ module Kernel
   #
   #   C.new.x  #=> 1
   #
-  def as( klass=nil, &blk )
+  def __as__( klass=nil, &blk )
     selfclass = Kernel.instance_method(:class).bind(self).call
     klass ||= selfclass.superclass
     if selfclass.ancestors.include?(klass)
@@ -31,6 +31,8 @@ module Kernel
     end
   end
 
+  alias_method :as, :__as__
+
 =begin :nodoc:
   def as( role, &blk )
     unless role.is_a?(Class)

data/lib/facets/core/module.rb

@@ -20,10 +20,6 @@ require 'facets/core/module/initializer'
 require 'facets/core/module/instance_methods'
 require 'facets/core/module/integrate'
 require 'facets/core/module/is'
-require 'facets/core/module/mattr'
-require 'facets/core/module/mattr_accessor'
-require 'facets/core/module/mattr_reader'
-require 'facets/core/module/mattr_writer'
 require 'facets/core/module/memoize'
 require 'facets/core/module/modspace'
 require 'facets/core/module/namespace'

data/lib/facets/more/aspects.rb

@@ -1,7 +1,5 @@
 require 'facet/inheritor'
 
-module Glue
-
 # An Aspect is a class that defines advices.
 
 class Aspect
@@ -30,7 +28,7 @@ end
 #   wrap Benchmark, :on => :index
 #   post :taraa, :on => login
 # end
-# 
+#
 # module Timestamped
 #   pre :on => :og_insert { |this| this.create_time = Time.now }
 #   pre :on => :og_update { |this| this.update_time = Time.now }
@@ -48,12 +46,12 @@ module Aspects
 
   def self.wrap(target, methods = target.instance_methods)
     include_advice_modules(target)
-    
+
     for m in [methods].flatten
       args = []
       target.instance_method(m).arity.times { |i| args << "a#{i}" }
       args = args.join(',')
-      
+
       target.module_eval <<-end_eval, __FILE__, __LINE__ 
         alias_method :__unwrapped_#{m}, :#{m}
         def #{m}(#{args})  
@@ -74,11 +72,11 @@ module Aspects
   def self.include_advice_modules(target)
     add_advices = []
     del_advices = []
-    
+
     for a in target.advices
       if a.code.is_a?(Module) and (!a.code.class.ancestors.include?(Class))
         target.module_eval %{ include #{a.code} }
-        
+
         options = a.options.reject { |k,v| k == :pre || k == :post }
 
         method = (a.options[:pre] || 'pre').to_s
@@ -86,32 +84,32 @@ module Aspects
           options.update(:where => :prepend, :join => :pre)
           add_advices <<  Advice.new(method.to_sym, options)
         end
-        
+
         method = (a.options[:post] || 'post').to_s
         if a.code.instance_methods.include?(method)
           options.update(:where => :append, :join => :post)
           add_advices <<  Advice.new(method.to_sym, options)
         end
-        
+
         del_advices << a
       end
     end
 
     # Delete the original advices.
-    
+
     for a in del_advices
       target.advices!.delete(a)
     end
-    
+
     # Add the new advices.
-    
+
     target.advices!.concat(add_advices)
   end
 
   # Generates the code to call the aspects.
-  
+
   def self.gen_advice_code(method, advices, join = :pre) # :nodoc: 
-    code = '' 
+    code = ''
 
     advices.each_with_index do |advice, idx|
       o = options = advice.options
@@ -121,7 +119,7 @@ module Aspects
       elsif except = options[:except]
         next if [except].flatten.include?(method.to_sym)
       end
-      
+
       advice = advice.code
 
       if advice.is_a?(Symbol) or advice.is_a?(String)
@@ -144,9 +142,9 @@ module Aspects
         end
       end
     end
-    
+
     return code
-  end  
+  end
 
   def self.append_features(base)
     super
@@ -155,7 +153,7 @@ module Aspects
   end
 
   module ClassMethods
-  
+
     # Add a pre (before) advice.
 
     def pre(*args, &block)
@@ -170,17 +168,15 @@ module Aspects
       else
         new_advices = args.collect { |a| Advice.new(a, options) }
       end
-=begin      
-      if options[:where] == :prepend
-        self.advices = advices + self.advices
-      else
-        self.advices = self.advices + advices
-      end
-=end
+#       if options[:where] == :prepend
+#         self.advices = advices + self.advices
+#       else
+#         self.advices = self.advices + advices
+#       end
       self.advices!.concat(new_advices)
     end
     alias_method :before, :pre
-    
+
     # Add a post (after) advice.
 
     def post(*args, &block)
@@ -195,20 +191,18 @@ module Aspects
       else
         new_advices = args.collect { |a| Advice.new(a, options) }
       end
-=begin      
-      if options[:where] == :prepend
-        self.advices = advices + self.advices
-      else
-        self.advices = self.advices + advices
-      end
-=end      
+#       if options[:where] == :prepend
+#         self.advices = advices + self.advices
+#       else
+#         self.advices = self.advices + advices
+#       end
       self.advices!.concat(new_advices)
     end
     alias_method :after, :post
 
     # Add a wrap (arround) aspect. An aspect is a class that 
     # responds to the before and after advices.  
-  
+
     def wrap(*args)
       o = options = {
         :pre => :pre,
@@ -223,8 +217,6 @@ module Aspects
     alias_method :around, :wrap
     alias_method :observer, :wrap
 
-  end  
-
-end
+  end
 
 end

data/lib/facets/more/basicobject.rb

@@ -16,16 +16,16 @@
 # ==========================================================================
 #  Revision History
 # ==========================================================================
-#  2006.04.03
-#  * added #instance method.
+#  2006.04.03  trans
+#  * Got rid of ^object_ exclusion.
 #
-#  2005.10.26
-#  * preserved a few addtional methods --everyhting ending in ?, dup and
+#  2005.10.26  trans
+#  * Preserved a few addtional methods --everyhting ending in ?, dup and
 #    object_id.
-#  * changed name from BlankSlate to BasicObject
+#  * Changed name from BlankSlate to BasicObject
 #
 #  2005.04.28  trans
-#  * ported from BlankSlate and added __class__
+#  * Ported from BlankSlate and added __class__.
 # ==========================================================================
 #
 # TODO Might be nice it there were a factory method to alter which methods
@@ -47,13 +47,13 @@ require 'facets/core/kernel/__class__'
 #
 # The pattern used to reserve methods is:
 #
-#   /(^__|^instance_|^object_|^null$|^inspect$|^dup$|\?$)/
+#   /(^__|^instance_|^initialize$|^null$|^inspect$|^dup$|^clone$\?$)/
 #
 # By default these are the reserved methods:
 #
-#   __id__ __class__ __self__ __send__ dup eql? equal? frozen? inspect instance_eval
-#   instance_of? instance_variable_get instance_variable_set instance_variables
-#   is_a? kind_of? nil? null object_id respond_to? tainted?
+#   __id__ __class__ __self__ __send__ clone dup eql? equal? frozen? initialize
+#   inspect instance_eval instance_of? instance_variable_get instance_variable_set
+#   instance_variables is_a? kind_of? nil? null respond_to? tainted?
 #
 # The special method #__self__ allows access to the underlying object via a
 # specialized Functor-style class called, BasicObject::Self. This binds the
@@ -70,63 +70,102 @@ require 'facets/core/kernel/__class__'
 
 class BasicObject
 
+  # The Self class allows one to get access the hidden Object/Kernel methods.
+  # It is essentially a specialized Functor which binds an Object/Kernel
+  # method to the current object for the current call.
+
+  class Self < self
+    def method_missing(meth, *args, &blk)
+      Object.instance_method(meth).bind(self).call(*args, &blk)
+    end
+  end
+
+  # Returns the Self functor class, which can then be used to
+  # call Kernel/Object methods on the current object.
+
+  def __self__
+    @__self__ ||= Self.new
+  end
+
+  # Shodow some important methods.
   alias_method :__method__, :method
 
-  #EXCLUDE = /^(__id__|__send__)$/
-  EXCLUDE = /(^__|^instance_|^object_|^null$|^inspect$|^dup$|\?$)/
+  # Methods not to get rid of. They are too important.
+  #EXCLUDE = /^(__|instance_eval$)/
+  EXCLUDE = /(^__|^instance_|^initialize$|^initialize_copy$|^null$|^inspect$|^dup$|^clone$|\?$)/
 
   def self.hide(name)
     #if instance_methods.include?(name.to_s) and name !~ EXCLUDE #/^(#{EXCLUDE.join('|')})/
-    if method_defined?(name) and name !~ EXCLUDE
+    if name !~ EXCLUDE and
+       ( public_instance_methods.include?(name.to_s) or
+         private_instance_methods.include?(name.to_s) or
+         protected_instance_methods.include?(name.to_s)
+       )
       undef_method name
     end
   end
 
-  instance_methods.each { |m| hide(m) }
-
-  class Self < self
-    define_method( :method_missing ) do |meth, *args|  # &blk|
-      Object.instance_method(meth).bind(self).call(*args) # ,&blk)
-    end
-  end
-
-  def __self__
-    @__self__ ||= Self.new
-  end
+  # remove all methods
+  public_instance_methods(true).each { |m| hide(m) }
+  private_instance_methods(true).each { |m| hide(m) }
+  protected_instance_methods(true).each { |m| hide(m) }
 
 end
 
 # Since Ruby is very dynamic, methods added to the ancestors of
 # BasicObject <em>after BasicObject is defined</em> will show up in the
-# list of available BasicObject methods.  We handle this by defining a hook
-# in the Object and Kernel classes that will hide any defined.
+# list of available BasicObject methods.  We handle this by defining
+# hooks in Object, Kernel and Module that will hide any defined.
 
 module Kernel
   class << self
     madded = method(:method_added)
     define_method(:method_added) do |name|
-      #return if name == :kernel_method_added
       r = madded.call(name)
-      return if self != Kernel
+      return r if self != Kernel
       BasicObject.hide(name)
       r
     end
   end
 end
 
+# See Kernel callback.
+
 class Object
   class << self
     madded = method(:method_added)
     define_method(:method_added) do |name|
-      #return if name == :object_method_added
       r = madded.call(name)
-      return if self != Object
+      return r if self != Object
       BasicObject.hide(name)
       r
     end
   end
 end
 
+# Also, modules included into Object need to be scanned and have their
+# instance methods removed from blank slate.  In theory, modules
+# included into Kernel would have to be removed as well, but a
+# "feature" of Ruby prevents late includes into modules from being
+# exposed in the first place.
+=begin
+class Module
+  if method_defined?(:append_features)
+    mappended = method(:append_features)
+  else
+    mappended = nil
+  end
+  define_method(:append_features) do |mod|
+    r = mappended.call(mod) if mappended
+    return r if mod != Object
+    public_instance_methods(true).each { |name| BasicObject.hide(name) }
+    private_instance_methods(true).each { |name| BasicObject.hide(name) }
+    public_instance_methods(true).each { |name| BasicObject.hide(name) }
+    r
+  end
+end
+=end
+
 
 #  _____         _
 # |_   _|__  ___| |_