facets 2.9.1 → 2.9.2

data/src/core/facets/string/quote.rb

@@ -0,0 +1,93 @@
+class String
+
+  # Return a new string embraced by given +type+ and +count+
+  # of quotes. The arguments can be given in any order.
+  #
+  # If no type is given, double quotes are assumed.
+  #
+  #   "quote me".quote     #=> '"quote me"'
+  #
+  # If no type but a count is given then :mixed is assumed.
+  #
+  #   "quote me".quote(1)  #=> %q{'quote me'}
+  #   "quote me".quote(2)  #=> %q{"quote me"}
+  #   "quote me".quote(3)  #=> %q{'"quote me"'}
+  #
+  # Symbols can be used to describe the type.
+  #
+  #   "quote me".quote(:single)    #=> %q{'quote me'}
+  #   "quote me".quote(:double)    #=> %q{"quote me"}
+  #   "quote me".quote(:back)      #=> %q{`quote me`}
+  #   "quote me".quote(:bracket)   #=> %q{`quote me'}
+  #
+  # Or the character itself.
+  #
+  #   "quote me".quote("'")     #=> %q{'quote me'}
+  #   "quote me".quote('"')     #=> %q{"quote me"}
+  #   "quote me".quote("`")     #=> %q{`quote me`}
+  #   "quote me".quote("`'")    #=> %q{`quote me'}
+  #
+  # CREDIT: Trans
+
+  def quote(type=:double, count=nil)
+    if Integer === type
+      tmp   = count
+      count = type
+      type  = tmp || :mixed
+    else
+      count ||= 1
+    end
+
+    type = type.to_s unless Integer===type
+
+    case type
+    when "'", 'single', 's', 1
+      f = "'" * count
+      b = f
+    when '"', 'double', 'd', 2
+      f = '"' * count
+      b = f
+    when '`', 'back', 'b', -1
+      f = '`' * count
+      b = f
+    when "`'", 'bracket', 'sb'
+      f = "`" * count
+      b = "'" * count
+    when "'\"", 'mixed', "m", Integer
+      c = (count.to_f / 2).to_i
+      f = '"' * c
+      b = f
+      if count % 2 != 0
+        f = "'" + f
+        b = b + "'"
+      end
+    else
+      raise ArgumentError, "unrecognized quote type -- #{type}"
+    end
+    "#{f}#{self}#{b}"
+  end
+
+  # Remove quotes from string.
+  #
+  #   "'hi'".unquote    #=> "hi"
+  #
+  # CREDIT: Trans
+
+  def unquote
+    s = self.dup
+
+    case self[0,1]
+    when "'", '"', '`'
+      s[0] = ''
+    end
+
+    case self[-1,1]
+    when "'", '"', '`'
+      s[-1] = ''
+    end
+
+    return s
+  end
+
+end
+

data/src/core/facets/string/random_binary.rb

@@ -0,0 +1,10 @@
+class String
+
+  # Generate a random binary string of +n_bytes+ size.
+  #
+  # CREDIT: Guido De Rosa
+  def self.random_binary(n_bytes)
+    ( Array.new(n_bytes){ rand(0x100) } ).pack('c*') 
+  end
+
+end

data/src/core/facets/string/range.rb

@@ -0,0 +1,60 @@
+class String
+
+  # Like #index but returns a Range.
+  #
+  #   "This is a test!".range('test')  #=> (10..13)
+  #
+  # CREDIT: Trans
+
+  def range(pattern, offset=0)
+    unless Regexp === pattern
+      pattern = Regexp.new(Regexp.escape(pattern.to_s))
+    end
+    string = self[offset..-1]
+    if md = pattern.match(string)
+      return (md.begin(0)+offset)..(md.end(0)+offset-1)
+    end
+    nil
+  end
+
+  # Like #index_all but returns an array of Ranges.
+  #
+  #   "abc123abc123".range_all('abc')  #=> [0..2, 6..8]
+  #
+  # TODO: Add offset ?
+  #
+  # CREDIT: Trans
+
+  def range_all(pattern, reuse=false)
+    r = []; i = 0
+    while i < self.length
+      rng = range(pattern, i)
+      if rng
+        r << rng
+        i += reuse ? 1 : rng.end + 1
+      else
+        break
+      end
+    end
+    r.uniq
+  end
+
+  # 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]
+  #
+  # CREDIT: Trans
+
+  def range_of_line
+    offset=0; charmap = []
+    each_line do |line|
+      charmap << (offset..(offset + line.length - 1))
+      offset += line.length
+    end
+    charmap
+  end
+
+end
+

data/src/core/facets/string/range_all.rb

@@ -0,0 +1 @@
+require 'facets/string/range'

data/src/core/facets/string/range_of_line.rb

@@ -0,0 +1 @@
+require 'facets/string/range'

data/src/core/facets/string/rewrite.rb

@@ -0,0 +1,24 @@
+class String
+
+  # Apply a set of rules in the form of regular expression matches
+  # to the string.
+  #
+  # * rules - The array containing rule-pairs (match, write).
+  #
+  # Keep in mind that the order of rules is significant.
+  #
+  # Returns the rewritten String.
+  #
+  # CREDIT: George Moschovitis
+
+  def rewrite(rules)
+    raise ArgumentError.new('The rules parameter is nil') unless rules
+    rewritten_string = dup
+    rules.each do |(match,write)|
+      rewritten_string.gsub!(match,write)
+    end
+    return rewritten_string
+  end
+
+end
+

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

@@ -0,0 +1,22 @@
+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>"]
+  #
+  # CREDIT: Trans
+
+  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/src/core/facets/string/similarity.rb

@@ -0,0 +1,89 @@
+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".similarity("Aleksander")  #=> 0.9
+  #
+  # The way it works:
+  #
+  # 1. Converts each string into a "graph like" object, with edges ...
+  #
+  #     "alexsander" -> [ alexsander, alexsand, alexsan ... lexsand ... san ... an, etc ]
+  #     "aleksander" -> [ aleksander, aleksand ... etc. ]
+  #
+  # 2. 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 ]
+  #
+  # 3. 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.
+  #
+  # Still a bit rough. Any suggestions for improvement are welcome.
+  #
+  # CREDIT: Derek Lewis.
+  def similarity(str_in)
+    return 0 if str_in == nil
+    return 1 if self == str_in
+
+    # -- make a graph of each word (okay, 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{ |aa| matches.push(aa) if( graph_B.include?(aa) ) }
+    #++
+
+    # -- 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( Regexp.escape(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
+
+end
+

data/src/core/facets/string/snakecase.rb

@@ -0,0 +1,21 @@
+class String
+
+  # The reverse of +camelcase+. Makes an underscored of a camelcase string.
+  #
+  # Changes '::' to '/' to convert namespaces to paths.
+  #
+  # Examples
+  #   "SnakeCase".snakecase           #=> "snake_case"
+  #   "Snake-Case".snakecase          #=> "snake_case"
+  #   "SnakeCase::Errors".snakecase   #=> "snake_case/errors"
+  #
+  def snakecase
+    gsub(/::/, '/').  # NOT SO SURE ABOUT THIS
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+
+end
+

data/src/core/facets/string/splice.rb

@@ -0,0 +1,33 @@
+require 'facets/string/store'
+
+class String
+
+  # String#slice is essentially the same as #store.
+  #
+  #   a = "HELLO"
+  #   a.splice(1, "X")
+  #   a                #=> "HXLLO"
+  #
+  # But it acts like #slice! when given a single argument.
+  #
+  #   a = "HELLO"
+  #   a.splice(1)    #=> "E"
+  #   a              #=> "HLLO"
+  #
+  # CREDIT: Trans
+
+  def splice(idx, sub=nil)
+    if sub
+      store(idx, sub)
+    else
+      case idx
+      when Range
+        slice!(idx)
+      else
+        slice!(idx,1)
+      end
+    end
+  end
+
+end
+

data/src/core/facets/string/squish.rb

@@ -0,0 +1,22 @@
+class String
+  # Returns the string, first removing all whitespace on both ends of
+  # the string, and then changing remaining consecutive whitespace
+  # groups into one space each.
+  #
+  #   %{ Multi-line
+  #      string }.squish                   # => "Multi-line string"
+  #
+  #   " foo   bar    \n   \t   boo".squish # => "foo bar boo"
+  #
+  def squish
+    dup.squish!
+  end
+
+  # Performs a destructive squish. See String#squish.
+  def squish!
+    strip!
+    gsub!(/\s+/, ' ')
+    self
+  end
+end
+

data/src/core/facets/string/start_with.rb

@@ -0,0 +1,60 @@
+#--
+# = Developer's Notes
+#
+# Old definition of start_with? written by Lucas Carlson
+# and Blaine Cook was ...
+#
+#   index(prefix) == 0
+# 
+# I like the simplicity of this definition, but I could not
+# find a way define #end_with? in similar terms and still
+# accept regular expressions for the suffix. So I had to use
+# Regexp match. On th upside, we can get MatchData
+# which might be more useful.
+#++
+
+class String
+
+  #unless method_defined?(:start_with?) # 1.8.7+
+
+    # Does a string start with the given prefix?
+    #
+    #   "hello".start_with?("he")    #=> true
+    #   "hello".start_with?("to")    #=> false
+    #
+    # Note: This definition is better than standard Ruby's
+    # becuase it handles regular expressions.
+    #
+    # CREDIT: Juris Galang
+
+    def start_with?(prefix)
+      prefix = Regexp.escape(prefix.to_s) unless Regexp===prefix
+      /^#{prefix}/.match(self) ? true : false
+    end
+
+  #end
+
+  #unless method_defined?(:end_with?) # 1.8.7+
+
+    # Does a string end with the given suffix?
+    #
+    #   "hello".end_with?("lo")    #=> true
+    #   "hello".end_with?("to")    #=> false
+    #
+    # Note: This definition is better than standard Ruby's
+    # becuase it handles regular expressions.
+    #
+    # CREDIT: Juris Galang
+
+    def end_with?(suffix)
+      suffix = Regexp.escape(suffix.to_s) unless Regexp===suffix
+      /#{suffix}$/.match(self) ? true : false
+    end
+
+  #end
+
+  alias_method :starts_with?, :start_with?
+  alias_method :ends_with?  , :end_with?
+
+end
+