facets-glimmer 3.2.0

data/lib/core/facets/module/is.rb

@@ -0,0 +1,57 @@
+class Module
+
+  # Is a given class or module an ancestor of this
+  # class or module?
+  #
+  #   class IsX ; end
+  #   class IsY < IsX ; end
+  #
+  #   IsY.is?(IsX)  #=> true
+  #
+  # CREDIT: Trans
+
+  def is?(base)
+    Module===base && ancestors.slice(1..-1).include?(base)
+  end
+
+  # An alias for #include.
+  #
+  #   class IsExample
+  #     is Enumerable
+  #   end
+  #
+  # CREDIT: Trans
+
+  def is(*mods)
+    mods.each do |mod|
+      if mod.const_defined?(:Self)
+        extend mod::Self
+        # pass it along if module
+        if instance_of?(Module)
+          const_set(:Self, Module.new) unless const_defined?(:Self)
+          const_get(:Self).send(:include, mod::Self)
+        end
+      end
+    end
+    include(*mods)
+  end
+
+  #alias_method :is, :include
+
+  # Expirmental idea for #is.
+  #
+  # If the module has #append_feature_function
+  # defined, this will use that instead of #include ...
+  #
+  #   def is(*modules)
+  #     module.each do { |m|
+  #       if m.respond_to?(:append_feature_function)
+  #         send(m.append_feature_function,m)
+  #       else
+  #         include m
+  #       end
+  #     end
+  #   end
+
+end
+

data/lib/core/facets/module/lastname.rb

@@ -0,0 +1,30 @@
+class Module
+
+  # Returns the root name of the module/class.
+  #
+  #   module ::BaseName
+  #     class Example
+  #     end
+  #   end
+  #
+  #   BaseName::Example.name       #=> "BaseName::Example"
+  #   BaseName::Example.lastname   #=> "Example"
+  #
+  # Returns nil when module is anonymous.
+  #
+  # CREDIT: Trans
+
+  def lastname
+    if name and not name.empty?
+      name.gsub(/^.*::/, '')
+    else
+      nil #inspect.gsub('#<','').gsub('>','').sub(':', '_')
+    end
+  end
+
+  # Original name, but conflicts with File.basename, so is
+  # mildly deprecated. 
+  alias basename lastname
+
+end
+

data/lib/core/facets/module/let.rb

@@ -0,0 +1,31 @@
+class Module
+
+  # Create a memoized method. This method has been popularized by RSpec.
+  #
+  #   class LetExample
+  #     let(:seed) { rand }
+  #   end
+  #
+  #   eg = LetExample.new
+  #   eg.seed == eg.seed
+  #
+  # CREDIT: Howard Yeh
+  #
+  # @uncommon
+  #   require 'facets/module/let'
+  #
+  def let(var,&block)
+    name = "@#{var}"
+    self.class_eval do
+      define_method(var) do
+        if instance_variable_defined?(name)
+          instance_variable_get(name)
+        else
+          val = self.instance_eval(&block)
+          instance_variable_set(name,val)
+        end
+      end
+    end
+  end
+
+end

data/lib/core/facets/module/mattr.rb

@@ -0,0 +1,296 @@
+class Module
+
+  # Creates a class-variable attribute that can
+  # be accessed both on an instance and class level.
+  #
+  #   class CARExample
+  #     @@a = 10
+  #     cattr :a
+  #   end
+  #
+  #   CARExample.a           #=> 10
+  #   CARExample.new.a       #=> 10
+  #
+  # NOTE: This method is not a common core extension and is not
+  # loaded automatically when using <code>require 'facets'</code>.
+  #
+  # CREDIT: David Heinemeier Hansson
+  #
+  # @uncommon
+  #   require 'facets/module/cattr'
+  #
+  def cattr(*syms)
+    writers, readers = syms.flatten.partition{ |a| a.to_s =~ /=$/ }
+    writers = writers.map{ |e| e.to_s.chomp('=').to_sym }
+    ##readers.concat( writers ) # writers also get readers
+
+    cattr_reader(*readers)
+    cattr_writer(*writers)
+
+    return readers + writers
+  end
+
+  # Creates a class-variable attr_reader that can
+  # be accessed both on an instance and class level.
+  #
+  #   class CARExample
+  #     @@a = 10
+  #     cattr_reader :a
+  #   end
+  #
+  #   CARExample.a           #=> 10
+  #   CARExample.new.a       #=> 10
+  #
+  # NOTE: This method is not a common core extension and is not
+  # loaded automatically when using <code>require 'facets'</code>.
+  #
+  # CREDIT: David Heinemeier Hansson
+  #
+  # @uncommon
+  #   require 'facets/module/cattr'
+  #
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      module_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+    return syms
+  end
+
+  # Creates a class-variable attr_writer that can
+  # be accessed both on an instance and class level.
+  #
+  #   class CAWExample
+  #     cattr_writer :a
+  #     def self.a
+  #       @@a
+  #     end
+  #   end
+  #
+  #   CAWExample.a = 10
+  #   CAWExample.a            #=> 10
+  #   CAWExample.new.a = 29
+  #   CAWExample.a            #=> 29
+  #
+  # NOTE: This method is not a common core extension and is not
+  # loaded automatically when using <code>require 'facets'</code>.
+  #
+  # CREDIT: David Heinemeier Hansson
+  #
+  # @uncommon
+  #   require 'facets/module/cattr'
+  #
+  def cattr_writer(*syms)
+    syms.flatten.each do |sym|
+      module_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        def #{sym}=(obj)
+          @@#{sym}=(obj)
+        end
+      EOS
+    end
+    return syms
+  end
+
+  # Creates a class-variable attr_accessor that can
+  # be accessed both on an instance and class level.
+  #
+  #   class CAAExample
+  #     cattr_accessor :a
+  #   end
+  #
+  #   CAAExample.a = 10
+  #   CAAExample.a           #=> 10
+  #   mc = CAAExample.new
+  #   mc.a                   #=> 10
+  #
+  # NOTE: This method is not a common core extension and is not
+  # loaded automatically when using <code>require 'facets'</code>.
+  #
+  # CREDIT: David Heinemeier Hansson
+  #
+  # @uncommon
+  #   require 'facets/module/cattr'
+  #
+  def cattr_accessor(*syms)
+    cattr_reader(*syms) + cattr_writer(*syms)
+  end
+
+  # Creates a class-variable attribute that can
+  # be accessed both on an instance and class level.
+  #
+  #   c = Class.new do
+  #     mattr :a
+  #     def initialize
+  #       @@a = 10
+  #     end
+  #   end
+  #
+  #   c.new.a       #=> 10
+  #   c.a           #=> 10
+  #
+  # NOTE: The #mattr methods may not be as useful for modules as the #cattr
+  # methods are for classes, becuase class-level methods are not "inherited"
+  # across the metaclass for included modules.
+  #
+  # NOTE: This methiod is not a common core extension and is not
+  # loaded automatically when using <code>require 'facets'</code>.
+  #
+  # CREDIT: David Heinemeier Hansson
+  #
+  # @uncommon
+  #   require 'facets/module/mattr'
+  #
+  def mattr(*syms)
+    writers, readers = syms.flatten.partition{ |a| a.to_s =~ /=$/ }
+    writers = writers.collect{ |e| e.to_s.chomp('=').to_sym }
+    ##readers.concat( writers ) # writers also get readers
+
+    mattr_writer( *writers )
+    mattr_reader( *readers )
+
+    return readers + writers
+  end
+
+  # Creates a class-variable attr_reader that can
+  # be accessed both on an instance and class level.
+  #
+  #   c = Class.new do
+  #     @@a = 10
+  #     mattr_reader :a
+  #   end
+  #
+  #   c.a           #=> 10
+  #   c.new.a       #=> 10
+  #
+  # NOTE: This methiod is not a common core extension and is not
+  # loaded automatically when using <code>require 'facets'</code>.
+  #
+  # CREDIT: David Heinemeier Hansson
+  #
+  # @uncommon
+  #   require 'facets/module/mattr'
+  #
+  def mattr_reader( *syms )
+    syms.flatten.each do |sym|
+      module_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+    return syms
+  end
+
+  # Creates a class-variable attr_writer that can
+  # be accessed both on an instance and class level.
+  #
+  #   c = Class.new do
+  #     mattr_writer :a
+  #     def self.a
+  #       @@a
+  #     end
+  #   end
+  #
+  #   c.a = 10
+  #   c.a            #=> 10
+  #
+  #   c.new.a = 29
+  #   c.a            #=> 29
+  #
+  # NOTE: This methiod is not a common core extension and is not
+  # loaded automatically when using <code>require 'facets'</code>.
+  #
+  # CREDIT: David Heinemeier Hansson
+  #
+  # @uncommon
+  #   require 'facets/module/mattr'
+  #
+  def mattr_writer(*syms)
+    syms.flatten.each do |sym|
+      module_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        def #{sym}=(obj)
+          @@#{sym}=(obj)
+        end
+      EOS
+    end
+    return syms
+  end
+
+  # Creates a class-variable attr_accessor that can
+  # be accessed both on an instance and class level.
+  #
+  #   c = Class.new do
+  #     mattr_accessor :a
+  #   end
+  #
+  #   c.a = 10
+  #   c.a           #=> 10
+  #
+  #   x = c.new
+  #   x.a           #=> 10
+  #
+  # NOTE: This methiod is not a common core extension and is not
+  # loaded automatically when using <code>require 'facets'</code>.
+  #
+  # CREDIT: David Heinemeier Hansson
+  #
+  # @uncommon
+  #   require 'facets/module/mattr'
+  #
+  def mattr_accessor(*syms)
+    mattr_reader(*syms) + mattr_writer(*syms)
+  end
+
+end
+
+# Consider the issue where a module's metaclass is not inherited.
+#
+#   m = Module.new do
+#     @@a = 10
+#     mattr_reader :a
+#   end
+#
+#   c = Class.new do
+#     include m
+#   end
+#
+#   expect NoMethodError do
+#     c.a
+#   end
+#
+# Ideally this would work.

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

@@ -0,0 +1,16 @@
+require 'facets/memoizable'
+
+class Module
+
+  # This is here for backward compatibility.
+  #
+  # @uncommon
+  #   require 'facets/module/memoize'
+  #
+  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/core/facets/module/method_clash.rb

@@ -0,0 +1,66 @@
+class Module
+
+  # TODO: Should method_clash just be public methods?
+
+  # TODO: Provide an option to select visiblity.
+
+  # Detect method name clash between modules and/or classes, regardless of
+  # method visibility:
+  #
+  #   module MethodClashExample
+  #
+  #     module A
+  #       def c; end
+  #     end
+  #
+  #     module B
+  #       private
+  #       def c; end
+  #     end
+  #
+  #     A.method_clash(B)  #=> [:c]
+  #
+  #   end
+  #
+  # CREDIT: Thomas Sawyer, Robert Dober
+  #
+  # @uncommon
+  #   require 'facets/module/method_clash'
+  #
+  def method_clash(other)
+    common_ancestor = (ancestors & other.ancestors).first
+
+    s = []
+    s += public_instance_methods(true)
+    s += private_instance_methods(true)
+    s += protected_instance_methods(true)
+
+    o = []
+    o += other.public_instance_methods(true)
+    o += other.private_instance_methods(true)
+    o += other.protected_instance_methods(true)
+
+    c = s & o
+
+    if common_ancestor
+      c -= common_ancestor.public_instance_methods(true)
+      c -= common_ancestor.private_instance_methods(true)
+      c -= common_ancestor.protected_instance_methods(true)
+    end
+
+    return c
+  end
+
+  # Uses #method_clash to return +true+ or +false+ if there
+  # are method name clashes.
+  #
+  # @uncommon
+  #   require 'facets/module/method_clash'
+  #
+  def method_clash?(other) 
+    c = method_clash(other) 
+    !c.empty?
+  end
+
+end
+

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

@@ -0,0 +1,107 @@
+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
+  #
+  # NOTE: This method is not a common core extension and is not
+  # loaded automatically when using <code>require 'facets'</code>.
+  #
+  # CREDIT: Pit Captain
+  #
+  # @uncommon
+  #   require 'facets/module/method_space'
+  #
+  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"
+  #
+  # NOTE: This method is not a common core extension and is not
+  # loaded automatically when using <code>require 'facets'</code>.
+  #
+  # @uncommon
+  #   require 'facets/module/method_space'
+  #
+  def include_as(h)
+    h.each{ |name, mod| method_space(name, mod) }
+  end
+
+end

data/lib/core/facets/module/methodize.rb

@@ -0,0 +1,20 @@
+require 'facets/string/methodize'
+
+class Module
+
+  # Translate a module name to a suitable method name.
+  #
+  #   module ::EgMethodize
+  #     module Eg
+  #     end
+  #   end
+  #
+  #   EgMethodize.methodize      #=> "eg_methodize"
+  #   EgMethodize::Eg.methodize  #=> "eg_methodize__eg"
+  #
+  def methodize
+    name.methodize
+  end
+
+end
+

data/lib/core/facets/module/modname.rb

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

data/lib/core/facets/module/module_def.rb

@@ -0,0 +1,31 @@
+class Module
+
+  # Defines an instance method within a class/module.
+  #
+  # CREDIT: WhyTheLuckyStiff
+
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
+  end
+
+  # Defines an instance method within a class/module.
+  #
+  # CREDIT: WhyTheLuckyStiff
+
+  def module_def name, &blk
+    module_eval { define_method name, &blk }
+  end
+
+  #--
+  # TODO: Why are we making these protected,
+  # and where should these really go in Facets?
+  #++
+  protected :attr
+  protected :attr_reader
+  protected :attr_writer
+  protected :attr_accessor
+  protected :remove_method
+  protected :undef_method
+
+end
+