# File lib/facets/core/string/bracket.rb, line 4
  def self.bra2ket
    @bra2ket ||= { '['=>']', '('=>')', '{'=>'}', '<'=>'>' }
  end

# File lib/facets/core/string/self/format.rb, line 2
def String.format(*args)
  Kernel.format(*args)
end

# File lib/facets/core/string/self/interpolate.rb, line 4
  def self.interpolate(&str)
    eval "%{#{str.call}}", str.binding
  end

# File lib/facets/core/string/self/patterns.rb, line 14
  def self.patterns( pattern )
    case pattern
    when :char, :chars, :character, :characters
      pattern = //
    when :word, :words
      pattern = /\s+|\Z/
    when :line, :lines
      pattern = /\Z/
    when String
      pattern = Regexp.new(Regexp.escape(pattern))
    end
    pattern
  end

# File lib/facets/core/string/self/rand_letter.rb, line 9
  def self.rand_letter
    (rand(26) + (rand(2) == 0 ? 65 : 97) ).chr
  end

# File lib/facets/core/string/self/random.rb, line 14
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

# File lib/facets/core/string/soundex.rb, line 40
  def String.soundex_code(character)
    character.tr! "AEIOUYWHBPFVCSKGJQXZDTLMNR", "00000000111122222222334556"
  end

# File lib/facets/core/string/self/format.rb, line 6
def String.sprintf(*args)
  Kernel.format(*args)
end

# File lib/facets/core/string/align_center.rb, line 47
  def align_center( n, sep="\n", c=' ' )
    return center(n.to_i,c.to_s) if sep==nil
    q = split(sep.to_s).collect { |line|
      line.center(n.to_i,c.to_s)
    }
    q.join(sep.to_s)
  end

# File lib/facets/core/string/align_center.rb, line 20
  def align_left( n, sep="\n", c=' ' )
    return ljust(n.to_i,c.to_s) if sep==nil
    q = split(sep.to_s).collect { |line|
      line.ljust(n.to_i,c.to_s)
    }
    q.join(sep.to_s)
  end

# File lib/facets/core/string/align_center.rb, line 8
  def align_right( n, sep="\n", c=' ' )
    return rjust(n.to_i,c.to_s) if sep==nil
    q = split(sep.to_s).collect { |line|
      line.rjust(n.to_i,c.to_s)
    }
    q.join(sep.to_s)
  end

# File lib/facets/core/string/at_rand.rb, line 13
  def at_rand( separator=// )
    separator = self.class.patterns( separator )
    self.split(separator,-1).at_rand
  end

# File lib/facets/core/string/at_rand.rb, line 25
  def at_rand!( separator=// )
    separator = self.class.patterns( separator )
    a = self.shatter( separator )
    w = []; a.each_with_index { |s,i| i % 2 == 0 ? w << s : w.last << s }
    i = rand( w.size )
    r = w.delete_at( i )
    self.replace( w.join('') )
    return r
  end

# File lib/facets/core/string/basename.rb, line 8
  def basename
    self.to_s.gsub(/^.*::/, '')
  end

# File lib/facets/core/string/blank.rb, line 9
  def blank?
    self !~ /\S/
  end

# File lib/facets/core/string/bracket.rb, line 15
  def bracket(bra, ket=nil)
    #ket = String.bra2ket[$&] if ! ket && /^[\[({<]$/ =~ bra
    ket = String.bra2ket[bra] unless ket
    "#{bra}#{self}#{ket ? ket : bra}"
  end

# File lib/facets/core/string/bracket.rb, line 22
  def bracket!(bra, ket=nil)
    self.replace( self.bracket(bra, ket) )
  end

# File lib/facets/core/string/brief.rb, line 10
  def brief(string, count = 128, force_cutoff = false, ellipsis="...")
    return nil unless string
    return nil if count < 2

    if string.size > count
      cut_at = force_cutoff ? count : (string.index(' ', count-1) || count)
      xstring = string.slice(0, cut_at)
      return xstring.chomp(" ") + ellipsis
    else
      return string
    end
  end

# File lib/facets/core/string/bytes.rb, line 6
  def bytes
    self.unpack('C*')
  end

# File lib/facets/core/string/camelcase.rb, line 16
  def camelcase( first=false, on='_\s' )
    if first
      gsub(/(^|[#{on}]+)([A-Za-z])/){ $2.upcase }
    else
      gsub(/([#{on}]+)([A-Za-z])/){ $2.upcase }
    end
  end

# File lib/facets/core/string/camelize.rb, line 9
  def camelize
    #to_s.gsub(/(^|_)(.)/){$2.upcase}
    to_s.gsub(/\/(.?)/){ "::" + $1.upcase }.gsub(/(^|_)(.)/){ $2.upcase }
  end

# File lib/facets/core/string/capitalized.rb, line 13
  def capitalized?
    self =~ /^[A-Z]/
  end

# File lib/facets/core/string/chars.rb, line 8
  def chars
    self.split(//)
  end

# File lib/facets/core/string/cmp.rb, line 12
  def cmp(other)
    return -1 if length < other.length
    return 1 if length > other.length
    self <=> other  # alphabetic compare
  end

# File lib/facets/core/string/dequote.rb, line 3
  def dequote
    s = self.dup

    case self[0,1]
    when "'", '"', '`'
      s[0] = ''
    end

    case self[-1,1]
    when "'", '"', '`'
      s[-1] = ''
    end

    s
  end

# File lib/facets/core/string/downcase.rb, line 12
  def downcase?
    downcase == self
  end

# File lib/facets/core/string/dresner.rb, line 12
  def dresner
    self.gsub(/\B\w+\B/){$&.split(//).sort_by{rand}} 
  end

# File lib/facets/core/string/dresner.rb, line 18
  def dresner!
    self.replace(dresner)
  end

# File lib/facets/core/string/each_char.rb, line 5
  def each_char  # :yield:
    split(//).each { |c|
      yield( c )
    }
  end

# File lib/facets/core/string/each_word.rb, line 8
  def each_word( &yld )
    rest_of_string = self
    wordfind = /([-'\w]+)/
    arity = yld.arity
    offset = 0
    while wmatch = wordfind.match(rest_of_string)
      word = wmatch[0]
      range = offset+wmatch.begin(0) ... offset+wmatch.end(0)
      rest_of_string = wmatch.post_match
      if arity == 1
        yld.call(word)
      else
        yld.call(word, range)
      end
      offset = self.length - rest_of_string.length
    end
  end

# File lib/facets/core/string/starts_with.rb, line 11
  def ends_with?(str)
    self.rindex( str ) == self.length - str.length
  end

# File lib/facets/core/enumerable/entropy.rb, line 27
  def entropy
    self.split(//).entropy
  end

# File lib/facets/core/string/first.rb, line 14
  def first(separator_pattern=//)
    pattern = self.class.patterns(separator_pattern)
    split(separator_pattern).at(0)
  end

# File lib/facets/core/string/first.rb, line 36
  def first!(separator_pattern=//)
    pattern = self.class.patterns(separator_pattern)
    a = shatter(pattern)
    r = a.first
    a.shift
    a.shift
    replace( a.join('') )
    return r
  end

# File lib/facets/core/string/first.rb, line 52
  def first=( x )
    insert(0, x.to_s)
  end

# File lib/facets/core/string/first_char.rb, line 8
  def first_char(n=1)
    slice(0, n.to_i)
  end

# File lib/facets/core/string/fold.rb, line 19
  def fold(ignore_indented=false)
    ns = ''
    i = 0
    br = self.scan(/(\n\s*\n|\Z)/m) do |m|
      b = $~.begin(1)
      e = $~.end(1)
      nl = $&
      tx = slice(i...b)
      if ignore_indented and slice(i...b) =~ /^[ ]+/
        ns << tx
      else
        ns << tx.gsub(/[ ]*\n+/,' ')
      end
      ns << nl
      i = e
    end
    ns
  end

# File lib/facets/core/string/format.rb, line 4
  def format( *args )
    self.%(args)
  end

# File lib/facets/core/string/frequency.rb, line 7
  def frequency(*args)
    to_arr(*args).frequency
  end

# File lib/facets/core/string/humanize.rb, line 6
  def humanize
    self.gsub(/_/, " ").capitalize
  end

# File lib/facets/core/string/indent.rb, line 25
  def indent(n)
    if n >= 0
      gsub(/^/, ' ' * n)
    else
      gsub(/^ {0,#{-n}}/, "")
    end
  end

# File lib/facets/core/string/index_all.rb, line 10
  def index_all(s, reuse=false)
    ia = []; i = 0
    while (i = self.index(s,i))
      ia << i
      i += (reuse ? 1 : $~.length)
    end
    ia
  end

# File lib/facets/core/string/last.rb, line 13
  def last(separator_pattern=//)
    pattern = self.class.patterns(separator_pattern)
    self.split(separator_pattern).at(-1)
  end

# File lib/facets/core/string/last.rb, line 43
  def last!(separator_pattern=//)
    pattern = self.class.patterns(separator_pattern)
    a = shatter(pattern)
    r = a.last
    a.pop
    a.pop
    replace( a.join('') )
    return r
  end

# File lib/facets/core/string/last.rb, line 22
  def last=(str)
    self << str
  end

# File lib/facets/core/string/last_char.rb, line 8
  def last_char(n=1)
    n = n.to_i
    return self if n > size
    slice(-n, n) #self[-n..-1]
  end

# File lib/facets/core/string/line_wrap.rb, line 13
  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

# File lib/facets/core/string/lines.rb, line 8
  def lines
    self.split(/\n/)
  end

# File lib/facets/core/string/margin.rb, line 15
  def margin(n=0)
    d = /\A.*\n\s*(.)/.match( self )[1]
    d = /\A\s*(.)/.match( self)[1] unless d
    return '' unless d
    if n == 0
      gsub(/\n\s*\Z/,'').gsub(/^\s*[#{d}]/, '')
    else
      gsub(/\n\s*\Z/,'').gsub(/^\s*[#{d}]/, ' ' * n)
    end
  end

# File lib/facets/core/string/methodize.rb, line 18
  def methodize
    to_s.gsub(/([A-Z])/, '_\1').downcase.gsub(/^_/,'').gsub(/(::|\/)_?/, '__')
  end

# File lib/facets/core/string/modulize.rb, line 16
  def modulize
    to_s.gsub(/(__|\/)(.?)/){ "::" + $2.upcase }.gsub(/(^|_)(.)/){ $2.upcase }
  end

# File lib/facets/core/string/mscan.rb, line 7
  def mscan(re) #:yield:
    if block_given?
      scan(re) { yield($~) }
    else
      m = []
      scan(re) { m << $~ }
      m
    end
  end

# File lib/facets/core/string/natcmp.rb, line 42
  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

# File lib/facets/core/string/nchar.rb, line 11
  def nchar( n, replacement=nil )
    if replacement
      s = self.dup
      n > 0 ? (s[0...n] = replacement) : (s[n..-1] = replacement)
      return s
    else
      n > 0 ? self[0...n] : self[n..-1]
    end
  end

# File lib/facets/core/string/ordinal.rb, line 4
  def ordinal
    self.to_i.ordinal
  end

# File lib/facets/core/string/pathize.rb, line 17
  def pathize
    to_s.gsub(/([A-Z])/, '_\1').downcase.gsub(/^_/,'').gsub(/(::|__)_?/, '/')
  end

# File lib/facets/core/string/singular.rb, line 76
  def plural
    result = self.to_s.dup
    String::PLURAL_RULES.each do |(rule, replacement)|
      break if result.gsub!(rule, replacement)
    end
    return result
  end

# File lib/facets/core/string/pop.rb, line 5
  def pop
    return '' if size == 0
    r = self[-1,1]
    self[-1] = ''
    r #self
  end

# File lib/facets/core/string/pot.rb, line 6
  def pot( str=' ' )
    insert(0, str)
  end

# File lib/facets/core/string/probability.rb, line 7
  def probability(*args)
    to_arr(*args).probability
  end

# File lib/facets/core/string/pull.rb, line 3
  def pull
    return '' if size == 0
    self[0] = ''
    self
  end

# File lib/facets/core/string/push.rb, line 5
  def push(str=' ')
    concat(str)
  end

# File lib/facets/core/string/quote.rb, line 11
  def quote(type=:s)
    case type.to_s.downcase
    when 's', 'single'
      bracket("'")
    when 'd', 'double'
      bracket('"')
    when 'b', 'back'
      bracket('`')
    else
      bracket("'")
    end
  end

# File lib/facets/core/string/rand_byte.rb, line 8
  def rand_byte
    self[rand( size )]
  end

# File lib/facets/core/string/rand_byte.rb, line 18
  def rand_byte!
    i = rand( size )
    rv = self[i,1]
    self[i,1] = ''
    rv
  end

# File lib/facets/core/string/rand_index.rb, line 6
  def rand_index
    rand( size )
  end

# File lib/facets/core/string/range.rb, line 8
  def range(s, offset=0)
    if self.index(s, offset)
      return ($~.begin(0))..($~.end(0)-1)
    end
    nil
  end

# File lib/facets/core/string/range_all.rb, line 12
  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

# File lib/facets/core/string/range_of_line.rb, line 10
  def range_of_line
    offset=0; charmap = []
    self.each do |line|
      charmap << (offset..(offset + line.length - 1))
      offset += line.length
    end
    charmap
  end

# File lib/facets/core/string/regesc.rb, line 5
  def regesc
    Regexp.escape( self )
  end

# File lib/facets/core/string/shatter.rb, line 14
  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

# File lib/facets/core/string/shell_escape.rb, line 7
  def shell_escape
    self.gsub(/([\\\t\| &`<>)('"])/) { |s| '\\' << s }
  end

# File lib/facets/core/string/shift.rb, line 2
  def shift
    return '' if size == 0
    self[0] = ''
    self
  end

# File lib/facets/core/string/shuffle.rb, line 10
  def shuffle(separator=//)
    split(separator).shuffle.join('')
  end

# File lib/facets/core/string/shuffle.rb, line 16
  def shuffle!(separator=//)
    self.replace( shuffle(separator) )
  end

# File lib/facets/core/string/similarity.rb, line 25
  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

# File lib/facets/core/string/singular.rb, line 63
  def singular
    result = self.to_s.dup
    String::SINGULAR_RULES.each do |(rule, replacement)|
      break if result.gsub!(rule, replacement)
    end
    return result
  end

# File lib/facets/core/string/soundex.rb, line 14
  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

# File lib/facets/core/string/starts_with.rb, line 7
  def starts_with?(str)
    self.index( str ) == 0
  end

# File lib/facets/core/string/succ.rb, line 9
  def succ(n=1)
    s = self
    n.times { s = s.succ_once }
    s
  end

# File lib/facets/core/string/indent.rb, line 7
  def tab(n)
    gsub(/^ */, ' ' * n)
  end

# File lib/facets/core/string/indent.rb, line 14
  def tabto(n)
    if self =~ /^( *)\S/
      indent(n - $1.length)
    else
      self
    end
  end

# File lib/facets/core/string/to_a.rb, line 14
  def to_a(div=//,limit=0)
    split(div,limit)
  end

# File lib/facets/core/string/to_b.rb, line 17
  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

# File lib/facets/core/string/to_const.rb, line 12
  def to_const
    split('::').inject(Object){ |namespace,name| namespace.const_get(name) }
  end

# File lib/facets/core/string/to_date.rb, line 4
  def to_date
    require 'date'
    require 'parsedate'
    ::Date::civil(*ParseDate.parsedate(self)[0..2])
  end

# File lib/facets/core/string/to_proc.rb, line 14
  def to_proc(context=nil)
    if context
      if context.kind_of?(Binding) or context.kind_of?(Proc)
        Kernel.eval "proc { #{self} }", context
      else context
        context.instance_eval "proc { #{self} }"
      end
    else
      Kernel.eval "proc { #{self} }"
    end
  end

# File lib/facets/core/string/to_re.rb, line 10
  def to_re(esc=true)
    Regexp.new((esc ? Regexp.escape(self) : self))
  end

# File lib/facets/core/string/to_re.rb, line 19
  def to_rx
    Regexp.new(self)
  end

# File lib/facets/core/string/to_time.rb, line 4
  def to_time
    require 'time'
    Time.parse(self)
  end

# File lib/facets/core/string/unbracket.rb, line 16
  def unbracket(bra=nil, ket=nil)
    if bra
      ket = Sring.bra2ket[bra] unless ket
      ket = ket ? ket : bra
      s = self.dup
      s.gsub!(%r[^#{Regexp.escape(bra)}], '')
      s.gsub!(%r[#{Regexp.escape(ket)}$], '')
      return s
    else
      if m = String.bra2ket[ self[0,1] ]
        return self.slice(1...-1) if self[-1,1]  == m
      end
    end
    return self.dup  # if nothing else
  end

# File lib/facets/core/string/unbracket.rb, line 33
  def unbracket!(bra=nil, ket=nil)
    self.replace( unbracket(bra, ket) )
  end

# File lib/facets/core/string/underscore.rb, line 5
  def underscore #(camel_cased_word)
    self.gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z])([A-Z])/,'\1_\2').downcase
  end

# File lib/facets/core/string/unix_crypt.rb, line 7
  def unix_crypt
    self.crypt(String.rand_letter + String.rand_letter)
  end

# File lib/facets/core/string/unix_crypt.rb, line 12
  def unix_crypt!
    self.replace( unix_crypt )
  end

# File lib/facets/core/string/unpack.rb, line 8
  def unpack(format, offset=nil)
    if offset.nil?
      unpack_from_orgin(format)
    else
      self[offset..-1].unpack_from_orgin(format)
    end
  end

# File lib/facets/core/string/unshift.rb, line 4
  def unshift( str=' ' )
    insert(0, str)
  end

# File lib/facets/core/string/upcase.rb, line 13
  def upcase?
    self.upcase == self
  end

# File lib/facets/core/string/word_filter.rb, line 8
  def word_filter( &blk )
    s = self.dup
    s.word_filter!( &blk )
  end

# File lib/facets/core/string/word_filter.rb, line 17
  def word_filter! #:yield:
    rest_of_string = self
    wordfind = /(\w+)/
    offset = 0
    while wmatch = wordfind.match(rest_of_string)
      word = wmatch[0]
      range = offset+wmatch.begin(0) ... offset+wmatch.end(0)
      rest_of_string = wmatch.post_match
      self[range] = yield( word ).to_s
      offset = self.length - rest_of_string.length
    end
    self
  end

# File lib/facets/core/string/word_wrap.rb, line 18
  def word_wrap( col_width=80 )
    self.dup.word_wrap!( col_width )
  end

# File lib/facets/core/string/word_wrap.rb, line 24
  def word_wrap!( col_width=80 )
    self.gsub!( /(\S{#{col_width}})(?=\S)/, '\1 ' )
    self.gsub!( /(.{1,#{col_width}})(?:\s+|$)/, "\\1\n" )
    self
  end

# File lib/facets/core/string/words.rb, line 8
  def words
    self.split(/\s+/)
  end