facets 2.9.3 → 3.0.0

data/lib/standard/facets/cloneable.rb

@@ -4,20 +4,23 @@
 # Cloneable was originally ported from Jim Weirich's Rake.
 # The current version is the work of Ken Bloom.
 #
+# DEPRECATED: A better approach is to provide a #deep_dup and and a #deep_clone,
+# then if a class needs these for #dup and #clone they can just alias them.
+#
 # CREDIT: Ken Bloom
 
 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
+    # 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.)
+    # 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 = (
       copy_call  = caller.find{|x| x !~ /'initialize_copy'/}
       copy_match = copy_call.match(/`(dup|clone)'/)
@@ -27,8 +30,8 @@ module Cloneable
     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
+      # 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

data/lib/standard/facets/enumargs.rb

@@ -1,195 +1,186 @@
-# Enumerable::Arguments
-#
-# Copyright (c) 2004 Thomas Sawyer
-#
-# LGPL(3) 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.
-
-begin
-  require 'enumerator'
-rescue LoadError
-end
-
-# This is a simple reimplementation of the core Enumerable module
-# to allow the methods to take and pass-on arbitrary arguments to the
-# underlying #each call. This library uses Enumerator and scans
-# Enumerable so it can alwasy stay in sync.
-#
-# NOTE Any Enumerable method with a negative arity cannot do pass arguments
-# due to ambiguity in the argument count. So the methods #inject and #zip
-# do NOT work this way, but simply work as they do in Enumerable.
-# The method #find (and #detect) though has been made to work by removing
-# its rarely used optional parameter and providing instead an optional
-# keyword parameter (:ifnone => ...). Please keep these difference in mind.
-#
-#   require 'enumargs'
-#
-#   class T
-#     include Enumerable::Arguments
-#     def initialize(arr)
-#       @arr = arr
-#     end
-#     def each(n)
-#       arr.each{ |e| yield(e+n) }
-#     end
-#   end
-#
-#   t = T.new([1,2,3])
-#   t.collect(4)
-#   #=> [5,6,7]
-#
 module Enumerable
-module Arguments
-
-  def self.wrap_enumerable_method( methodname )
+  # This is a simple reimplementation of the core Enumerable module
+  # to allow its methods to take and pass-on arbitrary arguments to the
+  # underlying #each call. This library uses Enumerator and scans
+  # Enumerable so it can alwasy stay in sync.
+  #
+  # NOTE: Any Enumerable method with a negative arity cannot pass arguments
+  # due to ambiguity in the argument count. So the methods #inject and #zip
+  # do NOT work this way, but simply work as they do in Enumerable. However,
+  # The methods #find and #detect have been made modified to work by removing
+  # its rarely used optional parameter and providing instead an optional
+  # keyword parameter (:ifnone => ...). Please keep these difference in mind.
+  #
+  # Example
+  #   require 'enumargs'
+  #
+  #   class T
+  #     include Enumerable::Argumentable
+  #     def initialize(arr)
+  #       @arr = arr
+  #     end
+  #     def each(n)
+  #       arr.each{ |e| yield(e+n) }
+  #     end
+  #   end
+  #
+  #   t = T.new([1,2,3])
+  #   t.collect(4)
+  #   #=> [5,6,7]
+  #
+  module Argumentable
+
+    # Helper method to wrap Enumerable methods.
+    def self.wrap_enumerable_method( methodname )
+      m = methodname
+      meth = Enumerable.instance_method(m)
+      arity = meth.arity
+
+      case arity <=> 0
+      when 0
+        class_eval %{
+          def #{m}( *args, &yld )
+            enum_for(:each, *args).#{m}( &yld )
+          end
+        }
+      when 1
+        class_eval %{
+          def #{m}( *args, &yld )
+            args, each_args = args[0...#{arity}], args[#{arity}..-1]
+            enum_for(:each, *each_args).#{m}( *args, &yld )
+          end
+        }
+      else
+        class_eval %{
+          def #{m}( *args, &yld )
+            enum_for(:each).#{m}( *args, &yld )
+          end
+        }
+      end
+    end
 
-    m = methodname
-    meth = Enumerable.instance_method(m)
-    arity = meth.arity
+    # Wrap all Enumerable's public instance methods
+    Enumerable.instance_methods(false).each do |m|
+      wrap_enumerable_method( m )
+    end
 
-    case arity <=> 0
-    when 0
-      class_eval %{
-        def #{m}( *args, &yld )
-          enum_for(:each, *args).#{m}( &yld )
-        end
-      }
-    when 1
-      class_eval %{
-        def #{m}( *args, &yld )
-          args, each_args = args[0...#{arity}], args[#{arity}..-1]
-          enum_for(:each, *each_args).#{m}( *args, &yld )
-        end
-      }
-    else
-      class_eval %{
-        def #{m}( *args, &yld )
-          enum_for(:each).#{m}( *args, &yld )
-        end
-      }
+    # Support for #to_a.
+    #
+    def to_a(*args)
+      #map(*args){ |x| x }
+      enum_for(:each, *args).to_a
     end
-  end
 
-  Enumerable.instance_methods(false).each do |m|
-    wrap_enumerable_method( m )
-  end
+    # Make exception for #find (a negative arity method) to accept
+    # keyword argument.
+    #
+    #   ObjectSpace.find(Class, :ifnone=>lambda{1}) { |e| ... }
+    #   ObjectSpace.find(Class, :ifnone=>lambda{1}) { |e| ... }
+    #
+    def find(*args, &yld)  # future use **keys ?
+      if Hash === args.last and args.last.key?(:ifnone)
+        ifnone = args.last.delete(:ifnone)
+        args.pop if args.last.empty?
+        enum_for(:each, *args).find( ifnone, &yld )
+      else
+        enum_for(:each, *args).find( &yld )
+      end
+    end
 
-  #
-  def to_a(*args)
-    map(*args){ |x| x }
-  end
+    alias_method :detect, :find
 
-  # Make exception for #find (a negative arity method) to accept
-  # keyword argument.
-  #
-  #   ObjectSpace.find(Class, :ifnone=>lambda{1}) { |e| ... }
-  #   ObjectSpace.find(Class, :ifnone=>lambda{1}) { |e| ... }
-  #
-  def find(*args, &yld)  # future use **keys ?
-    if Hash === args.last and args.last.key?(:ifnone)
-      ifnone = args.last.delete(:ifnone)
-      args.pop if args.last.empty?
-      enum_for(:each, *args).find( ifnone, &yld )
-    else
-      enum_for(:each, *args).find( &yld )
-    end
   end
-  alias_method :detect, :find
 
-end
+  # DEPRECATED: Module alias for old name.
+  Arguments = Argumentable
 end
 
 
 =begin  OLD CODE
-module EnumerableArgs
+  module EnumerableArgs
 
-  def collect(*args)  # :yield:
-    a = []
-    each(*args){ |n| a << yield(n) }
-    a
-  end
-  alias_method( :map, :collect )
+    def collect(*args)  # :yield:
+      a = []
+      each(*args){ |n| a << yield(n) }
+      a
+    end
+    alias_method( :map, :collect )
 
-  def detect(*args)  # :yield:
-    each(*args){ |n| return n if yield(n) }
-    nil
-  end
-  alias_method( :find, :detect )
+    def detect(*args)  # :yield:
+      each(*args){ |n| return n if yield(n) }
+      nil
+    end
+    alias_method( :find, :detect )
 
-  def each_with_index(*args)
-    i=0
-    each(*args){ |*n| n << i; yield(*n); i+=1 }
-    self
-  end
+    def each_with_index(*args)
+      i=0
+      each(*args){ |*n| n << i; yield(*n); i+=1 }
+      self
+    end
 
-  def to_a(*args)
-    a = []
-    each(*args){ |n| a << n }
-    a
-  end
-  alias_method( :entries, :to_a )
-
-  # An additional method not part of standard Enumerable.
-  # The regular version of this method can be found in Facets,
-  # but it is a bit more advanced then this one.
-  # At some point they need to be put into sync.
-  def each_slice(*args, &yld)
-    a = []; s = []
-    ar = yld.arity.abs
-    each(*args){ |n|
-      s << n
-      if s.length >= ar
-        yld.call(*s)
-        s = []
-      end
-    }
-    a
-  end
-  alias_method( :each_by, :each_slice )
+    def to_a(*args)
+      a = []
+      each(*args){ |n| a << n }
+      a
+    end
+    alias_method( :entries, :to_a )
+
+    # An additional method not part of standard Enumerable.
+    # The regular version of this method can be found in Facets,
+    # but it is a bit more advanced then this one.
+    # At some point they need to be put into sync.
+    def each_slice(*args, &yld)
+      a = []; s = []
+      ar = yld.arity.abs
+      each(*args){ |n|
+        s << n
+        if s.length >= ar
+          yld.call(*s)
+          s = []
+        end
+      }
+      a
+    end
+    alias_method( :each_by, :each_slice )
 
-  def select(*args)  # :yield:
-    a = []
-    each(*args){ |n| a << n if yield(n) }
-    a
-  end
-  alias_method( :find_all, :select )
+    def select(*args)  # :yield:
+      a = []
+      each(*args){ |n| a << n if yield(n) }
+      a
+    end
+    alias_method( :find_all, :select )
 
-  def grep(pattern, *args)
-    a = []
-    each(*args){ |n| a << (block_given? ? yield(n) : n) if pattern === n }
-    a
-  end
+    def grep(pattern, *args)
+      a = []
+      each(*args){ |n| a << (block_given? ? yield(n) : n) if pattern === n }
+      a
+    end
 
-  def include?(anObj, *args)
-    each(*args){ |n| return true if anObj == n }
-    false
-  end
-  alias_method( :member?, :include? )
+    def include?(anObj, *args)
+      each(*args){ |n| return true if anObj == n }
+      false
+    end
+    alias_method( :member?, :include? )
 
-  def max(*args)
-    to_a(*args).max
-  end
+    def max(*args)
+      to_a(*args).max
+    end
 
-  def min(*args)
-    to_a(*args).min
-  end
+    def min(*args)
+      to_a(*args).min
+    end
 
-  def reject(*args)
-    a = []
-    each(*args){ |n| a << n if ! yield(n) }
-    a
-  end
+    def reject(*args)
+      a = []
+      each(*args){ |n| a << n if ! yield(n) }
+      a
+    end
 
-  def sort(*args)
-    # TODO
-  end
+    def sort(*args)
+      # TODO
+    end
 
-end
+  end
 =end
 
+# Copyright (c) 2004 Rubyworks (BSD-2-Clause)

data/lib/standard/facets/find.rb

@@ -1,16 +1,2 @@
-require 'facets/enumerator'
-
-module Find
-  # Identical to find except select returns the matching files as an array.
-  # (find returns nil, which is not very useful if you actually wanted an array.)
-  # Calls the associated block with the name of every file and directory listed
-  # as arguments, then recursively on their subdirectories, and so on.
-  # Return a true (non-false) value from the block for every path that
-  # you want to be returned in the resulting array. You can still use Find.prune.
-  #
-  # CREDIT: Tyler Rick
-  def self.select(*paths, &block)
-    Enumerator.new(self, :find, *paths).select{|value| yield value}
-  end
-end
+require 'facets/find/select'
 

data/lib/standard/facets/find/select.rb

@@ -0,0 +1,16 @@
+require 'facets/enumerator'
+
+module Find
+  # Identical to find except select returns the matching files as an array.
+  # (find returns nil, which is not very useful if you actually wanted an array.)
+  # Calls the associated block with the name of every file and directory listed
+  # as arguments, then recursively on their subdirectories, and so on.
+  # Return a true (non-false) value from the block for every path that
+  # you want to be returned in the resulting array. You can still use Find.prune.
+  #
+  # CREDIT: Tyler Rick
+  def self.select(*paths, &block)
+    Enumerator.new(self, :find, *paths).select{|value| yield value}
+  end
+end
+

data/lib/standard/facets/gem/search.rb

@@ -0,0 +1,18 @@
+require 'facets/gem/specification/current_specs'
+
+module Gem
+
+  # Search RubyGems for matching paths in current gem versions.
+  def self.search(match, options={})
+    matches = []
+    Gem::Specification.current_specs.each do |spec|
+      glob = File.join(spec.lib_dirs_glob, match)
+      list = Dir[glob] #.map{ |f| f.untaint }
+      list = list.map{ |d| d.chomp('/') }
+      matches.concat(list)
+    end
+    matches
+  end
+
+end
+