mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/more/facets/chain.rb

@@ -0,0 +1,58 @@
+# = Chain
+#
+# Expiremental library for safe method chaining.
+#
+#   person = "John Doe"
+#   def person.address = "123 West St."
+#   person.address.street #=> Error
+#
+# To avoid the error use #chain:
+#
+#   person.chain.address.street.end   #=> nil
+#
+# Or
+#
+#   ~ person.chain.address.street     #=> nil
+#
+class Chain
+
+  private *instance_methods.select{|m| m !~ /^__/ }
+
+  def initialize(value)
+    @value = value
+  end
+
+  def method_missing(s,*a, &b)
+    if @value.respond_to?(s)
+      @value = @value.__send__(s,*a,&b)
+    else
+      @missing = true
+    end
+    #begin
+    #  @value = @value.__send__(s,*a,&b)
+    #rescue NoMethodError
+    #  @missing = true
+    #end
+    self
+  end
+
+  #def value?
+  #  @value
+  #end
+
+  def end
+    @missing ? nil : @value
+  end
+
+  def ~@
+    @missing ? nil : @value
+  end
+
+end
+
+module Kernel
+  def chain
+    Chain.new(self)
+  end
+end
+

data/lib/gems/facets-2.4.5/lib/more/facets/class_extension.rb

@@ -0,0 +1,114 @@
+# = Class Extension
+#
+# Normally when including modules, class/module methods are not
+# extended. To achieve this behavior requires some clever
+# Ruby Karate. Instead class_extension provides an easy to use
+# and clean solution. Simply place the extending class methods
+# in a block of the special module method #class_extension.
+#
+#   module Mix
+#     def inst_meth
+#       puts 'inst_meth'
+#     end
+#
+#     class_extension do
+#       def class_meth
+#         "Class Method!"
+#       end
+#     end
+#   end
+#
+#   class X
+#     include Mix
+#   end
+#
+#   X.class_meth  #=> "Class Method!"
+#
+# == History
+#
+# Thanks to Trans, Nobu and Ulysses for their original on this concept.
+#
+# == Authors
+#
+# * Daniel Schierbeck
+# * Thomas Sawyer
+# * Nobu Nakada
+# * Ulysses
+#
+# == Copying
+#
+# Copyright (c) 2006 Daniel Schierbeck
+#
+# 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.
+
+#
+class Module
+
+  alias_method :append_features_without_class_extension, :append_features
+
+  # = class_extension
+  #
+  # Normally when including modules, class/module methods are not
+  # extended. To achieve this behavior requires some clever
+  # Ruby Karate. Instead class_extension provides an easy to use
+  # and clean solution. Simply place the extending class methods
+  # in a block of the special module method #class_extension.
+  #
+  #   module Mix
+  #     def inst_meth
+  #       puts 'inst_meth'
+  #     end
+  #
+  #     class_extension do
+  #       def class_meth
+  #         "Class Method!"
+  #       end
+  #     end
+  #   end
+  #
+  #   class X
+  #     include Mix
+  #   end
+  #
+  #   X.class_meth  #=> "Class Method!"
+  #
+
+  def class_extension(&block)
+    @class_extension ||= Module.new do
+      def self.append_features(mod)
+        append_features_without_class_extension(mod)
+      end
+    end
+    @class_extension.module_eval(&block) if block_given?
+    @class_extension
+  end
+
+  private :class_extension
+
+  def append_features(mod)
+    append_features_without_class_extension(mod)
+    mod.extend(class_extension)
+    if mod.instance_of? Module
+      mod.__send__(:class_extension).__send__(:include, class_extension)
+    end
+  end
+
+end
+
+class Class
+  # For a class #class_extension is the same as class_eval.
+  # The alternative is to "undef_method :class_extension",
+  # but this seems uneccessarily limited.
+
+  def class_extension(&blk)
+    class_eval(&blk)
+  end
+end
+

data/lib/gems/facets-2.4.5/lib/more/facets/classmethods.rb

@@ -0,0 +1,199 @@
+# = ClassMethods
+#
+# Miniframework provides a very convenient way to have modules
+# pass along class methods in the inheritance chain.
+#
+# An oddity of Ruby, when including modules, class/module methods
+# are not inherited. To achieve this behavior requires some clever
+# Ruby Karate. Instead ClassMethods provides an easy to use and clean
+# solution. Simply place the class inheritable methods in a block of
+# the special module method #ClassMetods.
+#
+#   module Mix
+#     def inst_meth
+#       puts 'inst_meth'
+#     end
+#
+#     class_methods do
+#       def class_meth
+#         "Class Method!"
+#       end
+#     end
+#   end
+#
+#   class X
+#     include Mix
+#   end
+#
+#   X.class_meth  #=> "Class Method!"
+#
+# This is equivalent to the original (but still functional) techinique of
+# putting the class/module methods in a nested ClassMethods module
+# and extending the original module *manually*. Eg.
+#
+#   module Mix
+#     def inst_meth
+#       puts 'inst_meth'
+#     end
+#
+#     module ClassMethods
+#       def class_meth
+#         "Class Method!"
+#       end
+#     end
+#
+#     extend ClassMethods
+#   end
+#
+#   class X
+#     include Mix
+#   end
+#
+#   X.class_meth  #=> "Class Method!"
+#
+# Also note that #class_inherit is an available alias
+# for #class_methods for the sake of backward compatability.
+# And #class_extension is alias (potentially) looking forward
+# to a future version on Ruby.
+#
+# == On Topic
+#
+# Just a quick comment on the need for this behavior.
+#
+# A module is an encapsulation of code, hence when a module is included
+# (or extends), the module itself should have discretion over how it
+# effects the receiving class/module. That is the very embodiment of
+# encapsulation. Having it otherwise, as Ruby now does, stymies the
+# practice --and we end up with "hacks", like this and ClassMethods,
+# to compensate.
+#
+# Ruby would be much improved by making this bevaivor standard.
+# And making non-inheritance the exception, which is alwasy easy
+# enough to achieve: put the code in a separate (and thus uninherited)
+# module.
+#
+# == Notes
+#
+# * There are currently two approaches to this, ClassMethods and class_extensions.
+#   A third is being worked on called Component with the idea that a "component"
+#   is like a module except that it's class-level methods are mixed-in as well.
+#   This is an idea solution, however it is less that ideal to implement.
+#
+# == History
+#
+# Thanks to Nobu and Ulysses for their original work on this.
+#
+# == Authors
+#
+# * Nobu Nakada
+# * Thomas Sawyer
+# * Ulysses
+#
+# == Copying
+#
+# Copyright (c) 2005 Nobu Nakada, 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.
+
+
+# = ClassMethods
+#
+# ClassMethods provides an easy to use and clean
+# solution. Simply place the class inheritable methods in a block of
+# the special module method #ClassMetods.
+#
+#   module Mix
+#     def inst_meth
+#       puts 'inst_meth'
+#     end
+#
+#     class_methods do
+#       def class_meth
+#         "Class Method!"
+#       end
+#     end
+#   end
+#
+#   class X
+#     include Mix
+#   end
+#
+#   X.class_meth  #=> "Class Method!"
+#
+# This is equivalent to the original (but still functional) techinique of
+# putting the class/module methods in a nested ClassMethods module
+# and extending the original module *manually*. Eg.
+#
+#   module Mix
+#     def inst_meth
+#       puts 'inst_meth'
+#     end
+#
+#     module ClassMethods
+#       def class_meth
+#         "Class Method!"
+#       end
+#     end
+#
+#     extend ClassMethods
+#   end
+#
+#   class X
+#     include Mix
+#   end
+#
+#   X.class_meth  #=> "Class Method!"
+#
+# Also note that #class_inherit is an available alias
+# for #class_methods for the sake of backward compatability.
+# And #class_extension is alias (potentially) looking forward
+# to a future version on Ruby.
+
+class Module
+
+  alias_method :append_features_without_classmethods, :append_features
+
+  def append_features( base )
+    result = append_features_without_classmethods( base )
+    if const_defined?( :ClassMethods )
+      base.extend( self::ClassMethods )
+      unless base.is_a?( Class )
+        unless base.const_defined?( :ClassMethods )
+          base.const_set( :ClassMethods, Module.new )
+        end
+        my = self
+        base::ClassMethods.class_eval do
+          include my::ClassMethods
+        end
+      end
+    end
+    result
+  end
+
+  def class_methods( &yld )
+    if const_defined?( :ClassMethods )
+      self::ClassMethods.class_eval( &yld )
+    else
+      self.const_set( :ClassMethods, Module.new( &yld ) )
+    end
+    extend( self::ClassMethods )
+    self::ClassMethods
+  end
+
+  # For compatibility with old rendition.
+  alias_method :class_inherit, :class_methods
+
+end
+
+class Class
+  undef_method :class_methods
+  undef_method :class_inherit
+end
+

data/lib/gems/facets-2.4.5/lib/more/facets/cloneable.rb

@@ -0,0 +1,76 @@
+# = Clonable
+#
+# Standard basis for adding deep #dup and #clone to a class.
+# Provides a class with deep cloneablity via the standard
+# #dup and #clone methods.
+#
+# == Authors
+#
+# * Ken Bloom    (Current Version)
+# * Jim Weirich  (Original Version)
+#
+# == History
+#
+# Cloneable was ported from Jim Weirich's Rake.
+#
+# == Todo
+#
+# * Is there a more robust means to determining if clone or dup is used?
+#
+# == Copying
+#
+# Copyright (c) 2007 Ken Bloom
+#
+# 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.
+
+# = Clonable
+#
+# Standard basis for adding deep #dup and #clone to a class.
+# Provides a class with deep cloneablity via the standard
+# #dup and #clone methods.
+#
+module Cloneable
+  def initialize_copy(sibling)
+    #first duplicate my superclass' state. Note that if it's duplicating
+    #instance variables, this will be overwritten, but this is important
+    #because we could be dealing with a C extension with state hidden from
+    #the Ruby interpreter
+    super
+
+    #we want to know if we're being dup'ed or clone'd, because we want to
+    #preserve the state of our internals the same way our state is being
+    #preserved. (If we can't figure it out, we'll just use #dup.)
+    operation=caller.find{|x| x !~ /'initialize_copy'/}.
+      match(/`(dup|clone)'/)[1] or :dup
+
+    sibling.instance_variables.each do |ivar|
+      value = sibling.instance_variable_get(ivar)
+
+      #set my instance variable to be a #dup or #clone
+      #or my sibling, depending on what's happening to me right now
+      instance_variable_set(ivar, value.send(operation))
+    end
+  end
+end 
+
+# OLD VERSION
+
+#module Cloneable
+#  def clone
+#    sibling = self.class.new
+#    instance_variables.each do |ivar|
+#      value = self.instance_variable_get(ivar)
+#      sibling.instance_variable_set(ivar, value.dup) #rake_dup)
+#    end
+#    sibling
+#  end
+#  alias_method :dup, :clone
+#end
+