facets 1.1.0 → 1.2.0

data/lib/facet/string/self/rand_letter.rb

@@ -1,34 +1 @@
-class String
-
-  # Module method to generate a random letter.
-  #
-  #   String::Random.rand_letter  #=> "q"
-  #   String::Random.rand_letter  #=> "r"
-  #   String::Random.rand_letter  #=> "a"
-  #
-  def self.rand_letter
-    (rand(26) + (rand(2) == 0 ? 65 : 97) ).chr
-  end
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TC01 < Test::Unit::TestCase
-
-    def test_String_rand_letter
-      100.times { |i| assert( /[a-zA-z]/ =~ String.rand_letter ) }
-    end
-
-  end
-
-=end
+require 'facets/core/string/self/rand_letter.rb'

data/lib/facet/string/self/random.rb

@@ -1,37 +1 @@
-#
-# Returns a randomly generated string. One possible use is
-# password initialization. Takes a max legnth of characters
-# (default 8) and an optional valid char Regexp (default /\w\d/).
-#
-#--
-#
-# CREDIT goes to George Moschovitis.
-#
-# NOTE This is not very efficient. Better way?
-#
-#++
-
-def String.random(max_length = 8, char_re = /[\w\d]/)
-  # gmosx: this is a nice example of input parameter checking.
-  # this is NOT a real time called method so we can add this
-  # check. Congrats to the author.
-  raise ArgumentError.new('char_re must be a regular expression!') unless char_re.is_a?(Regexp)
-
-  string = ""
-
-  while string.length < max_length
-      ch = rand(255).chr
-      string << ch if ch =~ char_re
-  end
-
-  return string
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-# TODO
+require 'facets/core/string/self/random.rb'

data/lib/facet/string/shatter.rb

@@ -1,45 +1 @@
-
-class String
-
-  # Breaks a string up into an array based on a regular expression.
-  # Similar to scan, but includes the matches.
-  #
-  #   s = "<p>This<b>is</b>a test.</p>"
-  #   s.shatter( /\<.*?\>/ )
-  #
-  # _produces_
-  #
-  #   ["<p>", "This", "<b>", "is", "</b>", "a test.", "</p>"]
-  #
-  def shatter( re )
-    r = self.gsub( re ){ |s| "\1" + s + "\1" }
-    while r[0,1] == "\1" ; r[0] = '' ; end
-    while r[-1,1] == "\1" ; r[-1] = '' ; end
-    r.split("\1")
-  end
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCString < Test::Unit::TestCase
-
-    def test_shatter
-      s = "<p>This<b>is</b>a test.</p>"
-      sh = s.shatter( /<.*?>/ )
-      e = ["<p>", "This", "<b>", "is", "</b>", "a test.", "</p>"]
-      assert_equal(e, sh)
-    end
-
-  end
-
-=end
+require 'facets/core/string/shatter.rb'

data/lib/facet/string/shell_escape.rb

@@ -0,0 +1 @@
+require 'facets/core/string/shell_escape.rb'

data/lib/facet/string/shift.rb

@@ -1,42 +1 @@
-class String
-  def shift
-    return '' if size == 0
-    self[0] = ''
-    self
-  end
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCString < Test::Unit::TestCase
-
-    def setup
-      @a =  "012345"
-    end
-
-    def test_001
-      assert_raises( ArgumentError ) { @a.shift(1) }
-    end
-
-    def test_002
-      assert_equal( "12345", @a.shift )
-      assert_equal( "2345", @a.shift )
-      assert_equal( "345", @a.shift )
-      assert_equal( "45", @a.shift )
-      assert_equal( "5", @a.shift )
-      assert_equal( "", @a.shift )
-      assert_equal( "", @a.shift )
-    end
-
-  end
-
-=end
+require 'facets/core/string/shift.rb'

data/lib/facet/string/shuffle.rb

@@ -1,42 +1 @@
-require 'facet/array/shuffle'
-
-class String
-
-  # Return the string with seperated sections arranged
-  # in a random order. The default seperation is by character.
-  #
-  #   "Ruby rules".shuffle  #=> "e lybRsuur"
-  #
-  def shuffle(separator=//)
-    split(separator).shuffle.join('')
-  end
-
-  # In place version of shuffle.
-  #
-  def shuffle!(separator=//)
-    self.replace( shuffle(separator) )
-  end
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCString < Test::Unit::TestCase
-
-    def test_shuffle
-      assert_nothing_raised { "abc 123".shuffle }
-      #assert_nothing_raised { "abc 123".shuffle! }
-    end
-
-  end
-
-=end
+require 'facets/core/string/shuffle.rb'

data/lib/facet/string/similarity.rb

@@ -1,108 +1 @@
-
-class String
-
-  # A fuzzy matching mechanism. Returns a score from 0-1,
-  # based on the number of shared edges.
-  # To be effective, the strings must be of length 2 or greater.
-  #
-  #   "Alexsander".fuzzy_match( "Aleksander" )  #=> 0.9
-  #
-  # The way it works:
-  #
-  # * Converts each string into a "graph like" object, with edges
-  #     "alexsander" -> [ alexsander, alexsand, alexsan ... lexsand ... san ... an, etc ]
-  #     "aleksander" -> [ aleksander, aleksand ... etc. ]
-  # * Perform match, then remove any subsets from this matched set (i.e. a hit
-  #   on "san" is a subset of a hit on "sander")
-  #     Above example, once reduced -> [ ale, sander ]
-  # * See's how many of the matches remain, and calculates a score based
-  #   on how many matches, their length, and compare to the length of the
-  #   larger of the two words.
-  #--
-  # Credit goes to Derek Lewis. Thanks Derek!
-  # Still a bit rough. Any suggestions for improvement are welcome.
-  #++
-  def similarity( str_in )
-    return 0 if str_in == nil
-    return 1 if self == str_in
-
-    # Make a graph of each word (okay, so its not a true graph, but is similar)
-    graph_A = Array.new
-    graph_B = Array.new
-
-    # "graph" self
-    last = self.length
-    (0..last).each do |ff|
-      loc  = self.length
-      break if ff == last - 1
-      wordB = (1..(last-1)).to_a.reverse!
-      if (wordB != nil)
-        wordB.each do |ss|
-          break if ss == ff
-          graph_A.push( "#{self[ff..ss]}" )
-        end
-      end
-    end
-
-    # "graph" input string
-    last = str_in.length
-    (0..last).each{ |ff|
-      loc  = str_in.length
-      break if ff == last - 1
-      wordB = (1..(last-1)).to_a.reverse!
-      wordB.each do |ss|
-        break if ss == ff
-        graph_B.push( "#{str_in[ff..ss]}" )
-      end
-    }
-
-
-    # count how many of these "graph edges" we have that are the same
-    matches = graph_A & graph_B
-    #matches = Array.new
-    #graph_A.each do |aa|
-    #  matches.push( aa ) if( graph_B.include?( aa ) )
-    #end
-
-    # For eliminating subsets, we want to start with the smallest hits.
-    matches.sort!{|x,y| x.length <=> y.length}
-
-    # eliminate any subsets
-    mclone = matches.dup
-    mclone.each_index do |ii|
-      reg = Regexp.compile( mclone[ii] )
-      count = 0.0
-      matches.each{|xx| count += 1 if xx =~ reg}
-      matches.delete(mclone[ii]) if count > 1
-    end
-
-    score = 0.0
-    matches.each{ |mm| score += mm.length }
-    self.length > str_in.length ? largest = self.length : largest = str_in.length
-    return score/largest
-  end
-
-  alias_method :fuzzy_match, :similarity
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCString < Test::Unit::TestCase
-
-    def test_similarity
-      assert_nothing_raised { "Hello World!".similarity( "helo wrld" ) }
-    end
-
-  end
-
-=end
+require 'facets/core/string/similarity.rb'

data/lib/facet/string/singular.rb

@@ -1,117 +1 @@
-
-class String
-
-  SINGULAR_RULES = [
-    [/(matr)ices$/i, '\1ix'],
-    [/(vert)ices$/i, '\1ex'],
-    [/^(ox)en/i, '\1'],
-    [/(alias)es$/i, '\1'],
-    [/([octop|vir])i$/i, '\1us'],
-    [/(cris|ax|test)es$/i, '\1is'],
-    [/(shoe)s$/i, '\1'],
-    [/(o)es$/i, '\1'],
-    [/(bus)es$/i, '\1'],
-    [/([m|l])ice$/i, '\1ouse'],
-    [/(x|ch|ss|sh)es$/i, '\1'],
-    [/(m)ovies$/i, '\1\2ovie'],
-    [/(s)eries$/i, '\1\2eries'],
-    [/([^aeiouy]|qu)ies$/i, '\1y'],
-    [/([lr])ves$/i, '\1f'],
-    [/(tive)s$/i, '\1'],
-    [/(hive)s$/i, '\1'],
-    [/([^f])ves$/i, '\1fe'],
-    [/(^analy)ses$/i, '\1sis'],
-    [/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis'],
-    [/([ti])a$/i, '\1um'],
-    [/(p)eople$/i, '\1\2erson'],
-    [/(m)en$/i, '\1an'],
-    [/(s)tatus$/i, '\1\2tatus'],
-    [/(c)hildren$/i, '\1\2hild'],
-    [/(n)ews$/i, '\1\2ews'],
-    [/s$/i, '']
-  ]
-
-  PLURAL_RULES = [
-    [/^(ox)$/i, '\1\2en'],                 # ox
-    [/([m|l])ouse$/i, '\1ice'],            # mouse, louse
-    [/(matr|vert)ix|ex$/i, '\1ices'],      # matrix, vertex, index
-    [/(x|ch|ss|sh)$/i, '\1es'],            # search, switch, fix, box, process, address
-    [/([^aeiouy]|qu)ies$/i, '\1y'],
-    [/([^aeiouy]|qu)y$/i, '\1ies'],        # query, ability, agency
-    [/(hive)$/i, '\1s'],                   # archive, hive
-    [/(?:([^f])fe|([lr])f)$/i, '\1\2ves'], # half, safe, wife
-    [/sis$/i, 'ses'],                      # basis, diagnosis
-    [/([ti])um$/i, '\1a'],                 # datum, medium
-    [/(p)erson$/i, '\1eople'],             # person, salesperson
-    [/(m)an$/i, '\1en'],                   # man, woman, spokesman
-    [/(c)hild$/i, '\1hildren'],            # child
-    [/(buffal|tomat|potat)o$/i, '\1\2oes'],      # buffalo, tomato
-    [/(bu)s$/i, '\1\2ses'],                # bus
-    [/(alias)/i, '\1es'],                  # alias
-    [/(octop|vir)us$/i, '\1i'],            # octopus, virus - virus has no defined plural, but viri is better than viruses/viruss
-    [/(ax|cri|test)is$/i, '\1es'],         # axis, crisis  
-    [/s$/i, 's'],                          # no change (compatibility)
-    [/$/, 's']
-  ]
-
-
-  # Convert an English word from plurel to singular.
-  #
-  #   "boys".singular      #=> boy
-  #   "tomatoes".singular  #=> tomato
-  #
-  def singular
-    result = self.to_s.dup
-    String::SINGULAR_RULES.each do |(rule, replacement)|
-      break if result.gsub!(rule, replacement)
-    end
-    return result
-  end
-
-  # Convert an English word from singular to plurel.
-  #
-  #   "boy".plural     #=> boys
-  #   "tomato".plural  #=> tomatoes
-  #
-  def plural
-    result = self.to_s.dup
-    String::PLURAL_RULES.each do |(rule, replacement)|
-      break if result.gsub!(rule, replacement)
-    end
-    return result
-  end
-
-  # Deprecated alias for #singular.
-  alias_method( :singularize, :singular )
-
-  # Deprecated alias for #plural.
-  alias_method( :pluralize, :plural )
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCString < Test::Unit::TestCase
-
-    def test_singular
-      assert_equal( "friend", "friends".singular )
-      assert_equal( "man", "men".singular )    
-    end
-
-    def test_plural
-      assert_equal( "friends", "friend".plural )
-      assert_equal( "men", "man".plural )
-    end
-
-  end
-
-=end
+require 'facets/core/string/singular.rb'

data/lib/facet/string/slap.rb

@@ -1,44 +1 @@
-
-class String
-
-  # Like push but works from the other end of the string.
-  def slap( str=' ' )
-    insert(0, str)
-  end
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCString < Test::Unit::TestCase
-
-    def setup
-      @a =  ""
-    end
-
-    def test_001
-      #assert_raises( ArgumentError ) { @a.slap }
-      assert_raises( ArgumentError ) { @a.slap(1,2) }
-    end
-
-    def test_002
-      assert_equal( "0", @a.slap("0") )
-      assert_equal( "10", @a.slap("1") )
-      assert_equal( "210", @a.slap("2") )
-      assert_equal( "3210", @a.slap("3") )
-      assert_equal( "43210", @a.slap("4") )
-      assert_equal( "543210", @a.slap("5") )
-    end
-
-  end
-
-=end
+require 'facets/core/string/slap.rb'