facets 0.6.3

data/lib/facet/string/index_all.rb

@@ -0,0 +1,19 @@
+class String
+  # Like index but returns an array of all index locations.
+  # The reuse flag allows the trailing portion of a match to be 
+  # reused for subsquent matches.
+  #
+  #   require 'facet/string/index_all'
+  #
+  #   "abcabcabc".index_all('a')  #=> [0,3,6]
+  #
+  def index_all(s, reuse=false)
+    ia = []; i = 0
+    while (i = self.index(s,i))
+      ia << i
+      i += (reuse ? 1 : $~.length)
+    end
+    ia
+  end
+  #alias_method( :indexes, :index_all )
+end

data/lib/facet/string/inflect.rb

@@ -0,0 +1,70 @@
+class String
+ 
+  def inflect
+    Inflect.new( self )
+  end
+
+  class Inflect
+    def initialize( word )
+      @self = word
+    end
+
+    # only available via public call
+    def self
+      @self
+    end
+   
+    def pluralize
+      result = word.to_s.dup
+      plural_rules.each do |(rule, replacement)|
+        break if result.gsub!(rule, replacement)
+      end
+      return result      
+    end
+
+    def singularize #(word)
+      result = word.to_s.dup
+      singular_rules.each do |(rule, replacement)|
+        break if result.gsub!(rule, replacement)
+      end
+      return result
+    end
+
+    private
+    
+    def plural_rules #:doc:
+      [
+        [/(x|ch|ss|sh)$/, '\1es'],            # search, switch, fix, box, process, address
+        [/([^aeiouy]|qu)ies$/, '\1y'],
+        [/([^aeiouy]|qu)y$/, '\1ies'],        # query, ability, agency
+        [/(?:([^f])fe|([lr])f)$/, '\1\2ves'], # half, safe, wife
+        [/sis$/, 'ses'],                      # basis, diagnosis
+        [/([ti])um$/, '\1a'],                 # datum, medium
+        [/person$/, 'people'],                # person, salesperson
+        [/man$/, 'men'],                      # man, woman, spokesman
+        [/child$/, 'children'],               # child
+        [/s$/, 's'],                          # no change (compatibility)
+        [/$/, 's']
+      ]
+    end
+
+    def singular_rules #:doc:
+      [
+        [/(x|ch|ss)es$/, '\1'],
+        [/movies$/, 'movie'],
+        [/([^aeiouy]|qu)ies$/, '\1y'],
+        [/([lr])ves$/, '\1f'],
+        [/([^f])ves$/, '\1fe'],
+        [/(analy|ba|diagno|parenthe|progno|synop|the)ses$/, '\1sis'],
+        [/([ti])a$/, '\1um'],
+        [/people$/, 'person'],
+        [/men$/, 'man'],
+        [/status$/, 'status'],
+        [/children$/, 'child'],
+        [/s$/, '']
+      ]
+    end
+       
+  end
+
+end

data/lib/facet/string/line_to_char_map.rb

@@ -0,0 +1,18 @@
+class String
+  # Returns an array of ranges mapping 
+  # the characters per line.
+  #
+  #   require 'facet/string/line_to_char_map'
+  #
+  #   "this\nis\na\ntest".line_to_char_map
+  #   #=> [0..4, 5..7, 8..9, 10..13]
+  #
+  def line_to_char_map
+    offset=0; charmap = []
+    self.each do |line|
+      charmap << (offset..(offset + line.length - 1))
+      offset += line.length
+    end
+    charmap
+  end
+end

data/lib/facet/string/line_wrap.rb

@@ -0,0 +1,20 @@
+class String
+  # Line wrap at width.
+  #
+  #   require 'facet/string/line_wrap'
+  #
+  #   puts "Here and there".line_wrap(5)
+  #
+  # _produces_
+  #
+  #   Here 
+  #   and t
+  #   here
+  #
+  def line_wrap(width)
+    s = gsub(/\t/,' '*4) # tabs default to 4 spaces.
+    s = s.gsub(/\n/,' ')
+    r = s.scan( /.{1,#{width}}/ )
+    r.join("\n") << "\n"
+  end
+end

data/lib/facet/string/margin.rb

@@ -0,0 +1,27 @@
+class String
+  # Provides a margin controlled string.
+  #
+  #   require 'facet/string/margin'
+  #
+  #   x = %Q{
+  #         | This
+  #         |   is
+  #         |     margin controlled!
+  #         }.margin
+  #
+  #--
+  # This may still need a bit of tweaking.
+  #++
+  def margin(n=0,d='|')
+    if n == 0
+      gsub(/\n\s*\Z/,'').gsub(/^\s*[#{d}]/, '')
+    else
+      gsub(/\n\s*\Z/,'').gsub(/^\s*[#{d}]/, ' ' * n)
+    end
+  end
+  
+  # Same as #margin, but the parameters are in reverse order.
+  def trim(d='|',n=0)
+    margin(n,d)
+  end
+end

data/lib/facet/string/mscan.rb

@@ -0,0 +1,16 @@
+class String
+  # Like #scan but returns MatchData ($~) rather
+  # then matched string ($&).
+  #
+  #   require 'facet/string/mscan'
+  #
+  def mscan(re) #:yield:
+    if block_given?
+      scan(re) { yield($~) }
+    else
+      m = []
+      scan(re) { m << $~ }
+      m
+    end
+  end
+end

data/lib/facet/string/natcmp.rb

@@ -0,0 +1,84 @@
+#--
+# Adapted from:
+# 
+#   http://sourcefrog.net/projects/natsort/natcmp.rb
+#
+# Based on Martin Pool's "Natural Order String Comparison" originally 
+# written in C. (see http://sourcefrog.net/projects/natsort/)
+#
+# This implementation is Copyright (C) 2003 by Alan Davies
+# <cs96and_AT_yahoo_DOT_co_DOT_uk>
+#
+# This software is provided 'as-is', without any express or implied
+# warranty.  In no event will the authors be held liable for any damages
+# arising from the use of this software.
+#
+# Permission is granted to anyone to use this software for any purpose,
+# including commercial applications, and to alter it and redistribute it
+# freely, subject to the following restrictions:
+#
+# 1. The origin of this software must not be misrepresented; you must not
+#    claim that you wrote the original software. If you use this software
+#    in a product, an acknowledgment in the product documentation would be
+#    appreciated but is not required.
+# 2. Altered source versions must be plainly marked as such, and must not be
+#    misrepresented as being the original software.
+# 3. This notice may not be removed or altered from any source distribution.
+#
+#++
+class String
+
+  # 'Natural order' comparison of two strings, e.g.
+  #
+  #   "my_prog_v1.1.0" < "my_prog_v1.2.0" < "my_prog_v1.10.0"
+  #
+  # which does not follow alphabetically. A secondary
+  # parameter, if set to _true_, makes the comparison
+  # case insensitive.
+  #
+  #   require 'facet/string/natcmp'
+  #   
+  #   "Hello.10".natcmp("Hello.1")  #=> -1
+  #
+  def natcmp(str2, caseInsensitive=false)
+    str1 = self.dup
+    str2 = str2.dup
+    compareExpression = /^(\D*)(\d*)(.*)$/
+  
+    if caseInsensitive
+      str1.downcase!
+      str2.downcase!
+    end
+  
+    # Remove all whitespace
+    str1.gsub!(/\s*/, '')
+    str2.gsub!(/\s*/, '')
+  
+    while (str1.length > 0) or (str2.length > 0) do
+      # Extract non-digits, digits and rest of string
+      str1 =~ compareExpression
+      chars1, num1, str1 = $1.dup, $2.dup, $3.dup
+      str2 =~ compareExpression
+      chars2, num2, str2 = $1.dup, $2.dup, $3.dup
+      # Compare the non-digits
+      case (chars1 <=> chars2)
+        when 0 # Non-digits are the same, compare the digits...
+          # If either number begins with a zero, then compare alphabetically,
+          # otherwise compare numerically
+          if (num1[0] != 48) and (num2[0] != 48)
+            num1, num2 = num1.to_i, num2.to_i
+          end
+          case (num1 <=> num2)
+            when -1 then return -1
+            when 1 then return 1
+          end
+        when -1 then return -1
+        when 1 then return 1
+      end # case
+    end # while
+  
+    # Strings are naturally equal
+    return 0
+  end
+  
+end # class String 

data/lib/facet/string/rand_letter.rb

@@ -0,0 +1,13 @@
+class String
+  # Generate a random letter.
+  #
+  #   require 'facet/string/rand_letter'
+  #
+  #   String.rand_letter  #=> "q"
+  #   String.rand_letter  #=> "r"
+  #   String.rand_letter  #=> "a"
+  #
+  def String.rand_letter
+    (rand(26) + (rand(2) == 0 ? 65 : 97) ).chr
+  end
+end

data/lib/facet/string/range.rb

@@ -0,0 +1,39 @@
+class String
+  
+  # Like #index but returns a Range.
+  #
+  #   require 'facet/string/range'
+  #
+  #   "This is a test!".rand('test')  #=> 10..13
+  #
+  def range(s, offset=0)
+    if self.index(s, offset)
+      return ($~.begin(0))..($~.end(0)-1)
+    end
+    nil
+  end
+  
+  # Like #index_all but returns an array of Ranges.
+  #
+  #   require 'facet/string/range'
+  #
+  #   "abc123abc123".range_all('abc')  #=> [0..2, 6..8]
+  #
+  #--
+  # Note: should add offset ?
+  #++
+  def range_all(s, reuse=false)
+    r = []; i = 0
+    while i < self.length
+      rng = range(s, i)
+      if rng
+        r << rng
+        i += reuse ? 1 : rng.end + 1
+      else
+        break
+      end
+    end
+    r.uniq
+  end
+  
+end

data/lib/facet/string/shatter.rb

@@ -0,0 +1,17 @@
+class String
+  # Breaks a string up into an array based on a regular expression.
+  # Similar to scan, but includes the matches.
+  #
+  #   require 'facet/string/shatter'
+  #
+  #   s = "<p>This<b>is</b>a test.</p>"
+  #   s.shatter( // )
+  #
+  # _produces_
+  #
+  #   ["", "<p>", "This", "<b>", "is", "</b>", "a test.", "</p>"]
+  #
+  def shatter( re )
+    self.gsub( re, "\1"+'\&'+"\1" ).split("\1")
+  end 
+end

data/lib/facet/string/shuffle.rb

@@ -0,0 +1,49 @@
+class String
+
+  # Return the string with characters arranged in random order.
+  #
+  #   require 'facet/string/pick'
+  #
+  #   "Ruby rules".shuffle_chars  #=> "e lybRsuur"
+  #
+  def shuffle(separator=$/)
+    split(separator).shuffle.join('')
+  end
+
+  # Destructive shuffle_chars.  Arrange the characters of the
+  # string in a new random order.
+  #
+  #   require 'facet/string/pick'
+  #
+  #   s = "Ruby rules".shuffle_chars
+  #   s.shuffle_chars!
+  #   s    #=> "e lybRsuur"
+  #
+  def shuffle!(separator=$/)
+    self.replace( shuffle(separator) )
+  end
+  
+  # Return the string with characters arranged in random order.
+  #
+  #   require 'facet/string/pick'
+  #
+  #   "Ruby rules".shuffle_chars  #=> "e lybRsuur"
+  #
+  def shuffle_chars
+    split(//).shuffle.join('')
+  end
+
+  # Destructive shuffle_chars.  Arrange the characters of the
+  # string in a new random order.
+  #
+  #   require 'facet/string/pick'
+  #
+  #   s = "Ruby rules".shuffle_chars
+  #   s.shuffle_chars!
+  #   s    #=> "e lybRsuur"
+  #
+  def shuffle_chars!
+    self.replace( shuffle_chars )
+  end
+  
+end

data/lib/facet/string/succ.rb

@@ -0,0 +1,17 @@
+class String
+  alias_method( :succ_once, :succ )
+  
+  # Allows #succ to take _n_ step increments.
+  #
+  #   require 'facet/string/succ'
+  #
+  #   "abc".succ      #=> "abd"
+  #   "abc".succ(4)   #=> "abg"
+  #   "abc".succ(24)  #=> "aca"
+  #
+  def succ(n=1)
+    s = self
+    n.times { s = s.succ_once }
+    s
+  end
+end

data/lib/facet/string/tab.rb

@@ -0,0 +1,38 @@
+class String
+
+  # Indent left or right by n spaces.
+  # (This used to be called #tab and aliased as #indent.)
+  #
+  #   require 'facet/string/tab'
+  #
+  def indent(n)  
+    if n >= 0
+      gsub(/^/, ' ' * n)
+    else
+      gsub(/^ {0,#{-n}}/, "")
+    end
+  end
+  
+  # Aligns each line n spaces
+  # this used to be #taballto.
+  #
+  #   require 'facet/string/tab'
+  #
+  def tab(n)
+    gsub(/^ */, ' ' * n)
+  end
+
+  # Preserves relative tabbing.
+  # The first non-empty line ends up with n spaces before nonspace.
+  #
+  #   require 'facet/string/tab'
+  #
+  def tabto(n)
+    if self =~ /^( *)\S/
+      indent(n - $1.length)
+    else
+      self
+    end
+  end
+  
+end

data/lib/facet/string/to_b.rb

@@ -0,0 +1,27 @@
+class String
+  # Interpret common affirmative string meanings as true,
+  # otherwise false. Balnk sapce and case are ignored.
+  # The following strings that will return true:
+  #
+  #   <tt>true</tt>,<tt>yes</tt>,<tt>on</tt>,<tt>t</tt>,<tt>1</tt>,<tt>y</tt>,<tt>==</tt>
+  #
+  # Examples:
+  #
+  #   require 'facet/string/to_b'
+  #
+  #   "true".to_b   #=> true
+  #   "yes".to_b    #=> true
+  #   "no".to_b     #=> false
+  #   "123".to_b    #=> false
+  #
+  def to_b
+    case self.downcase.strip
+    when 'true', 'yes', 'on', 't', '1', 'y', '=='
+      return true
+    when 'nil', 'null'
+      return nil
+    else
+      return false
+    end
+  end
+end