facets 2.9.3 → 3.0.0

data/lib/core/facets/enumerator/lazy/squeeze.rb

@@ -0,0 +1,33 @@
+if defined?(Enumerator::Lazy)
+  class Enumerator
+    class Lazy
+
+      # Enumerator::Lazy version of Enumerable#squeeze.
+      # Note: you must use Ruby 2.0+ or require 'backports'.
+      # For now, you have to require 'facets/enumerator/lazy/squeeze' explicitly.
+      #
+      # Examples
+      #
+      #   [1,2,2,3,3,2,1].lazy.squeeze.to_a #=> [1,2,3,2,1]
+      #   [1,2,2,3,3,2,1].lazy.squeeze(*[3]).to_a #=> [1,2,2,3,2,1]
+      #
+      # Returns Enumerator::Lazy.
+      #
+      # CREDIT: T. Yamada
+
+      def squeeze(*limited_to)
+        first = true
+        cur = nil
+        self.class.new(self) do |y,v|
+          if !limited_to.empty? && !limited_to.include?(v)
+            y << v
+          elsif first || cur != v
+            y << v
+            first = false
+            cur = v
+          end
+        end
+      end
+    end
+  end
+end

data/lib/core/facets/essentials.rb

@@ -0,0 +1,65 @@
+# As suggested by Roger Pack this file is a simple convenience
+# for loading a limited set of *essential* core extensions. By
+# *essential* we mean, more or less, the extensions we think
+# ought to be in Ruby proper anyway.
+#
+# NOTE: This is very much a work in progress! Please feel frre to 
+#   suggest which extensions you think belong here.
+
+require_relative 'functor'
+
+### Kernel
+require_relative 'kernel/blank'
+#require_relative 'kernel/deep_copy'
+#require_relative 'kernel/deep_dup'
+require_relative 'kernel/false'
+require_relative 'kernel/true'
+
+### Object
+require_relative 'object/itself'
+
+### Array
+require_relative 'array/delete_values'
+require_relative 'array/reject_values'
+require_relative 'array/uniq_by'
+
+### Binding
+require_relative 'binding/self'
+
+### Dir
+require_relative 'dir/ascend'
+require_relative 'dir/descend'
+require_relative 'dir/lookup'
+
+### Enumerable
+require_relative 'enumerable/cluster'
+require_relative 'enumerable/graph'
+require_relative 'enumerable/value_by'
+
+### File
+require_relative 'file/write'
+
+### Hash
+require_relative 'hash/autonew'
+require_relative 'hash/compact'
+#require_relative 'hash/data'
+require_relative 'hash/delete_values'
+require_relative 'hash/except'
+require_relative 'hash/rekey'
+require_relative 'hash/revalue'
+require_relative 'hash/slice'
+
+### Proc
+#require_relative 'proc/wrap'
+
+### Regexp
+#require_relative 'regexp/to_proc'
+
+### String
+require_relative 'string/indent'
+require_relative 'string/index_all'
+require_relative 'string/mscan'
+require_relative 'string/trim'
+require_relative 'string/unindent'
+#require_realtive 'string/word_wrap'
+

data/lib/core/facets/exception.rb

@@ -1,5 +1,3 @@
-require 'facets/kernel/require_relative'
-
 require_relative 'exception/detail.rb'
 require_relative 'exception/raised.rb'
 require_relative 'exception/suppress.rb'

data/lib/core/facets/exception/set_message.rb

@@ -0,0 +1,10 @@
+class Exception
+
+  # See exception message.
+  #
+  def set_message(string)
+    @mesg = string.to_s
+  end
+
+end
+

data/lib/core/facets/file.rb

@@ -1,7 +1,6 @@
-require 'facets/kernel/require_relative'
-
 require_relative 'file/append.rb'
 #require_relative 'file/atomic_write.rb'    # uncommon
+require_relative 'file/common_path.rb'
 require_relative 'file/create.rb'
 require_relative 'file/ext.rb'
 require_relative 'file/null.rb'

data/lib/core/facets/file/common_path.rb

@@ -0,0 +1,17 @@
+class File
+
+  # Given an array of path strings, find the longest common prefix path.
+  #
+  # @author Aaron Gibralter
+  def self.common_path(*paths)
+    return paths.first if paths.length <= 1
+
+    arr = paths.sort
+    f = arr.first.split('/')
+    l = arr.last.split('/')
+    i = 0
+    i += 1 while f[i] == l[i] && i <= f.length
+    f.slice(0, i).join('/')
+  end
+
+end

data/lib/core/facets/file/rootname.rb

@@ -13,7 +13,7 @@ class File
     # -- this should be fairly robust
     path_re = Regexp.new('[' + Regexp.escape(File::Separator + %q{\/}) + ']')
 
-    head, tail = path.split(path_re, 2)
+    head, _ = path.split(path_re, 2)
     return '.' if path == head
     return '/' if head.empty?
     return head

data/lib/core/facets/filetest.rb

@@ -1,5 +1,3 @@
-require 'facets/kernel/require_relative'
-
 require_relative 'filetest/absolute.rb'
 require_relative 'filetest/contains.rb'
 require_relative 'filetest/relative.rb'

data/lib/core/facets/filetest/relative.rb

@@ -13,7 +13,7 @@ module FileTest
   # The opposite of #absolute?
   def relative?(path)
     while r = chop_basename(path.to_s)
-      path, basename = r
+      path, _ = r
     end
     path == ''
   end

data/lib/core/facets/filetest/safe.rb

@@ -4,17 +4,21 @@ module FileTest
 
   module_function
 
-    # Is a path considered reasonably "safe"?
-    #
-    # Do not mistake this for a perfect solution!
-    def safe?(path)
-      case path
-      when /\A(#{SEPARATOR_PATTERN}|\~)(#{SEPARATOR_PATTERN}|\*)+/
-        false
-      else
-        true
-      end
+  # Is a path considered reasonably "safe"?
+  #
+  # Do not mistake this for a perfect solution!
+  # Please help improve if you know how!
+  #
+  # Returns [Boolean]
+
+  def safe?(path)
+    case path
+    when /\A(#{SEPARATOR_PATTERN}|\~)(#{SEPARATOR_PATTERN}|\*)+/
+      false
+    else
+      true
     end
+  end
 
 end
 

data/lib/core/facets/float.rb

@@ -1,4 +1,2 @@
-require 'facets/kernel/require_relative'
-
-require_relative 'float/round.rb'
+require_relative 'float/round_to.rb'
 

data/lib/core/facets/float/round_to.rb

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

data/lib/core/facets/functor.rb

@@ -1,7 +1,7 @@
-# By definition a Functor is simply a first class method, but these are common
-# in the form of Method and Proc. So for Ruby a Functor is a more specialized
-# as a Higher-order function or Metafunction. Essentally, a Functor can vary
-# its behavior accorrding to the operation applied to it.
+# Functor is Ruby's implementation of a Higher-Order-Message. Essentally, 
+# a Functor can vary its behavior accorrding to the operation applied to it.
+#
+# Example
 #
 #   f = Functor.new { |op, x| x.send(op, x) }
 #   (f + 1)  #=> 2
@@ -18,7 +18,7 @@ class Functor #< BasicObject
   # can be used to speed things up.
   #
   # The +key+ will always be an array, wich makes it easier
-  # to cache functor for multiple factors.
+  # to cache Functor for multiple factors.
   #
   def self.cache(*key, &function)
     @cache ||= {}
@@ -40,7 +40,7 @@ class Functor #< BasicObject
   alias :__class__ :class
 
   ## If Functor were built-in to Ruby this would not be
-  ## needed since exceetions could just be added directly.
+  ## needed since exceptions could just be added directly.
   ##$FUNCTOR_EXCEPTIONS ||= [:binding, :undefine_method]
 
   ## TODO: This will not work when BasicObject is utilized. How to fix?
@@ -73,7 +73,7 @@ class Functor #< BasicObject
   end
 
   ##def inspect
-  ##  #"#<Functor:#{object_id} #{method_missing(:inspect)}>"    # hex id ?
+  ##  #"#<#{__class__}:#{object_id} #{method_missing(:inspect)}>"    # hex id ?
   ##  "#{method_missing(:inspect)}"
   ##end
 
@@ -84,11 +84,9 @@ class Functor #< BasicObject
 
   private
 
-  # Any action against the functor is processesd by the function.
+  # Any action against the Functor is processesd by the function.
   def method_missing(op, *args, &blk)
     @function.call(op, *args, &blk)
   end
 
 end
-
-# Copyright (c) 2004 Thomas Sawyer (Ruby License)

data/lib/core/facets/hash.rb

@@ -1,12 +1,9 @@
-require 'facets/kernel/require_relative'
-
 require_relative 'hash/alias.rb'
 require_relative 'hash/argumentize.rb'
 require_relative 'hash/at.rb'
 require_relative 'hash/autonew.rb'
 require_relative 'hash/collate.rb'
 require_relative 'hash/count.rb'
-require_relative 'hash/data.rb'
 require_relative 'hash/dearray_values.rb'
 require_relative 'hash/deep_merge.rb'
 require_relative 'hash/delete.rb'
@@ -14,7 +11,9 @@ require_relative 'hash/delete_at.rb'
 require_relative 'hash/delete_unless.rb'
 require_relative 'hash/delete_values.rb'
 require_relative 'hash/diff.rb'
+require_relative 'hash/each_with_key.rb'
 require_relative 'hash/except.rb'
+require_relative 'hash/fetch_nested.rb'
 require_relative 'hash/graph.rb'
 require_relative 'hash/insert.rb'
 require_relative 'hash/inverse.rb'
@@ -34,13 +33,11 @@ require_relative 'hash/recursively.rb'
 require_relative 'hash/rekey.rb'
 require_relative 'hash/replace_each.rb'
 require_relative 'hash/reverse_merge.rb'
-require_relative 'hash/select.rb'
 require_relative 'hash/slice.rb'
 require_relative 'hash/stringify_keys.rb'
 require_relative 'hash/subset.rb'
 require_relative 'hash/swap.rb'
 require_relative 'hash/symbolize_keys.rb'
-require_relative 'hash/to_h.rb'
 require_relative 'hash/to_mod.rb'
 require_relative 'hash/to_options.rb'
 require_relative 'hash/to_proc.rb'

data/lib/core/facets/hash/collate.rb

@@ -6,20 +6,34 @@ class Hash
   #   { :a=>1, :b=>2 }.collate(:a=>3, :b=>4, :c=>5)
   #   #=> { :a=>[1,3], :b=>[2,4], :c=>[5] }
   #
+  # As of v3.0, this method no longer automatically flattens
+  # the array values. To acheive the same effect add a flat map.
+  #
+  #   h = { :a=>[1,3], :b=>[2,4], :c=>[5] }.collate(:a=>6, :b=>7, :c=>8)
+  #   h.each_value{ |v| v.flatten! }
+  #   #=> { :a=>[1,3,6], :b=>[2,4,7], :c=>[5,8] }
+  #
   # @author Trans         (rewrite)
   # @author Tilo Sloboda  (bug fixes)
   # @author Gavin Kistner (original)
 
-  def collate(other)
-    h = Hash.new
-    (keys + other.keys).each do |key|
-      h[key] = []
+  def collate(*others)
+    h = {}
+    keys.each do |k|
+      h[k] = []
+    end
+    others.each do |other|
+      other.keys.each do |k|
+        h[k] = []
+      end
     end
-    each do |key, value|
-      h[key] << value
+    each do |k, v|
+      h[k] << v
     end
-    other.each do |key, value|
-      h[key] << value
+    others.each do |other|
+      other.each do |k, v|
+        h[k] << v
+      end
     end
     h.each{ |k,v| v.flatten! }
     h

data/lib/core/facets/hash/count.rb

@@ -1,11 +1,15 @@
 class Hash
 
-  # Like Enumerable#count, but counts hash values.
+  # Like Enumerable#count, but can count hash values.
   #
-  #   {:A=>1, :B=>1}.count(1) #=> 2
+  #   {:A=>1, :B=>1}.count(1)  #=> 2
   #
-  def count(value)
-    values.count(value)
+  def count(*value)
+    if value.empty?
+      super()
+    else
+      values.count(*value)
+    end
   end
 
 end

data/lib/core/facets/hash/data.rb

@@ -16,9 +16,12 @@ class Hash
   #   h.data.a?  #=> true
   #   h.data.d?  #=> false
   #
-  # TODO: Change name of Hash#data to something better?
+  # TODO: Is there a better name for `data` --perhaps `open`?
   #
-  # TODO: Is this really a method worth having?
+  # TODO: Is this method really worth having?
+  #
+  # Returns [Functor].
+
   def data
     this = self
     Functor.new do |op, *a|

data/lib/core/facets/hash/dearray_values.rb

@@ -1,6 +1,6 @@
 class Hash
 
-  # Any array values with be replaced with the first element of the array.
+  # Any array values will be replaced with the first element of the array.
   # Arrays with no elements will be set to nil.
   #
   #   h = { :a=>[1], :b=>[1,2], :c=>3, :d=>[] }

data/lib/core/facets/hash/deep_rekey.rb

@@ -0,0 +1,54 @@
+require 'facets/hash/recurse'
+require 'facets/hash/rekey'
+
+class Hash
+
+  # Rekey a hash and all sub-hashes:
+  #
+  #   deep_rekey()
+  #   deep_rekey(from_key => to_key, ...)
+  #   deep_rekey{|from_key| to_key}
+  #   deep_rekey{|from_key, value| to_key}
+  #
+  # If a key map is given, then the first key is changed to the second key.
+  #
+  #   foo = { :c=>{ :a=>1, :b=>2 } }
+  #   foo.deep_rekey(:a=>'a')       #=> { :c=>{ 'a'=>1, :b=>2 } }
+  #   foo.deep_rekey(:b=>:x)        #=> { :c=>{ :a =>1, :x=>2 } }
+  #   foo.deep_rekey('foo'=>'bar')  #=> { :c=>{ :a =>1, :b=>2 } }
+  #
+  # If a block is given, converts all keys in the Hash accroding to the
+  # given block procedure.
+  #
+  #   foo = { :person=>{ :name=>'Gavin', :wife=>:Lisa } }
+  #   foo.deep_rekey{ |k| k.to_s }  #=>  { "person"=>{ "name"=>"Gavin", "wife"=>:Lisa } }
+  #   foo                      #=>  { "person"=>{ "name"=>"Gavin", "wife"=>:Lisa } }
+  #
+  # If no key map or block is given, then all keys are converted
+  # to Symbols.
+  #
+  # Raises an ArgumentError if both a +key_map+ and a block are given.
+  # If both are needed just call #deep_rekey twice.
+  #
+  # TODO: If `nil` is returned by block should the key be set to `nil` or the orignal key?
+  #
+  # CREDIT: Trans, Gavin Kistner, Ryan Duryea
+
+  def deep_rekey(key_map=nil, &block)
+    recurse do |h|
+      h.rekey(key_map, &block)
+    end
+  end
+
+  # Synonym for Hash#deep_rekey, but modifies the receiver in place (and returns it).
+  #
+  #   foo = { :person=>{ :name=>'Gavin', :wife=>:Lisa } }
+  #   foo.deep_rekey!{ |k| k.to_s }  #=>  { "person"=>{ "name"=>"Gavin", "wife"=>:Lisa } }
+  #   foo                       #=>  { "person"=>{ "name"=>"Gavin", "wife"=>:Lisa } }
+  #
+  # CREDIT: Trans, Gavin Kistner, Ryan Duryea
+
+  def deep_rekey!(key_map=nil, &block)
+    replace(deep_rekey(key_map, &block))
+  end
+end