facets 2.4.2 → 2.4.3

data/lib/core/facets/numeric.rb

@@ -1,4 +1,4 @@
 require 'facets/numeric/approx'
-#require 'facets/numeric/distance'
+require 'facets/numeric/distance'
 require 'facets/numeric/round'
 

data/lib/core/facets/proc.rb

@@ -1,7 +1,6 @@
-#require 'facets/proc/bind'
+require 'facets/proc/bind'
 require 'facets/proc/compose'
 require 'facets/proc/curry'
-#require 'facets/proc/partial'
-#require 'facets/proc/to_method'
+require 'facets/proc/to_method'
 require 'facets/proc/update'
 

data/lib/core/facets/string.rb

@@ -5,12 +5,15 @@ require 'facets/string/capitalized.rb'
 require 'facets/string/chomp.rb'
 require 'facets/string/cleave.rb'
 require 'facets/string/divide.rb'
+require 'facets/string/each_word.rb'
 require 'facets/string/fold.rb'
 require 'facets/string/interpolate.rb'
 require 'facets/string/line_wrap.rb'
+require 'facets/string/methodize.rb'
 require 'facets/string/mscan.rb'
 require 'facets/string/natcmp.rb'
 require 'facets/string/nchar.rb'
+require 'facets/string/pathize.rb'
 require 'facets/string/range.rb'
 require 'facets/string/rewrite.rb'
 require 'facets/string/shatter.rb'
@@ -20,16 +23,15 @@ require 'facets/string/subtract.rb'
 require 'facets/string/tab.rb'
 require 'facets/string/titlecase.rb'
 require 'facets/string/to_re.rb'
-#require 'facets/string/to_time.rb'
-#require 'facets/string/words.rb'
+require 'facets/string/to_time.rb'
+require 'facets/string/words.rb'
 require 'facets/string/xor.rb'
 
-require 'facets/string/start_with.rb'
-require 'facets/string/end_with.rb'
-
+# 1.9
 require 'facets/string/bytes.rb'
 require 'facets/string/chars.rb'
 require 'facets/string/lines.rb'
-
+require 'facets/string/start_with.rb'
+require 'facets/string/end_with.rb'
 require 'facets/string/each_char.rb'
 

data/lib/core/facets/string/each_word.rb

@@ -0,0 +1,13 @@
+require 'facets/string/words'
+
+class String
+
+  # Iterate through each word of a string.
+  #
+  #   "a string".each_word { |word, range| ... }
+  #
+  def each_word(&block)
+    words.each(&block)
+  end
+
+end

data/lib/core/facets/string/methodize.rb

@@ -0,0 +1,12 @@
+class String
+
+  # Translate a (class or module) name to a suitable method name.
+  #
+  #   My::CoolClass.name.methodize => "my__cool_class"
+  #
+  def methodize
+    gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z])([A-Z])/,'\1_\2').gsub('::','__').downcase
+  end
+
+end
+

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

@@ -0,0 +1,12 @@
+class String
+
+  # Converts a (class or module) name to a unix path.
+  #
+  #   My::CoolClass.name.pathize  #=> "/my/cool_class"
+  #
+  def pathize
+    gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z])([A-Z])/,'\1_\2').gsub('::','/').downcase
+  end
+
+end
+

data/lib/core/facets/string/word_wrap.rb

@@ -0,0 +1,34 @@
+class String
+
+  # Word wrap a string not exceeding max width.
+  #
+  #   puts "this is a test".word_wrap(4)
+  #
+  # _produces_
+  #
+  #   this
+  #   is a
+  #   test
+  #
+  # This is basic implementation of word wrap, but smart
+  # enough to suffice for most use cases.
+  #
+  #  CREDIT: Gavin Kistner
+  #  CREDIT: Dayne Broderson
+  #
+  def word_wrap( col_width=80 )
+    self.dup.word_wrap!( col_width )
+  end
+
+  # As with #word_wrap, but modifies the string in place.
+  #
+  #   CREDIT: Gavin Kistner
+  #   CREDIT: Dayne Broderson
+  #
+  def word_wrap!( col_width=80 )
+    self.gsub!( /(\S{#{col_width}})(?=\S)/, '\1 ' )
+    self.gsub!( /(.{1,#{col_width}})(?:\s+|$)/, "\\1\n" )
+    self
+  end
+
+end

data/lib/core/facets/string/words.rb

@@ -1,173 +1,12 @@
-require 'facets/string/fold'
-
 class String
 
-  module Words
-
-    # Returns an array of characters.
-    #
-    #   "abc 123".words  #=> ["abc","123"]
-
-    def words
-      self.split(/\s+/)
-    end
-
-    # Iterate through each word of a string.
-    #
-    #   "a string".each_word { |word, range| ... }
-
-    def each_word( &yld )
-      rest_of_string = self
-      wordfind = /([-'\w]+)/
-      arity = yld.arity
-      offset = 0
-      while wmatch = wordfind.match(rest_of_string)
-        word = wmatch[0]
-        range = offset+wmatch.begin(0) ... offset+wmatch.end(0)
-        rest_of_string = wmatch.post_match
-        if arity == 1
-          yld.call(word)
-        else
-          yld.call(word, range)
-        end
-        offset = self.length - rest_of_string.length
-      end
-    end
-
-    # Filters out words from a string based on block test.
-    #
-    #   "a string".word_filter { |word| word =~ /^a/ }  #=> "string"
-    #
-    #   CREDIT: George Moschovitis
-
-    def word_filter( &blk )
-      s = self.dup
-      s.word_filter!( &blk )
-    end
-
-    # In place version of #word_filter.
-    #
-    #   "a string".word_filter { |word| ... }
-    #
-    #   CREDIT: George Moschovitis
-
-    def word_filter! #:yield:
-      rest_of_string = self
-      wordfind = /(\w+)/
-      offset = 0
-      while wmatch = wordfind.match(rest_of_string)
-        word = wmatch[0]
-        range = offset+wmatch.begin(0) ... offset+wmatch.end(0)
-        rest_of_string = wmatch.post_match
-        self[range] = yield( word ).to_s
-        offset = self.length - rest_of_string.length
-      end
-      self
-    end
-
-    # TODO: This is alternateive from glue: worth providing?
-    #
-    # Enforces a maximum width of a string inside an
-    # html container. If the string exceeds this maximum width
-    # the string gets wraped.
-    #
-    # Not really useful, better use the CSS overflow: hidden
-    # functionality.
-    #
-    # === Input:
-    # the string to be wrapped
-    # the enforced width
-    # the separator used for wrapping
-    #
-    # === Output:
-    # the wrapped string
-    #
-    # === Example:
-    #  text = "1111111111111111111111111111111111111111111"
-    #  text = wrap(text, 10, " ")
-    #  p text # => "1111111111 1111111111 1111111111"
-    #
-    # See the test cases to better understand the behaviour!
-
-    #   def wrap(width = 20, separator = " ")
-    #     re = /([^#{separator}]{1,#{width}})/
-    #     scan(re).join(separator)
-    #   end
-
-    # Word wrap a string not exceeding max width.
-    #
-    #   puts "this is a test".word_wrap(4)
-    #
-    # _produces_
-    #
-    #   this
-    #   is a
-    #   test
-    #
-    #   CREDIT: Gavin Kistner
-    #   CREDIT: Dayne Broderson
-
-    def word_wrap( col_width=80 )
-      self.dup.word_wrap!( col_width )
-    end
-
-    # As with #word_wrap, but modifies the string in place.
-    #
-    #   CREDIT: Gavin Kistner
-    #   CREDIT: Dayne Broderson
-
-    def word_wrap!( col_width=80 )
-      self.gsub!( /(\S{#{col_width}})(?=\S)/, '\1 ' )
-      self.gsub!( /(.{1,#{col_width}})(?:\s+|$)/, "\\1\n" )
-      self
-    end
-
-    # old def
-
-    #def word_wrap(max=80)
-    #  c = dup
-    #  c.word_wrap!(max)
-    #  c
-    #end
-
-    #def word_wrap!(max=80)
-    #  raise ArgumentError, "Wrap margin too low: #{n}" if max <= 2
-    #  #gsub!( Regexp.new( "(.{1,#{max-1}}\\w)\\b\\s*" ), "\\1\n")
-    #  gsub!( /(.{1,#{max-1}}\S)([ ]|\n)/, "\\1\n")
-    #end
-
-    # Returns short abstract of long strings; not exceeding +range+
-    # characters. If range is an integer then the minimum is 20%
-    # of the maximum. The string is chopped at the nearest word
-    # if possible, and appended by +ellipsis+, which defaults
-    # to '...'.
-    #
-    #   CREDIT: George Moschovitis
-    #   CREDIT: Trans
-
-    def brief(range=76, ellipsis="...")
-      if Range===range
-        min = range.first
-        max = range.last
-      else
-        max = range
-        min = max - (max/5).to_i
-        range = min..max
-      end
-
-      if size > max
-        cut_at = rindex(/\b/, max) || max
-        cut_at = max if cut_at < min
-        xstring = slice(0, cut_at)
-        xstring.chomp(" ") + ellipsis
-      else
-        self
-      end
-    end
-
+  # Returns an array of characters.
+  #
+  #   "abc 123".words  #=> ["abc","123"]
+  #
+  def words
+    self.split(/\s+/)
   end
 
-  include Words
-
 end
 

data/lib/core/facets/symbol.rb

@@ -1,4 +1,5 @@
 require 'facets/symbol/chomp'
+require 'facets/symbol/generate'
 require 'facets/symbol/not'
 require 'facets/symbol/succ'
 require 'facets/symbol/to_proc'

data/lib/more/facets/ansicode.rb

@@ -313,8 +313,8 @@ module ANSICode
 
 end
 
-module CLI #:nodoc:
-  # For backward compatability
-  ANSICode = ::ANSICode
-end
+#module Console #:nodoc:
+#  # For backward compatability
+#  ANSICode = ::ANSICode
+#end
 

data/lib/{core → more}/facets/hash/symbolize_keys.rb

@@ -19,7 +19,7 @@ class Hash
     end
   end
 
-  alias_method( :keys_to_sym, :symbolize_keys )
+  #alias_method( :keys_to_sym, :symbolize_keys )
 
   #--
   # # Rails has these aliases too, but they are not very good for
@@ -45,7 +45,7 @@ class Hash
 
   end
 
-  alias_method( :keys_to_sym!, :symbolize_keys! )
+  #alias_method( :keys_to_sym!, :symbolize_keys! )
 
   # Converts all keys in the Hash to Strings, returning a new Hash.
   # With a +filter+ parameter, limits conversion to only a certain selection of keys.
@@ -64,7 +64,7 @@ class Hash
     end
   end
 
-  alias_method(:keys_to_s, :stringify_keys)
+  #alias_method(:keys_to_s, :stringify_keys)
 
   # Synonym for Hash#stringify_keys, but modifies the receiver in place and returns it.
   # With a +filter+ parameter, limits conversion to only a certain selection of keys.
@@ -83,11 +83,10 @@ class Hash
     end
   end
 
-  alias_method( :keys_to_s!, :stringify_keys!)
+  #alias_method( :keys_to_s!, :stringify_keys!)
 
   #--
-  # # Rails has these aliases too, but they are not very good for
-  # # gerenal use, IMHO. But perhaps someone can convince me otherwise.
+  # # Rails has these aliases too.
   # alias_method( :to_options!, :symbolize_keys! )
   #++
 

data/lib/more/facets/string/words.rb

@@ -0,0 +1,173 @@
+require 'facets/string/fold'
+
+class String
+
+  module Words
+
+    # Returns an array of characters.
+    #
+    #   "abc 123".words  #=> ["abc","123"]
+
+    def words
+      self.split(/\s+/)
+    end
+
+    # Iterate through each word of a string.
+    #
+    #   "a string".each_word { |word, range| ... }
+
+    def each_word( &yld )
+      rest_of_string = self
+      wordfind = /([-'\w]+)/
+      arity = yld.arity
+      offset = 0
+      while wmatch = wordfind.match(rest_of_string)
+        word = wmatch[0]
+        range = offset+wmatch.begin(0) ... offset+wmatch.end(0)
+        rest_of_string = wmatch.post_match
+        if arity == 1
+          yld.call(word)
+        else
+          yld.call(word, range)
+        end
+        offset = self.length - rest_of_string.length
+      end
+    end
+
+    # Filters out words from a string based on block test.
+    #
+    #   "a string".word_filter { |word| word =~ /^a/ }  #=> "string"
+    #
+    #   CREDIT: George Moschovitis
+
+    def word_filter( &blk )
+      s = self.dup
+      s.word_filter!( &blk )
+    end
+
+    # In place version of #word_filter.
+    #
+    #   "a string".word_filter { |word| ... }
+    #
+    #   CREDIT: George Moschovitis
+
+    def word_filter! #:yield:
+      rest_of_string = self
+      wordfind = /(\w+)/
+      offset = 0
+      while wmatch = wordfind.match(rest_of_string)
+        word = wmatch[0]
+        range = offset+wmatch.begin(0) ... offset+wmatch.end(0)
+        rest_of_string = wmatch.post_match
+        self[range] = yield( word ).to_s
+        offset = self.length - rest_of_string.length
+      end
+      self
+    end
+
+    # TODO: This is alternateive from glue: worth providing?
+    #
+    # Enforces a maximum width of a string inside an
+    # html container. If the string exceeds this maximum width
+    # the string gets wraped.
+    #
+    # Not really useful, better use the CSS overflow: hidden
+    # functionality.
+    #
+    # === Input:
+    # the string to be wrapped
+    # the enforced width
+    # the separator used for wrapping
+    #
+    # === Output:
+    # the wrapped string
+    #
+    # === Example:
+    #  text = "1111111111111111111111111111111111111111111"
+    #  text = wrap(text, 10, " ")
+    #  p text # => "1111111111 1111111111 1111111111"
+    #
+    # See the test cases to better understand the behaviour!
+
+    #   def wrap(width = 20, separator = " ")
+    #     re = /([^#{separator}]{1,#{width}})/
+    #     scan(re).join(separator)
+    #   end
+
+    # Word wrap a string not exceeding max width.
+    #
+    #   puts "this is a test".word_wrap(4)
+    #
+    # _produces_
+    #
+    #   this
+    #   is a
+    #   test
+    #
+    #   CREDIT: Gavin Kistner
+    #   CREDIT: Dayne Broderson
+
+    def word_wrap( col_width=80 )
+      self.dup.word_wrap!( col_width )
+    end
+
+    # As with #word_wrap, but modifies the string in place.
+    #
+    #   CREDIT: Gavin Kistner
+    #   CREDIT: Dayne Broderson
+
+    def word_wrap!( col_width=80 )
+      self.gsub!( /(\S{#{col_width}})(?=\S)/, '\1 ' )
+      self.gsub!( /(.{1,#{col_width}})(?:\s+|$)/, "\\1\n" )
+      self
+    end
+
+    # old def
+
+    #def word_wrap(max=80)
+    #  c = dup
+    #  c.word_wrap!(max)
+    #  c
+    #end
+
+    #def word_wrap!(max=80)
+    #  raise ArgumentError, "Wrap margin too low: #{n}" if max <= 2
+    #  #gsub!( Regexp.new( "(.{1,#{max-1}}\\w)\\b\\s*" ), "\\1\n")
+    #  gsub!( /(.{1,#{max-1}}\S)([ ]|\n)/, "\\1\n")
+    #end
+
+    # Returns short abstract of long strings; not exceeding +range+
+    # characters. If range is an integer then the minimum is 20%
+    # of the maximum. The string is chopped at the nearest word
+    # if possible, and appended by +ellipsis+, which defaults
+    # to '...'.
+    #
+    #   CREDIT: George Moschovitis
+    #   CREDIT: Trans
+
+    def brief(range=76, ellipsis="...")
+      if Range===range
+        min = range.first
+        max = range.last
+      else
+        max = range
+        min = max - (max/5).to_i
+        range = min..max
+      end
+
+      if size > max
+        cut_at = rindex(/\b/, max) || max
+        cut_at = max if cut_at < min
+        xstring = slice(0, cut_at)
+        xstring.chomp(" ") + ellipsis
+      else
+        self
+      end
+    end
+
+  end
+
+  include Words
+
+end
+