facets 2.6.0 → 2.7.0

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

@@ -0,0 +1,34 @@
+class Module
+
+  # Like attr_writer, but the writer method validates the
+  # setting against the given block.
+  #
+  # CREDIT: ?
+
+  def attr_validator(*symbols, &validator)
+    made = []
+    symbols.each do |symbol|
+      define_method "#{symbol}=" do |val|
+        unless validator.call(val)
+          raise ArgumentError, "Invalid value provided for #{symbol}"
+        end
+        instance_variable_set("@#{symbol}", val)
+      end
+      made << "#{symbol}=".to_sym
+    end
+    made
+  end
+
+  # Create aliases for validators.
+
+  def alias_validator(*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/{class_extension.rb → module/class_extend.rb}

@@ -11,7 +11,7 @@
 #       puts 'inst_meth'
 #     end
 #
-#     class_extension do
+#     class_extend do
 #       def class_meth
 #         "Class Method!"
 #       end
@@ -53,8 +53,6 @@ class Module
 
   alias_method :append_features_without_class_extension, :append_features
 
-  # = class_extension
-  #
   # Normally when including modules, class/module methods are not
   # extended. To achieve this behavior requires some clever
   # Ruby Karate. Instead class_extension provides an easy to use
@@ -66,7 +64,7 @@ class Module
   #       puts 'inst_meth'
   #     end
   #
-  #     class_extension do
+  #     class_extend do
   #       def class_meth
   #         "Class Method!"
   #       end
@@ -79,35 +77,45 @@ class Module
   #
   #   X.class_meth  #=> "Class Method!"
   #
-
-  def class_extension(&block)
+  # NOTE: This old #class_extension version of this method
+  # did not extend the containing class automatically --it had
+  # to be done by hand. With #class_extend, that is no longer
+  # the case.
+  #
+  def class_extend(*mods, &block)
     @class_extension ||= Module.new do
       def self.append_features(mod)
         append_features_without_class_extension(mod)
       end
     end
+    @class_extension.__send__(:include, *mods)
     @class_extension.module_eval(&block) if block_given?
+    extend(@class_extension)  # extend this module too
     @class_extension
   end
 
-  private :class_extension
+  # TODO: DEPRECATE
+  alias_method :class_extension, :class_extend
 
+  #private :class_extend
+
+  # Override +append_features+ to handle class-inheritable extensions.
   def append_features(mod)
     append_features_without_class_extension(mod)
-    mod.extend(class_extension)
+    mod.extend(class_extend)
     if mod.instance_of? Module
-      mod.__send__(:class_extension).__send__(:include, class_extension)
+      mod.__send__(:class_extend).__send__(:include, class_extend)
     end
   end
 
 end
 
 class Class
-  # For a class #class_extension is the same as class_eval.
-  # The alternative is to "undef_method :class_extension",
+  # For Class, #class_extend is the same as class_eval.
+  # The alternative is to "undef_method :class_extend",
   # but this seems uneccessarily limited.
-
-  def class_extension(&blk)
+  #
+  def class_extend(&blk)
     class_eval(&blk)
   end
 end

data/lib/more/facets/once.rb

@@ -0,0 +1,59 @@
+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/openmodule.rb

@@ -1,3 +1,4 @@
+#
 class OpenModule < Module
 
   def initialize(&block)

data/lib/more/facets/orderedhash.rb

@@ -1,37 +1,5 @@
-# = 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
-
+# Ordered hash is the same as a Dictionary.
 OrderedHash = Dictionary
 
-# = AutoOrderedHash
-#
-# AutoOrderedHash is an alias for the AutoDictionary class
-
-#AutoOrderedHash = AutoDictionary  # was replaced by Dictionary.auto() (or autonew?)
-

data/lib/more/facets/ostructable.rb

@@ -30,15 +30,13 @@
 #
 #++
 
-#:title: OpenStructable
-#
 # OpensStructable is a mixin module which can provide OpenStruct behavior to
 # any class or object. OpenStructable allows extention of data objects
 # with arbitrary attributes.
 #
 # == Usage
 #
-#   require 'mega/ostructable'
+#   require 'ostructable'
 #
 #   class Record
 #     include OpenStructable
@@ -58,7 +56,6 @@
 # * Yukihiro Matsumoto
 # * Gavin Sinclair (Documentation)
 #
-
 module OpenStructable
 
   def initialize(hash=nil)

data/lib/more/facets/partial.rb

@@ -1,33 +1,23 @@
-# MissingArgument exception class is used to represent an argument "hole".
-
-class MissingArgument < ArgumentError
-end
-
-# Convenience method for an argument hole.
-# It simple returns the MissingArgument exception class.
-
-def __
-  MissingArgument
-end
-
 class Proc
 
   # Convert a Proc object into new partial Proc object.
   #
   #   a = proc { |a,b,c| a+b+c }
-  #   b = a.partial(__, 2, __)
+  #   b = a.partial(X,2,X)
+  #   b[1,3] #=> 6
+  #
+  #   a = proc { |a,b,c| a+b+c }
+  #   b = a.partial(__,2,__)
   #   b[1,3] #=> 6
   #
   # This method is similar to Proc#curry.
   #
   # CREDT Trans
-  #
-  # TODO: Parhaps ArgumentError would suffice, and we don't need MissingArgument?
 
   def partial(*args)
     Proc.new do |*spice|
       result = args.collect do |a|
-        MissingArgument == a ? spice.pop : a
+        X == a ? spice.pop : a
       end
       call(*result)
     end
@@ -35,3 +25,15 @@ class Proc
 
 end
 
+# X class is used to represent an argument "slot".
+
+class X < ArgumentError
+end
+
+# Convenience method for an argument slot.
+# It simple returns the X exception class.
+
+def __
+  X
+end
+

data/lib/more/facets/preinitialize.rb

@@ -0,0 +1,157 @@
+# TITLE:
+#
+#   Preinitialize
+#
+# DESCRIPTION:
+#
+#   Presend a module to another module, or to a class.
+#
+# COPYRIGHT:
+#
+#   Copyright (c) 2005 Thomas Sawyer
+#
+# LICENSE:
+#
+#   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
+
+require 'facets/kernel/object'  # for object_class
+
+# = Preinitialize
+#
+# This is an object preinitialize system, which provides
+# an elegant way to initialize an object allowing the
+# class to provide additional default structure to an
+# object prior to calling initialize.
+#
+# In effect it does two things after allocating the object
+# but prior to initializing it.
+#
+# First, it calls the class method #default_instance_variables,
+# which returns a hash and by default returns the hash
+# stored in @default_instance_variables. It uses this to
+# pre-define instance variables.
+#
+# Then it goes to the top of the class hierarchy  and works
+# it's way down calling #preinitialize if defined.
+# WARNING! It is rather useless to use <tt>super</tt>
+# inside the any preinitialize hook.
+#
+#   module M
+#     def preinitialize
+#       @a = 23
+#     end
+#   end
+#
+#   class X
+#     include M
+#     def a ; @a ; end
+#   end
+#
+#   x = X.new
+#   x.a         #=> 23
+#
+# If neded the original new method has been aliased, albeit
+# <tt>postinitialize_new</tt> is probably a bit of a misnomer.
+
+#--
+# class Module
+#
+#   def default_instance_variables(complete=false)
+#     @default_instance_variables ||= {}
+#     unless complete
+#       return @default_instance_variables
+#     else
+#       parent = ancestors[1]
+#       if parent
+#         return @default_instance_variables.merge(parent.default_instance_variables)
+#       else
+#         return @default_instance_variables
+#       end
+#     end
+#   end
+#
+# end
+#++
+
+class Class
+  alias_method :postinitialize_new, :new
+
+  def new(*args, &blk)
+    o = allocate
+
+    #if respond_to?(:default_instance_variables)
+    #  default_instance_variables.each{|k,v| o.instance_variable_set( "@#{k.to_s.gsub(/\W$/,'')}",v )}
+    #end
+
+    a = ancestors
+    until a.empty?
+      m = a.pop
+      #if m.private_instance_methods.include?('preinitialize') or m.public_instance_methods.include?('preinitialize')
+      if m.method_defined?('preinitialize') or m.private_method_defined?('preinitialize')
+        im = instance_method('preinitialize')
+        im.arity == 0 ? im.bind(o).call : im.bind(o).call(*args, &blk)
+      end
+    end
+
+    o.__send__(:initialize, *args, &blk) if o.object_class.private_method_defined?(:initialize)
+
+    o
+  end
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin test
+
+  require 'test/unit'
+
+  class TC_Preinitalize < Test::Unit::TestCase
+
+    module M
+      def preinitialize
+        @a = 10
+      end
+    end
+
+    class X
+      include M
+      def a ; @a ; end
+    end
+
+    class Y < X
+      def initialize
+        super
+      end
+    end
+
+    def test_01
+      x = X.new
+      assert_equal( 10, x.a )
+    end
+
+    def test_01
+      y = Y.new
+      assert_equal( 10, y.a )
+    end
+
+  end
+
+=end