facets-glimmer 3.2.0

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

@@ -0,0 +1,83 @@
+class Module
+
+  # Load file directly into module/class namespace.
+  #
+  # Please use this with careful consideration.
+  # It is best suited to loading plugin-type scripts,
+  # and should generally not be used as a substitue for
+  # Ruby's standard load system.
+  #
+  # NOTE: This method is not a common core extension and is not
+  # loaded automatically when using <code>require 'facets'</code>.
+  #
+  # CREDIT: Trans
+  #
+  # @uncommon
+  #   require 'facets/module/module_load'
+  #
+  def module_load( path )
+    if path =~ /^[\/~.]/
+      file = File.expand_path(path)
+    else
+      $LOAD_PATH.each do |lp|
+        file = File.join(lp,path)
+        break if File.exist?(file)
+        file = nil
+      end
+    end
+    raise LoadError, "no such file to load -- #{path}" unless file
+    module_eval(File.read(file))
+  end
+
+  # Require file into module/class namespace.
+  #
+  # Unlike load this keeps a per-module cache and will
+  # not load the same file into the same module more
+  # than once despite repeated attempts.
+  #
+  # The cache is kept in a global var called +$module_require+.
+  #
+  # Please use this with careful consideration.
+  # It is best suited to loading plugin-type scripts,
+  # and should generally not be used as a substitue for
+  # Ruby's standard load system.
+  #
+  # NOTE: This method is not a common core extension and is not loaded
+  # automatically when using <code>require 'facets'</code>.
+  #
+  # CREDIT: Trans
+  #
+  # @uncommon
+  #   require 'facets/module/module_load'
+  #
+  def module_require( path )
+    if path =~ /^[\/~.]/
+      file = File.expand_path(path)
+    else
+      $LOAD_PATH.each do |lp|
+        file = File.join(lp,path)
+        break if File.exist?(file)
+        file += '.rb'
+        break if File.exist?(file)
+        file = nil
+      end
+    end
+    raise LoadError, "no such file to load -- #{path}" unless file
+    # per-module load cache
+    $module_require ||= {}
+    $module_require[self] ||= {}
+    loaded = $module_require[self]
+    if loaded.key?(file)
+      false
+    else
+      loaded[file] = true
+      script = File.read(file)
+      module_eval(script)
+      true
+    end
+  end
+
+  alias_method :class_require, :module_require
+  alias_method :class_load, :module_load
+end
+

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

@@ -0,0 +1,13 @@
+class Module
+
+  # Alias for undef_method. This has been called "nodef" instead of
+  # undef to help clarify that it doesn't get rid of the method, but
+  # rather represses repsonse.
+  alias_method :nodef, :undef_method
+
+  # Alias for remove_method. This method actually "undefines" a method
+  # and will raise an error is the method is not defined in receiver.
+  alias_method :remove,  :remove_method
+
+end
+

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

@@ -0,0 +1,107 @@
+class Module
+
+  # Combine modules.
+  #
+  #   module APlus
+  #     def a; "a"; end
+  #   end
+  #
+  #   module BPlus
+  #     def b; "b"; end
+  #   end
+  #
+  #   CPlus = APlus + BPlus
+  #
+  #   class XPlus; include CPlus; end
+  #
+  #   XPlus.new.a    #=> "a"
+  #   XPlus.new.b    #=> "b"
+  #
+  # Note that in the old version of traits.rb we cloned
+  # modules and altered their copies...
+  #
+  #   def +(other)
+  #     mod1 = other.clone
+  #     mod2 = clone
+  #     mod1.module_eval{ include mod2 }
+  #   end
+  #
+  # Later it was realized that this thwarted the main
+  # benefit that Ruby's concept of modules has over
+  # traditional traits, inheritance.
+  #
+  # CREDIT: Thomas Sawyer, Robert Dober
+
+  def +(other)
+    base = self
+    Module.new do
+      include base
+      include other
+    end
+  end
+
+  # Subtract modules.
+  #
+  #   module AMinus
+  #     def a; "a"; end
+  #     def b; "b"; end
+  #   end
+  #
+  #   CMinus = AMinus - [:a]
+  #
+  #   class XMinus; include CMinus; end
+  #
+  #   expect NameError do
+  #     XMinus.new.a  #=> "a"
+  #   end
+  #
+  #   XMinus.new.b    #=> "b"
+  #
+  # TODO: Should this use all instance methods, not just public?
+  #
+  # CREDIT: Thomas Sawyer, Robert Dober
+
+  def -(other)
+    instance_methods = instance_methods(true).map{|m| m.to_sym}
+    case other
+    when Array
+      subtract = instance_methods & other.map{|m| m.to_sym}
+    when Module
+      subtract = instance_methods & other.instance_methods(true).map{|m| m.to_sym}  # false?
+    when String, Symbol
+      subtract = instance_methods & [other.to_sym]
+    end
+    base = self
+    Module.new do
+      include base
+      subtract.each{ |x| undef_method x }
+    end
+  end
+
+  # Rename methods.
+  #
+  #   module AStar
+  #     def a; "a"; end
+  #   end
+  #
+  #   BStar = AStar * { :a => :b }
+  #
+  #   class XStar; include BStar; end
+  #
+  #   XStar.new.b    #=> "a"
+  #
+  # CREDIT: Thomas Sawyer, Robert Dober
+
+  def *(rename_map)
+    base = self
+    Module.new do
+      include base
+      rename_map.each do |from, to|
+        alias_method to, from
+        undef_method from
+      end
+    end
+  end
+
+end
+

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

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

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

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

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

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

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

@@ -0,0 +1,20 @@
+require 'facets/string/pathize'
+
+class Module
+
+  # Converts a class name to a unix path.
+  #
+  #   module ::ExamplePathize
+  #     module Example
+  #     end
+  #   end
+  #
+  #   ExamplePathize.pathize           #=> "example_pathize"
+  #   ExamplePathize::Example.pathize  #=> "example_pathize/example"
+  #
+  def pathize
+    name.pathize
+  end
+
+end
+

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

@@ -0,0 +1,32 @@
+class Module
+
+  # Prepend an +aspect+ module to a module.
+  # This only works at the module level.
+  #
+  #   module ::PreX
+  #     def x; "x"; end
+  #   end
+  #
+  #   module ::PreU
+  #     def x; '{' + super + '}'; end
+  #   end
+  #
+  #   PreX.preextend(PreU)
+  #
+  #   PreX.x  # => "{x}"
+  #
+  # NOTE: This is not a common core extension and is not loaded
+  # automatically when using <code>require 'facets'</code>.
+  #
+  # CREDIT Trans
+  #
+  # @uncommon
+  #   require 'facets/module/preextend'
+  #
+  def preextend(aspect)
+    aspect.__send__(:include, self)
+    extend aspect
+  end
+
+end
+

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

@@ -0,0 +1,37 @@
+class Module
+
+  private
+
+  # Creates a new method for a pre-existing method.
+  #
+  # If _aka_ is given, then the method being redefined will
+  # first be aliased to this name.
+  #
+  #   class Greeter
+  #     def hello ; "Hello" ; end
+  #   end
+  #
+  #   Greeter.new.hello   #=> "Hello"
+  #
+  #   class Greeter
+  #     redefine_method( :hello, :hi ) do
+  #       hi + ", friend!"
+  #     end
+  #   end
+  #
+  #   Greeter.new.hello   #=> "Hello, friend!"
+  #
+  # CREDIT: Trans
+
+  def redefine_method(sym, aka=nil, &blk)
+    alias_method(aka, sym) if aka
+    ## prevent warning about method overwrite
+    begin remove_method(sym) rescue NameError end
+    ## define replacelemt method
+    define_method(sym, &blk)
+  end
+
+  #
+  alias_method :redef, :redefine_method
+
+end

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

@@ -0,0 +1,46 @@
+class Module
+
+  private
+
+  # Redirect methods to other methods. This simply
+  # defines methods by the name of a hash key which
+  # calls the method with the name of the hash's value.
+  #
+  #   class RedirectExample
+  #     redirect_method :hi => :hello, :hey => :hello
+  #     def hello(name)
+  #       "Hello, #{name}."
+  #     end
+  #   end
+  #
+  #   e = RedirectExample.new
+  #   e.hello("Bob")    #=> "Hello, Bob."
+  #   e.hi("Bob")       #=> "Hello, Bob."
+  #   e.hey("Bob")      #=> "Hello, Bob."
+  #
+  # The above class definition is equivalent to ...
+  #
+  #   class RedirectExample
+  #     def hi(*args)
+  #       hello(*args)
+  #     end
+  #     def hey(*args)
+  #       hello(*args)
+  #     end
+  #     def hello
+  #       puts "Hello"
+  #     end
+  #   end
+  #
+  # CREDIT: Trans
+
+  def redirect_method( method_hash )
+    method_hash.each do |targ,adv|
+      define_method(targ) { |*args| send(adv,*args) }
+    end
+  end
+
+  #
+  alias_method :redirect, :redirect_method
+
+end

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

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

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

@@ -0,0 +1,30 @@
+class Module
+
+  private
+
+  # Aliases a method and undefines the original.
+  #
+  #   class RenameExample
+  #     def foo; "foo"; end
+  #     rename_method(:bar, :foo)
+  #   end
+  # 
+  #   example = RenameExample.new
+  #   example.bar  #=> 'foo'
+  #
+  #   expect NoMethodError do
+  #     example.foo
+  #   end
+  #
+  # CREDIT: Trans
+
+  def rename_method( to_sym, from_sym )
+    raise ArgumentError, "method #{from_sym} does not exist" unless method_defined?( from_sym )
+    alias_method( to_sym, from_sym )
+    undef_method( from_sym )
+  end
+
+  alias_method :rename, :rename_method
+
+end
+

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

@@ -0,0 +1,41 @@
+require 'facets/module/redirect_method'
+require 'facets/module/redefine_method'
+require 'facets/module/rename_method'
+require 'facets/module/wrap_method'
+require 'facets/module/nodef'
+
+class Module
+
+  # Return a new module based on another. This includes the original module
+  # into the new revised module.
+  #
+  #   module ReviseExample
+  #     def foo; "foo"; end
+  #   end
+  #
+  #   ReviseExample2 = ReviseExample.revise do
+  #     alias_method :bar, :foo
+  #   end
+  #
+  #   object = Object.new
+  #   object.extend ReviseExample2
+  #   object.bar  #=> 'foo'
+  #
+  # CREDIT: Trans
+
+  def revise(&blk)
+    base = self
+    nm = Module.new{ include base }
+    nm.class_eval(&blk)
+    nm
+  end
+
+  alias_method :revisal, :revise
+end
+
+class Class
+  undef_method :revise
+  undef_method :revisal
+end
+
+

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

@@ -0,0 +1,36 @@
+class Module
+
+  unless method_defined?(:set)
+
+    # Sets an option to the given value. If the value is a proc,
+    # the proc will be called every time the option is accessed.
+    #
+    # CREDIT: Blake Mizerany (Sinatra)
+
+    def set(option, value=self, &block)
+      raise ArgumentError if block && value != self
+      value = block if block
+      if value.kind_of?(Proc)
+        if value.arity == 1
+          yield self
+        else
+          (class << self; self; end).module_eval do
+            define_method(option, &value)
+            define_method("#{option}?"){ !!__send__(option) }
+            define_method("#{option}="){ |val| set(option, Proc.new{val}) }
+          end
+        end
+      elsif value == self
+        option.each{ |k,v| set(k, v) }
+      elsif respond_to?("#{option}=")
+        __send__("#{option}=", value)
+      else
+        set(option, Proc.new{value})
+      end
+      self
+    end
+
+  end
+
+end
+

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

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

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

@@ -0,0 +1,25 @@
+class Module
+
+  # Returns the name of module's container module.
+  #
+  #   module ::SpaceName
+  #     class Example
+  #     end
+  #   end
+  #
+  #   SpaceName::Example.name         #=> "SpaceName::Example"
+  #   SpaceName::Example.spacename    #=> "SpaceName"
+  #
+  # This used to be called +dirname+.
+  #
+  # See also Module#basename.
+  #
+  # CREDIT: Trans
+
+  def spacename
+    name[0...(name.rindex('::') || 0)]
+    #name.gsub(/::[^:]*$/, '')
+  end
+
+end
+

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

@@ -0,0 +1,20 @@
+class Module
+
+  # Create an instance of Object and extend it with +self+.
+  #
+  #   mod = Module.new do
+  #     def foo; "foo"; end
+  #   end
+  #
+  #   obj = mod.to_obj
+  #
+  #   obj.foo #=> "foo"
+  #
+  def to_obj
+    o = Object.new
+    o.extend self
+    o
+  end
+
+end
+

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

@@ -0,0 +1,35 @@
+class Module
+
+  #private  # (we'll leave this one public for AOP-like uses).
+
+  # Creates a new method wrapping the previous of the same name.
+  # Reference to the old method is passed into the new definition
+  # block as the first parameter.
+  #
+  #   class WrapExample
+  #     def foo
+  #       "foo"
+  #     end
+  #
+  #     wrap_method(:foo) do |old_meth, *args|
+  #       old_meth.call + '!'
+  #     end
+  #   end
+  #
+  #   example = WrapExample.new
+  #   example.foo #=> 'foo!'
+  #
+  # Keep in mind that this cannot be used to wrap methods
+  # that take a block.
+  #
+  # CREDIT: Trans
+
+  def wrap_method( sym, &blk )
+    old = instance_method(sym)
+    define_method(sym) { |*args| blk.call(old.bind(self), *args) }
+  end
+
+  alias_method :wrap, :wrap_method
+
+end
+

data/lib/core/facets/module.rb

@@ -0,0 +1,60 @@
+require_relative 'module/abstract.rb'
+require_relative 'module/alias_accessor.rb'
+require_relative 'module/alias_method_chain.rb'
+require_relative 'module/alias_module_function.rb'
+require_relative 'module/all_instance_methods.rb'
+require_relative 'module/ancestor.rb'
+require_relative 'module/anonymous.rb'
+#require_relative 'module/attr_class_accessor.rb'         # uncommon
+require_relative 'module/attr_setter.rb'
+#require_relative 'module/attr_tester.rb'                 # uncommon
+#require_relative 'module/attr_validator.rb'              # uncommon
+require_relative 'module/basename.rb'
+require_relative 'module/can.rb'
+#require_relative 'module/cattr.rb'                       # uncommon
+require_relative 'module/class.rb'
+#require_relative 'module/class_accessor.rb'              # uncommon
+require_relative 'module/class_def.rb'
+#require_relative 'module/class_extend.rb'                # uncommon
+#require_relative 'module/class_inheritor.rb'             # uncommon
+require_relative 'module/class_method_defined.rb'
+#require_relative 'module/copy_inheritor.rb'              # uncommon
+#require_relative 'module/enclosure.rb'                   # uncommon
+#require_relative 'module/enclosures.rb'                  # uncommon
+require_relative 'module/extend.rb'
+require_relative 'module/home.rb'
+require_relative 'module/homename.rb'
+require_relative 'module/housing.rb'
+#require_relative 'module/include_as.rb'                  # uncommon
+#require_relative 'module/instance_function.rb'           # uncommon
+require_relative 'module/include_function_module.rb'
+require_relative 'module/instance_method.rb'
+require_relative 'module/instance_method_defined.rb'
+require_relative 'module/integrate.rb'
+require_relative 'module/is.rb'
+#require_relative 'module/let.rb'                         # uncommon
+#require_relative 'module/memoize.rb'                     # uncommon
+#require_relative 'module/method_clash.rb'                # uncommon
+#require_relative 'module/method_space.rb'                # uncommon
+require_relative 'module/methodize.rb'
+require_relative 'module/modname.rb'
+require_relative 'module/module_def.rb'
+#require_relative 'module/module_load.rb'                 # uncommon
+require_relative 'module/nodef.rb'
+require_relative 'module/op.rb'
+require_relative 'module/op_add.rb'
+require_relative 'module/op_mul.rb'
+require_relative 'module/op_sub.rb'
+require_relative 'module/pathize.rb'
+#require_relative 'module/preextend.rb'                   # uncommon
+require_relative 'module/redefine_method.rb'
+require_relative 'module/redirect_method.rb'
+require_relative 'module/remove.rb'
+require_relative 'module/rename_method.rb'
+require_relative 'module/revise.rb'
+require_relative 'module/set.rb'
+require_relative 'module/singleton_method_defined.rb'
+require_relative 'module/spacename.rb'
+require_relative 'module/to_obj.rb'
+require_relative 'module/wrap_method.rb'
+

data/lib/core/facets/na.rb

@@ -0,0 +1,21 @@
+# N/A exception is useful for specifying non-argument defaults when +nil+
+# is a valid value.
+#
+#   def f(x=NA)
+#   end
+#
+# NA is also used to represent an argument "slot" for Proc#partial.
+#
+# NA is an instance of ArgumentError.
+
+class << NA = ArgumentError.new
+  def inspect ; 'N/A' ; end
+  def method_missing(*); self; end
+end
+
+# NA is a subclass of ArgumentError.
+#class NA < ArgumentError
+#  class << self
+#    def method_missing(*); self; end
+#  end
+#end

data/lib/core/facets/nilclass/ergo.rb

@@ -0,0 +1 @@
+require 'facets/kernel/ergo'

data/lib/core/facets/nilclass.rb

@@ -0,0 +1,2 @@
+require_relative 'nilclass/ergo.rb'
+

data/lib/core/facets/numeric/approx.rb

@@ -0,0 +1,39 @@
+class Numeric
+
+  # Determines if another number is approximately equal within a given
+  # _n_th degree. Defaults to 100ths if the degree is not specified.
+  #
+  # Currently defaults to 1/10,000,000 if the degree is not specified.
+  # But this may change once a "most commonly useful" factor is determined.
+  #
+  # This is the same a {#close?} but has a different defualt.
+  #
+  # @author Gavin Sinclair
+
+  def approx?(x, n=0.0000001)
+    close?(x, n)
+  end
+
+  # Determines if another number is approximately equal
+  # within a given +epsilon+.
+  #
+  # This is the same a {#approx?} but has a different default.
+  # In this case it is 1/100th.
+  #
+  # @author Gavin Sinclair
+  def close?(number, epsilon=0.01)
+    return(self == number) if epsilon.zero?
+
+    a, b = self.to_f, number.to_f
+    if a.zero? or b.zero?
+      ## There's no scale, so we can only go on difference.
+      (a - b).abs < epsilon
+    else
+      ## We go by ratio. The ratio of two equal numbers is one, so the ratio
+      ## of two practically-equal floats will be very nearly one.
+      (a/b - 1).abs < epsilon
+    end
+  end
+
+end
+

data/lib/core/facets/numeric/close.rb

@@ -0,0 +1 @@
+require 'facets/numeric/approx'