facets 2.8.4 → 2.9.0.pre.1

data/lib/tour/facets/module/class_accessor.rb

@@ -0,0 +1,27 @@
+class Module
+
+  #
+  def class_accessor(name)
+    class_reader(name)
+    class_writer(name)
+  end
+
+  #
+  def class_reader(name)
+    module_eval(<<-EOS, __FILE__, __LINE__)
+      def self.#{name}
+        @#{name}
+      end
+    EOS
+  end
+
+  #
+  def class_writer(name)
+    module_eval(<<-EOS, __FILE__, __LINE__)
+      def self.#{name}=(x)
+        @#{name} = x
+      end
+    EOS
+  end
+
+end

data/lib/tour/facets/module/class_extend.rb

@@ -0,0 +1,82 @@
+class Module
+
+  # Normally when including modules, class/module methods are not
+  # extended. To achieve this behavior requires some clever
+  # Ruby Karate. Instead #class_extend provides an easy to use
+  # and clean solution. Simply place the extending class methods
+  # in a block of the special module method #class_extend.
+  #
+  #   module Mix
+  #     def inst_meth
+  #       puts 'inst_meth'
+  #     end
+  #
+  #     class_extend do
+  #       def class_meth
+  #         "Class Method!"
+  #       end
+  #     end
+  #   end
+  #
+  #   class X
+  #     include Mix
+  #   end
+  #
+  #   X.class_meth  #=> "Class Method!"
+  #
+  # 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.
+  #
+  # CREDIT: Daniel Schierbeck, Thomas Sawyer
+  #
+  # THANKS: Nobu Nakada, Ulysses
+
+  def class_extend(*mods, &block)
+    class_extension = Module.new
+
+    class_extension.__send__(:include, *mods)
+    class_extension.module_eval(&block) if block_given?
+
+    extend(class_extension)  # extend this module too
+
+    append_method = method(:append_features)
+
+    (class << self; self; end).class_eval do
+      define_method(:append_features) do |mod|
+        append_method.call(mod)
+        mod.extend(class_extension)
+        if mod.instance_of?(Module)
+          mod.__send__(:class_extend, class_extension)
+        end
+      end
+    end
+
+    class_extensions << class_extension
+  end
+
+  #private :class_extend
+
+  #
+  def class_extensions
+    @class_extensions ||= []
+  end
+
+end
+
+class Class
+
+  # For Class, Module#class_extend is similar to class_eval.
+  #
+  # The alternative is to "undef_method :class_extend",
+  # but this seems uneccessarily limited.
+  def class_extend(*mods, &block)
+    class_extension = Module.new
+    class_extension.__send__(:include, *mods)
+    class_extension.module_eval(&block) if block
+    extend(class_extension)
+    class_extensions << class_extension
+  end
+
+end

data/lib/{more/facets/inheritor.rb → tour/facets/module/class_inheritor.rb}

@@ -1,32 +1,10 @@
-# = Inheritor
-#
-#  Inheritor providse a means to store and inherit data via
-#  the class heirarchy.
-#
-# == Authors
-#
-# * Thomas Sawyer
-#
-# == Copying
-#
-# Copyright (c) 2005 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.
+require 'facets/module/class_extend'
 
-require 'facets/class_extend'
+class Module
 
-class Object
-
-  # = Inheritor
+  # = Class Inheritor
   #
-  # Create an inheritor "class attribute".
+  # Create an dynamic class inheritable attribute.
   #
   # Inheritor providse a means to store and inherit data via the class
   # heirarchy. An inheritor creates two methods one named after the key
@@ -40,31 +18,28 @@ class Object
   # that specifies how one hierarchical level "integrates" with the next.
   #
   #   class X
-  #     inheritor :foo, [], :+
+  #     class_inheritor :x, [], :+
   #   end
   #
   #   class Y < X
   #   end
   #
   #   X.x! << :a
-  #   X.x => [:a]
-  #   Y.x => [:a]
+  #   X.x  #=> [:a]
+  #   Y.x  #=> [:a]
   #
   #   Y.x! << :b
-  #   X.x => [:a]
-  #   Y.x => [:a, :b]
-  #
-  # It is interesting to note that the only reason inheritor is needed
-  # at all is becuase Ruby does not allow modules to be "inherited" at
-  # the class-level, or conversely that the class-level is not a module
-  # instead. Otherwise using #super at the class-level would suffice.
+  #   X.x  #=> [:a]
+  #   Y.x  #=> [:a, :b]
   #
   # NOTE: Adding an inheritor directly to Module or Class will probably
   # not do what is expected. Thankfully that usecase is likely a YAGNI,
   # but in anycase it is even more likely that it is not possible with
   # this code.
+  #
+  # CREDIT: Thomas Sawyer
 
-  def inheritor(key, obj, op=nil, &fop)
+  def class_inheritor(key, obj, op=nil, &fop)
     raise ArgumentError if op && fop
 
     if !fop
@@ -97,4 +72,3 @@ class Object
   end
 
 end
-

data/lib/tour/facets/module/copy_inheritor.rb

@@ -0,0 +1,39 @@
+require 'facets/module/class_extend'
+
+class Module
+
+  # Like #class_inheritor but non-dynamic. The value of the inheritor
+  # is copied from the ancestor on first read.
+  #
+  #   c = Class.new do
+  #     def self.x; ['x']; end
+  #   end
+  #
+  #   d = Class.new(c) do
+  #     copy_inheritor :x
+  #   end
+  #
+  #   d.x  #=> ['x']
+  #
+  # CREDIT: Thomas Sawyer
+
+  def copy_inheritor(name, default={})
+    class_extend do
+      define_method(name) do
+        if instance_variable_defined?("@#{name}")
+          instance_variable_get("@#{name}")
+        else
+          if anc = ancestors[1..-1].find{ |a| a.respond_to?(name) }
+            value = anc.__send__(name)
+            value = value.dup rescue value
+            instance_variable_set("@#{name}", value)
+          else
+            instance_variable_set("@#{name}", default)
+          end
+        end
+      end
+    end
+  end
+
+end
+

data/lib/tour/facets/module/enclosure.rb

@@ -0,0 +1,62 @@
+class Module
+
+  # Returns the module which contains this one according to its name.
+  #
+  #   module ::EncExample
+  #     module M
+  #       module N
+  #       end
+  #     end
+  #   end
+  #
+  #   EncExample::M::N.enclosure  #=> EncExample::M
+  #
+  # The enclosure of top-level and anonymous modules is Object.
+  #
+  #   EncExample.enclosure   #=> Object
+  #   Module.new.enclosure   #=> Object
+  #
+  def enclosure
+    name = /::[^:]+\Z/ =~ self.name ? $` : nil
+    if name
+      #base = name.sub!(/^::/, '') ? Object : self
+      name.split(/::/).inject(self) do |mod, cref|
+        if /\:(0x.*?)\>$/ =~ cref   # TODO: does this ever happen?
+          #p $1.to_i(16)
+          ObjectSpace._idref($1.to_i(16))
+        else
+          mod.const_get(cref)
+        end
+      end
+    else
+      Object
+    end
+  end
+
+  # Returns all the namespaces of this module according ordered from
+  # nearest and moving outwards. The receiver is not contained within
+  # the result.
+  #
+  #   module ::EncExample
+  #     module M
+  #       module N
+  #       end
+  #     end
+  #   end
+  #
+  #   EncExample.enclosures        #=> [Object]
+  #   EncExample::M.enclosures     #=> [EncExample, Object]
+  #   EncExample::M::N.enclosures  #=> [EncExample::M, EncExample, Object]
+  #
+  def enclosures
+    n = []
+    name.split(/::/).inject(self) do |mod, cref|
+      c = mod.const_get(cref) ; n.unshift(c) ; c
+    end
+    n << Object # ?
+    n.shift # we really don't need +self+ too.
+    n
+  end
+
+end
+

data/lib/tour/facets/module/enclosures.rb

@@ -0,0 +1 @@
+require 'facets/module/enclosure'

data/lib/tour/facets/module/include_as.rb

@@ -0,0 +1 @@
+require 'facets/module/method_space'

data/lib/{more/facets → tour/facets/module}/instance_function.rb

@@ -11,32 +11,36 @@ class Module
   #   module MyModule
   #     instance_function
   #
-  #     def self.jumble( obj, arg )
+  #     def self.jumble(obj, arg)
   #       obj + arg
   #     end
   #   end
   #
-  #   class String
-  #     include MyModule
-  #   end
-  #
-  #   MyModule.jumble( "Try", "Me" )  #=> "TryMe"
+  #   MyModule.jumble("Try", "Me")  #=> "TryMe"
   #
-  #   "Try".jumble( "Me" )            #=> 'TryMe'
+  #   s = "Try"
+  #   s.extend MyModule
+  #   s.jumble("Me")                #=> "TryMe"
   #
   # Note: This used to be a module called PromoteSelf and later Instantize,
   # before becoming a method.
   #
   def instance_function(*meths)
+    this = self
     if meths.empty?
       extend InstanceFunction
     else
       meths.each do |meth|
-        class_eval %{
-          def #{meth}(*args)
-            #{self.name}.#{meth}(self,*args)
+        module_eval do
+          define_method(meth) do |*args|
+            this.__send__(meth, self, *args)
           end
-        }
+        end
+        ##class_eval %{
+        ##  def #{meth}(*args)
+        ##    #{self.name}.#{meth}(self,*args)
+        ##  end
+        ##}
       end
     end
   end
@@ -44,18 +48,24 @@ class Module
   module InstanceFunction #:nodoc
     #
     def singleton_method_added(meth)
-      module_eval %{
-        def #{meth}(*args)
-          #{self.name}.#{meth}(self,*args)
+      this = self
+      ##module_eval %{
+      ##  def #{meth}(*args)
+      ##    #{self.name}.#{meth}(self,*args)
+      ##  end
+      ##}
+      module_eval do
+        define_method(meth) do |*args|
+          this.__send__(meth, self, *args)
         end
-      }
-      #self.class_eval d
+      end
       super(meth)
     end
   end
 
 end #class Module
 
+
 =begin
 module Instantize
 

data/lib/tour/facets/module/memoize.rb

@@ -0,0 +1,12 @@
+require 'facets/memoizable'
+
+class Module
+
+  # This is here for backward compatibility.
+  def memoize(*args)
+    include Memoizable
+    Memoizable.instance_method(:memoize).bind(self).call(*args)
+    #super(*args)  # TODO: why is super not working here?
+  end
+
+end

data/lib/tour/facets/module/method_space.rb

@@ -0,0 +1,94 @@
+require 'facets/functor'
+require 'facets/module/basename'
+
+class Module
+
+  # Create method namespaces, allowing for method
+  # chains but still accessing the object's instance.
+  #
+  #   class A
+  #     attr_writer :x
+  #     method_space :inside do
+  #       def x; @x; end
+  #     end
+  #   end
+  #
+  #   a = A.new
+  #   a.x = 10
+  #   a.inside.x  #=> 10
+  #
+  #   expect NoMethodError do
+  #     a.x
+  #   end
+  #
+  # CREDIT: Pit Captain
+  def method_space(name, mod=nil, &blk)
+
+    ## If block is given then create a module, otherwise
+    ## get the name of the module.
+    if block_given?
+      name = name.to_s
+      raise ArgumentError if mod
+      mod  = Module.new(&blk)
+    else
+      if Module === name
+        mod = name
+        name = mod.basename.downcase
+      end
+      mod  = mod.dup
+    end
+
+    ## Include the module. This is neccessary, otherwise
+    ## Ruby won't let us bind the instance methods.
+    include mod
+
+    ## Save the instance methods of the module and
+    ## replace them with a "transparent" version.
+    methods = {}
+    mod.instance_methods(false).each do |m|
+      methods[m.to_sym] = mod.instance_method(m)
+      mod.module_eval %{
+        def #{m}(*a,&b)
+          super(*a,&b)
+        end
+      }
+      ##mod.instance_eval do
+      ##  define_method(m)
+      ##    super
+      ##  end
+      ##end
+    end
+
+    ## Add a method for the namespace that delegates
+    ## via the Functor to the saved instance methods.
+    define_method(name) do
+      mtab = methods
+      Functor.new do |op, *args|
+        if meth = mtab[op.to_sym]
+          meth.bind(self).call(*args)
+        else
+          #self.__send__(op, *args)
+          raise NoMethodError, "undefined method `#{m}'"
+        end
+      end
+    end
+  end
+
+  # Include a module via a specified space.
+  #
+  #   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| method_space(name, mod) }
+  end
+
+end