nano 0.8.1

data/lib/nano/string/rand_byte%21.rb

@@ -0,0 +1,17 @@
+
+class String
+
+  # Destructive rand_byte. Delete a random byte of _self_ and return it.
+  #
+  #   s = "Ruby rules"
+  #   s.rand_byte!      #=> 121
+  #   s                 #=> "Rub rules"
+  #
+  def rand_byte!
+    i = rand( size )
+    rv = self[i,1]
+    self[i,1] = ''
+    rv
+  end
+
+end

data/lib/nano/string/rand_byte.rb

@@ -0,0 +1,12 @@
+
+class String
+
+  # Return a random byte of _self_.
+  #
+  #   "Ruby rules".rand_byte  #=> 121
+  #
+  def rand_byte
+    self[rand( size )]
+  end
+
+end

data/lib/nano/string/rand_index.rb

@@ -0,0 +1,9 @@
+class String
+  # Return a random string index.
+  #
+  #   "Ruby rules".rand_index  #=> 3
+  #
+  def rand_index
+    rand( size )
+  end
+end

data/lib/nano/string/range.rb

@@ -0,0 +1,15 @@
+
+class String
+
+  # Like #index but returns a Range.
+  #
+  #   "This is a test!".range('test')  #=> 10..13
+  #
+  def range(s, offset=0)
+    if self.index(s, offset)
+      return ($~.begin(0))..($~.end(0)-1)
+    end
+    nil
+  end
+
+end

data/lib/nano/string/range_all.rb

@@ -0,0 +1,26 @@
+require 'nano/string/range'
+
+class String
+
+  # Like #index_all but returns an array of Ranges.
+  #
+  #   "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/nano/string/range_of_line.rb

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

data/lib/nano/string/shatter.rb

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

data/lib/nano/string/shift.rb

@@ -0,0 +1,7 @@
+class String
+  def shift
+    return '' if size == 0
+    self[0] = ''
+    self
+  end
+end

data/lib/nano/string/shuffle.rb

@@ -0,0 +1,20 @@
+require 'nano/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

data/lib/nano/string/similarity.rb

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

data/lib/nano/string/singular.rb

@@ -0,0 +1,51 @@
+require 'nano/string/plural'
+
+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, '']
+  ]
+
+  # 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
+
+  # Deprecated alias for #singular.
+  alias_method( :singularize, :singular )
+
+end

data/lib/nano/string/slap.rb

@@ -0,0 +1,9 @@
+class String
+
+  # Like push but works from the other end of the string.
+  #
+  def slap( str=' ' )
+    insert(0, str)
+  end
+
+end

data/lib/nano/string/soundex.rb

@@ -0,0 +1,71 @@
+
+class String
+
+  # Implementation of the soundex algorithm as described by Knuth
+  # in volume 3 of The Art of Computer Programming. Returns nil
+  # if the value couldn't be calculated b/c of empty-string or
+  # invalid character.
+  #
+  #   "Ruby".soundex  #=> "R100"
+  #
+  #--
+  # Credit goes to Michael Neumann (neumann@s-direktnet.de).
+  #++
+  def soundex
+    return nil if self.empty?
+
+    str = self.upcase
+    last_code = String.soundex_code(str[0,1])
+    soundex_code = str[0,1]
+
+    for index in 1...(str.size) do
+      return soundex_code if soundex_code.size == 4
+
+      code = String.soundex_code(str[index,1])
+
+      if code == "0" then
+        last_code = nil
+      elsif code == nil then
+        return nil
+      elsif code != last_code then
+        soundex_code += code
+        last_code = code
+      end
+    end
+
+    return soundex_code + "000"[0,4-soundex_code.size]
+  end
+
+  # Support function for String#soundex. Returns code for a single character.
+  def String.soundex_code(character)
+    character.tr! "AEIOUYWHBPFVCSKGJQXZDTLMNR", "00000000111122222222334556"
+  end
+
+end
+
+
+=begin
+
+# --- test ----
+
+if __FILE__ == $0
+  testvec = "Euler Ellery Gauss Ghosh Hilbert Heilbronn Knuth Kant Lloyd Ladd Lukasiewicz Lissajous".split(" ")
+  resvec  = "E460 E460 G200 G200 H416 H416 K530 K530 L300 L300 L222 L222".split(" ")
+   
+  wrong = 0
+  
+  testvec.each_with_index {|str,i| 
+    res = str.soundex
+    print "#{str.ljust(11)} => #{res} ... "
+    if res == resvec[i] then
+      puts "ok"
+    else
+      wrong += 1
+      puts "failed, had to be #{resvec[i]}"
+    end    
+  }
+  puts "summary: #{wrong} of #{testvec.size} tests failed!"      
+  readline
+end
+
+=end

data/lib/nano/string/succ.rb

@@ -0,0 +1,14 @@
+class String
+  alias_method( :succ_once, :succ )
+  # Allows #succ to take _n_ step increments.
+  #
+  #   "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/nano/string/tab.rb

@@ -0,0 +1,13 @@
+require 'nano/string/indent'
+require 'nano/string/tabto'
+
+class String
+
+  # Aligns each line n spaces.
+  # (This used to be #taballto.)
+  #
+  def tab(n)
+    gsub(/^ */, ' ' * n)
+  end
+
+end

data/lib/nano/string/tabto.rb

@@ -0,0 +1,17 @@
+require 'nano/string/indent'
+require 'nano/string/tab'
+
+class String
+
+  # Preserves relative tabbing.
+  # The first non-empty line ends up with n spaces before nonspace.
+  #
+  def tabto(n)
+    if self =~ /^( *)\S/
+      indent(n - $1.length)
+    else
+      self
+    end
+  end
+
+end

data/lib/nano/string/to_a.rb

@@ -0,0 +1,13 @@
+
+require 'nano/string/to_arr'
+
+class String
+
+  # Alias for #to_arr. See #to_arr for documentation.
+  #
+  # WARNING! Use this method with caution as its default behavior
+  # (i.e. chars splitting) is nonconvential (unfortunately).
+  #
+  alias_method :to_a, :to_arr
+
+end

data/lib/nano/string/to_arr.rb

@@ -0,0 +1,34 @@
+
+class String
+
+  # Split a string into an array according to ath egiven mode.
+  # The mode is a recognized symbol or a regexp. If no mode is
+  # given the default mode :char (same as regular expression //)
+  # is used.
+  #
+  # Symbolized modes include :byte, :char, :word, :line and :enum.
+  #
+  # The :enum mode passes the call up to the Enumerable#to_a, thus
+  # providing a means to Ruby's current built-in behavior.
+  #
+  #   'abc 123'.to_arr        #=> ['a','b','c',' ','1','2','3']
+  #   'abc 123'.to_arr(:word) #=> ['abc','123']
+  #
+  def to_arr(mode=nil)
+    case mode
+    when nil, :char, :chars
+      split(//)
+    when :enum
+      super
+    when :byte, :bytes
+      unpack('C*')
+    when :word, :words
+      split(/[ ]+/)
+    when :line, :lines
+      split(/\n/)
+    else
+      split(mode)
+    end
+  end
+
+end