facets 1.1.0 → 1.2.0

data/lib/facet/module/initializer.rb

@@ -1,65 +1 @@
-
-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
+require 'facets/core/module/initializer.rb'

data/lib/facet/module/instance_methods.rb

@@ -1,186 +1 @@
-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
+require 'facets/core/module/instance_methods.rb'

data/lib/facet/module/integrate.rb

@@ -1,51 +1 @@
-
-require 'facet/module/rename'
-require 'facet/module/redef'
-require 'facet/module/remove'
-require 'facet/module/undef'
-require 'facet/module/wrap'
-
-#require 'facet/module/revisal'
-
-class Module
-
-  def integrate( mod, &blk )
-    #include mod.revisal( &blk )
-    m = Module.new { include mod }
-    m.class_eval &blk
-    include m 
-  end
-
-end
-
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-
-=begin testing
-
-  require 'test/unit'
-
-  class TCModule < Test::Unit::TestCase
-    module M
-      def x ; 1 ; end
-    end
-    class C
-      integrate M do
-        rename :y, :x
-      end
-    end
-
-    def test_integrate
-      c = C.new
-      assert_raises( NoMethodError ) { c.x }
-      assert_equal( 1, c.y )
-    end
-  end
-
-=end
+require 'facets/core/module/integrate.rb'

data/lib/facet/module/is.rb

@@ -1,34 +1 @@
-require 'facet/kernel/is'
-
-class Module
-
-  # An alias for #include.
-  #
-  # class X
-  #   is Enumerable
-  # end
-  #
-  alias_method :is, :include
-
-  # Is a given class or module an ancestor of
-  # this class or module?
-  #
-  #  class X ; end
-  #  class Y < X ; end
-  #
-  #   Y.is?(X)  #=> true
-  #
-  def is?( base )
-    ancestors.slice(1..-1).include?( base )
-  end
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-# TODO
+require 'facets/core/module/is.rb'

data/lib/facet/module/memoize.rb

@@ -1,95 +1 @@
-#--
-# Credit goes to Robert Feldt.
-#++
-
-class Module
-
-  # Directive for making your functions faster by trading
-  # space for time. When you "memoize" a method/function
-  # its results are cached so that later calls with the
-  # same arguments returns results in the cache instead
-  # of recalculating them.
-  #
-  #   class T
-  #     def initialize(a)
-  #       @a = a
-  #     end
-  #     def a
-  #       "#{@a ^ 3 + 4}"
-  #     end
-  #     memoize :a
-  #   end
-  #
-  #   t = T.new
-  #   t.a.__id__ == t.a.__id__  #=> true
-  #
-  def memoize(*meths)
-    @_MEMOIZE_CACHE ||= Hash.new
-    meths.each do |meth|
-      mc = @_MEMOIZE_CACHE[meth] = Hash.new
-      old = instance_method(meth)
-      new = proc do |*args|
-        if mc.has_key? args
-          mc[args]
-        else
-          mc[args] = old.bind(self).call(*args)
-        end
-      end
-      send(:define_method, meth, &new)
-    end
-  end
-
-end
-
-# This allows memoize to work in main and instance scope too.
-#--
-# Would this be good to have? Will need to modify for instance level, if so.
-#++
-#def memoize(*args)
-#  self.class.memoize(*args)
-#end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class T
-    def initialize(a)
-      @a = a
-    end
-    def a
-      "#{@a ^ 3 + 4}"
-    end
-    memoize :a
-  end
-
-  # test
-
-  class TC_Memoize < Test::Unit::TestCase
-
-    def setup
-      @t = T.new(2)
-    end
-
-    def test_memoize_01
-      assert_equal( @t.a, @t.a )
-    end
-
-    def test_memoize_02
-      assert_equal( @t.a.__id__, @t.a.__id__ )
-    end
-
-    def test_memoize_03
-      assert_equal( @t.a.__id__, @t.a.__id__ )
-    end
-
-  end
-
-=end
+require 'facets/core/module/memoize.rb'

data/lib/facet/module/modspace.rb

@@ -1,43 +1 @@
-#require 'facet/module/dirname'
-#require 'facet/kernel/constant'
-
-class Module
-
-  # Returns the module's container module.
-  #
-  #   module Example
-  #     class Demo
-  #     end
-  #   end
-  #
-  #   Demo.modspace    #=> Example
-  #
-  # See also Module#basename.
-  #
-  def modspace
-    eval self.name[ 0...self.name.rindex( '::' ) ]
-  end
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCModule < Test::Unit::TestCase
-
-    def test_modspace
-      assert_equal( Test::Unit, Test::Unit::TestCase.modspace )
-      assert_equal( ::Test::Unit, ::Test::Unit::TestCase.modspace )
-    end
-
-  end
-
-=end
+require 'facets/core/module/modspace.rb'