facets 1.0.2 → 1.0.3

data/packages/core/lib/facet/module/cattr_reader.rb

@@ -0,0 +1,2 @@
+# stub
+require 'facet/module/cattr_accessor'

data/packages/core/lib/facet/module/cattr_writer.rb

@@ -0,0 +1,2 @@
+# stub
+require 'facet/module/cattr_accessor'

data/packages/core/lib/facet/module/clone_removing.rb

@@ -0,0 +1,2 @@
+# stub
+require 'facet/module/clone_using.rb'

data/packages/core/lib/facet/module/clone_renaming.rb

@@ -0,0 +1,2 @@
+# stub
+require 'facet/module/clone_using.rb'

data/packages/core/lib/facet/module/clone_using.rb

@@ -0,0 +1,87 @@
+
+class Module
+
+  # Returns an anonymous module with the specified methods
+  # of the receiving module renamed.
+  def clone_renaming( pairs )
+    mod = self.dup
+    pairs.each_pair { |to_sym, from_sym|
+      mod.class_eval {
+        alias_method( to_sym, from_sym )
+        undef_method( from_sym )
+      }
+    }
+    return mod
+  end
+
+  # Returns an anonymous module with the specified methods
+  # of the receiving module removed.
+  def clone_removing( *meths )
+    mod = self.dup
+    methods_to_remove = meths
+    methods_to_remove.each { |m|  mod.class_eval { remove_method m }  }
+    return mod
+  end
+
+  # Returns an anonymous module with only the specified methods
+  # of the receiving module intact.
+  def clone_using( *meths )
+    meths = meths.collect { |m| m.to_s }
+    methods_to_remove = (self.instance_methods - meths)
+    mod = self.dup
+    mod.class_eval { methods_to_remove.each { |m| undef_method m } }
+    return mod
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCModule < Test::Unit::TestCase
+
+    module M
+      def f; 1; end
+      def g; 2; end
+    end
+
+    class Remove
+      include M.clone_removing( :g )
+    end
+
+    class Rename
+      include M.clone_renaming( :q => :g )
+    end
+
+    class Use
+      include M.clone_using( :f )
+    end
+
+    def test_removing
+      assert( Remove.method_defined?(:f) )
+      assert( ! Remove.method_defined?(:g) )
+    end
+
+    def test_renaming
+      assert( ! Rename.method_defined?(:g) )
+      assert( Rename.method_defined?(:f) )
+      assert( Rename.method_defined?(:q) )
+    end
+
+    def test_using_2
+      assert( ! Use.method_defined?(:g) )
+      assert( Use.method_defined?(:f) )
+    end
+
+  end
+
+=end

data/packages/core/lib/facet/module/dirname.rb

@@ -0,0 +1,42 @@
+class Module
+
+  # Returns the name of module's container module.
+  #
+  #   module Example
+  #     class Demo
+  #     end
+  #   end
+  #
+  #   Demo.name       #=> "Example::Demo"
+  #   Demo.dirname    #=> "Example"
+  #
+  # See also Module#basename.
+  #
+  def dirname
+    name.gsub(/::[^:]*$/, '')
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCModule < Test::Unit::TestCase
+
+    def test_dirname
+      assert_equal( 'Test::Unit', ::Test::Unit::TestCase.dirname )
+    end
+
+  end
+
+=end
+

data/packages/core/lib/facet/module/equate_on.rb

@@ -0,0 +1,70 @@
+#--
+# NOTE Better off as a parameterized module?
+#++
+
+class Module
+
+  # Generates identity/key methods based on specified attributes.
+  #
+  #  equate_on :a, :b
+  #
+  # _is equivalent to_
+  #
+  #   def ==(o)
+  #     self.a == o.a && self.b == o.b
+  #   end
+  #
+  #   def eql?(o)
+  #     self.a.eql?(o.a) && self.b.eql?(o.b)
+  #   end
+  #
+  #   def hash()
+  #     self.a.hash ^ self.b.hash
+  #   end
+  #
+  def equate_on(*fields)
+    code = ""
+    code << "def ==(o) "   << fields.map {|f| "self.#{f} == o.#{f}" }.join(" && ")    << " end\n"
+    code << "def eql?(o) " << fields.map {|f| "self.#{f}.eql?(o.#{f})" }.join(" && ") << " end\n"
+    code << "def hash() "  << fields.map {|f| "self.#{f}.hash" }.join(" ^ ")          << " end\n"
+    class_eval( code )
+    fields
+  end
+
+  # Deprecated usage.
+  alias_method :key_attributes, :equate_on
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCModule < Test::Unit::TestCase
+
+    def test_equate_on
+      c = Class.new
+      c.class_eval { attr_accessor :a, :b ; equate_on :a,:b }
+      c1,c2 = c.new,c.new
+      c1.a = 10; c1.b = 20
+      c2.a = 10; c2.b = 20
+      assert_equal( c1, c2 )
+      c1.a = 10; c1.b = 10
+      c2.a = 10; c2.b = 20
+      assert_not_equal( c1, c2 )
+      c1.a = 10; c1.b = 20
+      c2.a = 20; c2.b = 20
+      assert_not_equal( c1, c2 )
+    end
+
+  end
+
+=end

data/packages/core/lib/facet/module/generate_instance_method_name.rb

@@ -0,0 +1,47 @@
+
+class Module
+
+  # Generates a new symbol that is unique among the
+  # inctance methods of the class/module. If a name
+  # argument is given, it will generate a similar name.
+  #
+  #   Class.generate_instance_method_name( :class ) => :_clast_
+  #
+  def generate_instance_method_name( name='a' )
+    s = name.to_s
+    while self.method_defined?( "_#{s}_" )
+      s = s.succ
+    end
+    return :"_#{s}_"
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCModule < Test::Unit::TestCase
+
+    class MockObject
+      def a ; end
+      def b ; end
+      def c ; end
+      def _c ; end
+    end
+
+    def test_generate_instance_method_name
+      assert_nothing_raised { MockObject.generate_instance_method_name(:b) }
+    end
+
+  end
+
+=end

data/packages/core/lib/facet/module/include_as.rb

@@ -0,0 +1,102 @@
+
+require 'delegate'
+
+class Module
+
+  # Include a module via a specified namespace.
+  #
+  #   module T
+  #     def t ; "HERE" ; end
+  #   end
+  #
+  #   class X
+  #     include_as :test => T
+  #     def t ; test.t ; end
+  #   end
+  #
+  #   X.new.t  #=> "HERE"
+  #
+  def include_as( h )
+    h.each{ |name, mod|
+      s = self
+      c = Class.new(SimpleDelegator) {
+        include mod
+        define_method(:initialize) { |s| super(s) }
+      }
+      class_eval {
+        define_method( name ) {
+          instance_variable_set( "@#{name}", instance_variable_get( "@#{name}" ) || c.new(s) )
+        }
+      }
+    }
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCModule < Test::Unit::TestCase
+
+    module MockModule
+      def mm; 77; end
+    end
+
+    class MockObject
+      include_as :mod => MockModule
+    end
+
+    def test_include_as
+      m = MockObject.new
+      assert_equal( 77, m.mod.mm )
+    end
+
+  end
+
+=end
+
+
+# devlopment testing
+
+=begin
+
+if __FILE__ == $0
+
+  # test
+
+  module T
+    def t ; p self ; end
+    def r ; p self ; end
+    def q ; super ; end
+  end
+
+  class N
+    def q ; puts "ho" ; end
+  end
+
+  class X < N
+    include_as :test => T
+
+    def n ; p test ; end
+    def m ; test.t ; end
+    def o ; test.r ; end
+  end
+
+  x = X.new
+  x.n
+  x.m
+  x.o
+  x.q
+
+end
+
+=end

data/packages/core/lib/facet/module/initializer.rb

@@ -0,0 +1,65 @@
+
+class Module
+
+  # Automatically create an initializer assigning the given 
+  # arguments.
+  #
+  #   class MyClass
+  #     initializer(:a, "b", :c)
+  #   end
+  #
+  # _is equivalent to_
+  #
+  #   class MyClass
+  #     def initialize(a, b, c)
+  #       @a,@b,@c = a,b,c
+  #     end
+  #   end
+  #
+  # Downside: Initializers defined like this can't take blocks.
+  # This can be fixed when Ruby 1.9 is out.
+  #
+  # The initializer will not raise an Exception when the user
+  # does not supply a value for each instance variable. In that
+  # case it will just set the instance variable to nil. You can
+  # assign default values or raise an Exception in the block.
+  #
+  def initializer(*attributes, &block)
+    define_method(:initialize) do |*args|
+      attributes.zip(args) do |sym, value|
+        instance_variable_set(:"@#{sym}", value)
+      end
+
+      instance_eval(&block) if block
+    end
+  end
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  class TCModule < Test::Unit::TestCase
+
+    def test_attr_initializer
+      cc = Class.new
+      cc.class_eval {
+        initializer :ai
+        attr_reader :ai
+      }
+      c = cc.new(10)
+      assert_equal( 10, c.ai )
+    end
+
+  end
+
+=end

data/packages/core/lib/facet/module/instance_methods.rb

@@ -0,0 +1,186 @@
+require 'facet/symbol/not'
+
+class Module
+
+  METHOD_TYPES = [ :inherited, :ancestors, :local,
+                   :public, :private, :protected,
+                   :all ]
+
+  # Provides an improved method lookup routnine.
+  # It returns a list of methods according to symbol(s) given.
+  #
+  # Recognized symbols are:
+  #
+  # * <tt>:public</tt>     include public methods
+  # * <tt>:private</tt>    include private methods
+  # * <tt>:protected</tt>  include protected methods
+  # * <tt>:ancestors</tt>  include all ancestor's methods
+  # * <tt>:inherited</tt>  (same as above)
+  # * <tt>:local</tti>     include non-ancestor methods
+  # * <tt>:all</tt>        include all of the above
+  #
+  # This method also uses the symbol-not system. So you can specify
+  # the inverse of all of the above. For instance ~:public would mean
+  # :private, :protected (see facet/symbol/not).
+  #
+  # If no symbol is given then :public, :local is assumed.
+  # Unrecognized symbols raise an error.
+  #
+  #   module Demo
+  #     def test
+  #       puts("Hello World!")
+  #     end
+  #   end
+  #
+  #   Demo.instance_methods(:local)    #=> ['test']
+  #
+  # To maintain backward compatibility <tt>true</tt> as an intitial argument
+  # is converted to :local, :ancestors (i.e. it includes both).
+  #
+  def instance_methods(*args)
+
+    # for backward compatibility
+    args << true if args.empty?
+    case args[0]
+    when TrueClass
+      args.shift
+      args << :ancestors
+      args << :local
+    when FalseClass
+      args.shift
+      args << :local
+    end
+
+    # default public, local
+    args |= [:public] unless [:publix,:private,:protected,:all].any?{ |a| args.include?(a) }
+    args |= [:ancestors,:local] unless [:ancestors,:inherited,:local,:all].any?{ |a| args.include?(a) }
+
+    raise ArgumentError if args.any?{ |a| ! METHOD_TYPES.include?(a) }
+
+    pos, neg = args.partition { |s| ! s.not? }
+
+    m = []
+
+    pos.each do |n|
+      case n
+      when :inherited, :ancestors
+        m |= ( public_instance_methods( true ) - public_instance_methods( false ) )       if pos.include?(:public)
+        m |= ( private_instance_methods( true ) - private_instance_methods( false ) )     if pos.include?(:private)
+        m |= ( protected_instance_methods( true ) - protected_instance_methods( false ) ) if pos.include?(:protected)
+      when :local
+        m |= public_instance_methods( false )    if pos.include?(:public)
+        m |= private_instance_methods( false )   if pos.include?(:private)
+        m |= protected_instance_methods( false ) if pos.include?(:protected)
+      when :all
+        m |= public_instance_methods( true )
+        m |= private_instance_methods( true )
+        m |= protected_instance_methods( true )
+      end
+    end
+
+    neg.each do |n|
+      case n
+      when :public
+        m -= public_instance_methods( true )
+      when :private
+        m -= private_instance_methods( true )
+      when :protected
+        m -= protected_instance_methods( true )
+      when :inherited, :ancestors
+        m -= ( public_instance_methods( true ) - public_instance_methods( false ) )
+        m -= ( private_instance_methods( true ) - private_instance_methods( false ) )
+        m -= ( protected_instance_methods( true ) - protected_instance_methods( false ) )
+      when :local
+        m -= public_instance_methods( false )
+        m -= private_instance_methods( false )
+        m -= protected_instance_methods( false )
+      end
+    end
+
+    m.sort
+  end
+
+# old-version
+#     args << :public unless ( args.include?(:private) or args.include?(:protected) )
+#     args[0] = [ :ancestors, :local ] if TrueClass === args[0]
+#     args.flatten!
+#     raise ArgumentError if args.any?{ |a| ! METHOD_SYMBOLS.include?(a) }
+#     m = []
+#     a = args.include?( :all )
+#     i = ( args.include?( :inherited ) or args.include?( :ancestors ) )
+#     l = ( args.include?( :local ) or args.include?( :no_ancestors ) )
+#     if a
+#       m |= public_instance_methods( true )
+#       m |= private_instance_methods( true )
+#       m |= protected_instance_methods( true )
+#     elsif i and l
+#       m |= public_instance_methods( true ) if args.include?( :public )
+#       m |= private_instance_methods( true ) if args.include?( :private )
+#       m |= protected_instance_methods( true ) if args.include?( :protected )
+#     elsif i
+#       m |= (public_instance_methods( true ) - public_instance_methods( false )) if args.include?( :public )
+#       m |= (private_instance_methods( true ) - private_instance_methods( false )) if args.include?( :private )
+#       m |= (protected_instance_methods( true ) - protected_instance_methods( false )) if args.include?( :protected )
+#     else
+#       m |= public_instance_methods( ! l ) if args.include?( :public )
+#       m |= private_instance_methods( ! l ) if args.include?( :private )
+#       m |= protected_instance_methods( ! l ) if args.include?( :protected )
+#     end
+#     m
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+=begin test
+
+  require 'test/unit'
+
+  # fixture
+
+  class O
+    def a ; end
+  end
+
+  # get a hold of the original definition _before require_
+  $imF = Module.instance_method( :instance_methods )
+
+  class TC_Methods < Test::Unit::TestCase
+
+    def test_instance_methods
+      assert_equal( $imF.bind(O).call.sort, O.instance_methods )
+    end
+
+    def test_instance_methods_true
+      assert_equal( $imF.bind(O).call(true).sort, O.instance_methods(true) )
+    end
+
+    def test_public_instance_methods
+      assert_equal( O.public_instance_methods.sort, O.instance_methods )
+    end
+
+    def test_private_instance_methods
+      assert_equal( O.private_instance_methods.sort, O.instance_methods(:private) )
+    end
+
+    def test_protected_instance_methods
+      assert_equal( O.protected_instance_methods.sort, O.instance_methods(:protected) )
+    end
+
+    def test_local_instance_methods
+      assert_equal( ["a"], O.instance_methods(:local) )
+    end
+
+    def test_instance_method_local_and_ancestors
+      assert_equal( $imF.bind(O).call(true).sort, O.instance_methods(:local, :ancestors) )
+    end
+
+  end
+
+=end