mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/core/facets/module/include_function_module.rb

@@ -0,0 +1,25 @@
+class Module
+
+  private
+
+  # Include module and apply module_fuction to the
+  # included methods.
+  #
+  #   module Utils
+  #     module_function
+  #     def foo; "foo"; end
+  #   end
+  #
+  #   module UtilsPlus
+  #     include_function_module Utils
+  #   end
+  #
+  #  CREDIT: Trans
+
+  def include_function_module *mod
+    include(*mod)
+    module_function(*mod.collect{|m| m.private_instance_methods & m.methods(false)}.flatten)
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/module/instance_methods.rb

@@ -0,0 +1,40 @@
+class Module
+
+  # List all instance methods, equivalent to
+  #
+  #   public_instance_methods +
+  #   protected_instance_methods +
+  #   private_instance_methods
+  #
+  # TODO: Better name for #all_instance_methods?
+  # 
+  #  CREDIT: Trans
+
+  def all_instance_methods(include_super=true)
+    public_instance_methods(include_super) +
+    protected_instance_methods(include_super) +
+    private_instance_methods(include_super)
+  end
+
+  # Query whether a public instance method is defined for the module.
+  #
+  #  CREDIT: Gavin Sinclair
+  #  CREDIT: Noah Gibbs
+
+  def instance_method_defined?(meth)
+    instance_methods(true).find{ |m| m == meth.to_s }
+  end
+
+  # Query whether a normal (singleton) method is defined for the module.
+  #
+  #  CREDIT: Gavin Sinclair
+  #  CREDIT: Noah Gibbs
+
+  def singleton_method_defined?(meth)
+    singleton_methods(true).find{ |m| m == meth.to_s }
+  end
+
+  alias_method :module_method_defined?, :singleton_method_defined?
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/module/integrate.rb

@@ -0,0 +1,2 @@
+require 'facets/module/revise'
+

data/lib/gems/facets-2.4.5/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 X ; end
+  #  class Y < X ; end
+  #
+  #   Y.is?(X)  #=> true
+  #
+  #   CREDIT: Trans
+
+  def is?(base)
+    ancestors.slice(1..-1).include?(base)
+  end
+
+  # An alias for #include.
+  #
+  #   class X
+  #     is Enumerable
+  #   end
+  #
+  #   CREDIT: Trans
+
+  #alias_method :is, :include
+
+  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
+
+  # Expirmental idea for #is.
+  #
+  # If the module has #append_function_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/gems/facets-2.4.5/lib/core/facets/module/methodize.rb

@@ -0,0 +1,14 @@
+require 'facets/string/methodize'
+
+class Module
+
+  # Translate a module name to a suitable method name.
+  #
+  #   My::CoolClass.methodize => "my__cool_class"
+  #
+  def methodize
+    name.methodize
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/module/modspace.rb

@@ -0,0 +1,22 @@
+class Module
+
+  # Returns the module's container module.
+  #
+  #   module Example
+  #     class Demo
+  #     end
+  #   end
+  #
+  #   Example::Demo.modspace   #=> Example
+  #
+  # See also Module#basename.
+  #
+  #   CREDIT: Trans
+
+  def modspace
+    space = name[ 0...(name.rindex( '::' ) || 0)]
+    space.empty? ? Object : eval(space)
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/module/module_load.rb

@@ -0,0 +1,56 @@
+class Module
+
+  #unless (RUBY_VERSION[0,3] == '1.9')
+
+    # Load file into module/class namespace.
+    #
+    #   CREDIT: Trans
+
+    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.
+    #
+    #   CREDIT: Trans
+
+    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
+      @loaded ||= {}
+      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
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/module/nesting.rb

@@ -0,0 +1,18 @@
+class Module
+
+  # Show a modules nesting in module namespaces.
+  #
+  #   A::B::C.nesting  #=> [ A, A::B ]
+  #
+  #  CREDIT: Trans
+
+  def nesting
+    n = []
+    name.split(/::/).inject(self) do |mod, name|
+      c = mod.const_get(name) ; n << c ; c
+    end
+    return n
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/module/op.rb

@@ -0,0 +1,95 @@
+class Module
+
+  # Combine modules.
+  #
+  #   module A
+  #     def a; "a"; end
+  #   end
+  #
+  #   module B
+  #     def b; "b"; end
+  #   end
+  #
+  #   C = A + B
+  #
+  #   class X; include C; end
+  #
+  #   X.new.a    #=> "a"
+  #   X.new.b    #=> "b"
+  #
+  # Note that in the old version of traits.rb we cloned
+  # modules and altered their copies. Eg.
+  #
+  #     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
+  #   CREDIT: Robert Dober
+
+  def +(other)
+    base = self
+    Module.new do
+      include base
+      include other
+    end
+  end
+
+  # Subtract modules.
+  #
+  #   TODO: Should this use all instance_methods, not just public?
+  #
+  #   CREDIT: Thomas Sawyer
+  #   CREDIT: Robert Dober
+
+  def -(other)
+    case other
+    when Array
+      subtract = instance_methods(true) & other.collect{|m| m.to_s}
+    when Module
+      subtract = instance_methods(true) & other.instance_methods(true)  # false?
+    when String, Symbol
+      subtract = instance_methods(true) & [other.to_s]
+    end
+    base = self
+    Module.new do
+      include base
+      subtract.each{ |x| undef_method x }
+    end
+  end
+
+  # Rename methods.
+  #
+  #   module A
+  #     def a; "a"; end
+  #   end
+  #
+  #   B = A * { :a => :b }
+  #
+  #   class X; include B; end
+  #
+  #   X.new.b    #=> "a"
+  #
+  #
+  #   CREDIT: Thomas Sawyer
+  #   CREDIT: 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/gems/facets-2.4.5/lib/core/facets/module/pathize.rb

@@ -0,0 +1,22 @@
+require 'facets/string/pathize'
+
+class Module
+
+  # Converts a class name to a unix path
+  #
+  # Examples
+  #   CoolClass.pathize       #=> "cool_class"
+  #   My::CoolClass.pathize   #=> "my/cool_class"
+  #
+  def pathize
+    name.pathize
+    #to_s.
+    #  gsub(/::/, '/').
+    #  gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    #  gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    #  tr("-", "_").
+    #  downcase
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/module/prepend.rb

@@ -0,0 +1,26 @@
+class Module
+
+  # Prepend an +aspect+ module to a module.
+  # This only works at the module level.
+  #
+  #   module X
+  #     def x; "x"; end
+  #   end
+  #
+  #   module U
+  #     def x; '{' + super + '}'; end
+  #   end
+  #
+  #   X.prepend U
+  #
+  #   X.x  # => "{x}"
+  #
+  #  CREDIT Trans
+
+  def prepend(aspect)
+    aspect.__send__(:include, self)
+    extend aspect
+  end
+
+end
+

data/lib/gems/facets-2.4.5/lib/core/facets/module/redefine_method.rb

@@ -0,0 +1,35 @@
+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)
+    raise ArgumentError, "method does not exist" unless method_defined?( sym )
+    alias_method( aka, sym ) if aka
+    undef_method( sym )
+    define_method( sym, &blk )
+  end
+
+  alias_method :redef, :redefine_method
+
+end

data/lib/gems/facets-2.4.5/lib/core/facets/module/redirect_method.rb

@@ -0,0 +1,45 @@
+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 Example
+  #     redirect_method :hi => :hello, :hey => :hello
+  #     def hello(name)
+  #       puts "Hello, #{name}."
+  #     end
+  #   end
+  #
+  #   e = Example.new
+  #   e.hello("Bob")    #=> "Hello, Bob."
+  #   e.hi("Bob")       #=> "Hello, Bob."
+  #   e.hey("Bob")      #=> "Hello, Bob."
+  #
+  # The above class definition is equivalent to:
+  #
+  #   class Example
+  #     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