facets 1.1.0 → 1.2.0

data/lib/facets/core/string/self/rand_letter.rb

@@ -0,0 +1,34 @@
+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

data/lib/facets/core/string/self/random.rb

@@ -0,0 +1,37 @@
+#
+# 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

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

@@ -0,0 +1,45 @@
+
+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

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

@@ -0,0 +1,11 @@
+
+class String
+
+  # Escape special characters used in most
+  # unix shells to use it, eg. with system().
+
+  def shell_escape
+    self.gsub(/([\\\t\| &`<>)('"])/) { |s| '\\' << s }
+  end
+
+end

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

@@ -0,0 +1,42 @@
+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

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

@@ -0,0 +1,42 @@
+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

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

@@ -0,0 +1,108 @@
+
+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

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

@@ -0,0 +1,117 @@
+
+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

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

@@ -0,0 +1,44 @@
+
+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