Class ActiveSupport::Multibyte::Handlers::UTF8Handler < Object

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 192
def capitalize(str)
  upcase(slice(str, 0..0)) + downcase(slice(str, 1..-1) || '')
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 228
def compose(str)
  compose_codepoints u_unpack(str).pack('U*')
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 258
def consumes?(str)
  # Unpack is a little bit faster than regular expressions
  begin
    str.unpack('U*')
    true
  rescue ArgumentError
    false
  end
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 223
def decompose(str)
  decompose_codepoints(:canonical, u_unpack(str)).pack('U*')
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 189
def downcase(str); to_case :lowercase_mapping, str; end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 270
def g_length(str)
  g_unpack(str).length
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 138
def index(str, *args)
  bidx = str.index(*args)
  bidx ? (u_unpack(str.slice(0...bidx)).size) : nil
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 128
def insert(str, offset, fragment)
  str.replace(
    u_unpack(str).insert(
      offset,
      u_unpack(fragment)
    ).flatten.pack('U*')
  )
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 149
def lstrip(str)
  str.gsub(UNICODE_LEADERS_PAT, '')
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 205
def normalize(str, form=ActiveSupport::Multibyte::DEFAULT_NORMALIZATION_FORM)
  # See http://www.unicode.org/reports/tr15, Table 1
  codepoints = u_unpack(str)
  case form
    when :d
      reorder_characters(decompose_codepoints(:canonical, codepoints))
    when :c
      compose_codepoints reorder_characters(decompose_codepoints(:canonical, codepoints))
    when :kd
      reorder_characters(decompose_codepoints(:compatability, codepoints))
    when :kc
      compose_codepoints reorder_characters(decompose_codepoints(:compatability, codepoints))
    else
      raise ArgumentError, "#{form} is not a valid normalization variant", caller
  end.pack('U*')
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 165
def reverse(str)
  u_unpack(str).reverse.pack('U*')
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 144
def rstrip(str)
  str.gsub(UNICODE_TRAILERS_PAT, '')
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 159
def size(str)
  u_unpack(str).size
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 171
def slice(str, *args)
  if (args.size == 2 && args.first.is_a?(Range))
    raise TypeError, 'cannot convert Range into Integer' # Do as if we were native
  elsif args[0].kind_of? Range
    cps = u_unpack(str).slice(*args)
    cps.nil? ? nil : cps.pack('U*')
  elsif args.size == 1 && args[0].kind_of?(Numeric)
    u_unpack(str)[args[0]]
  else
    u_unpack(str).slice(*args).pack('U*')
  end
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 154
def strip(str)
  str.gsub(UNICODE_LEADERS_PAT, '').gsub(UNICODE_TRAILERS_PAT, '')
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 275
def tidy_bytes(str)
  str.split(%r/).map do |c|
    if !UTF8_PAT.match(c)
      n = c.unpack('C')[0]
      n < 128 ? n.chr :
      n < 160 ? [UCD.cp1252[n] || n].pack('U') :
      n < 192 ? "\xC2" + n.chr : "\xC3" + (n-64).chr
    else
      c
    end
  end.join
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 237
def translate_offset(str, byte_offset)
  return 0 if str == ''
  return nil if byte_offset.nil?
  chunk = str[0..byte_offset]
  begin
    begin
      chunk.unpack('U*').length - 1
    rescue ArgumentError => e
      chunk = str[0..(byte_offset+=1)]
      # Stop retrying at the end of the string
      raise e unless byte_offset < chunk.length 
      # We damaged a character, retry
      retry
    end
  # Catch the ArgumentError so we can throw our own
  rescue ArgumentError 
    raise EncodingError.new('malformed UTF-8 character')
  end
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 186
def upcase(str); to_case :uppercase_mapping, str; end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 392
def compose_codepoints(codepoints)
  pos = 0
  eoa = codepoints.length - 1
  starter_pos = 0
  starter_char = codepoints[0]
  previous_combining_class = -1
  while pos < eoa
    pos += 1
    lindex = starter_char - HANGUL_LBASE
    # -- Hangul
    if 0 <= lindex and lindex < HANGUL_LCOUNT
      vindex = codepoints[starter_pos+1] - HANGUL_VBASE rescue vindex = -1
      if 0 <= vindex and vindex < HANGUL_VCOUNT
        tindex = codepoints[starter_pos+2] - HANGUL_TBASE rescue tindex = -1
        if 0 <= tindex and tindex < HANGUL_TCOUNT
          j = starter_pos + 2
          eoa -= 2
        else
          tindex = 0
          j = starter_pos + 1
          eoa -= 1
        end
        codepoints[starter_pos..j] = (lindex * HANGUL_VCOUNT + vindex) * HANGUL_TCOUNT + tindex + HANGUL_SBASE
      end
      starter_pos += 1
      starter_char = codepoints[starter_pos]
    # -- Other characters
    else
      current_char = codepoints[pos]
      current = UCD[current_char]
      if current.combining_class > previous_combining_class
        if ref = UCD.composition_map[starter_char]
          composition = ref[current_char]
        else
          composition = nil
        end
        unless composition.nil?
          codepoints[starter_pos] = composition
          starter_char = composition
          codepoints.delete_at pos
          eoa -= 1
          pos -= 1
          previous_combining_class = -1
        else
          previous_combining_class = current.combining_class
        end
      else
        previous_combining_class = current.combining_class
      end
      if current.combining_class == 0
        starter_pos = pos
        starter_char = codepoints[pos]
      end
    end
  end
  codepoints
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 371
def decompose_codepoints(type, codepoints)
  codepoints.inject([]) do |decomposed, cp|
    # if it's a hangul syllable starter character
    if HANGUL_SBASE <= cp and cp < HANGUL_SLAST
      sindex = cp - HANGUL_SBASE
      ncp = [] # new codepoints
      ncp << HANGUL_LBASE + sindex / HANGUL_NCOUNT
      ncp << HANGUL_VBASE + (sindex % HANGUL_NCOUNT) / HANGUL_TCOUNT
      tindex = sindex % HANGUL_TCOUNT
      ncp << (HANGUL_TBASE + tindex) unless tindex == 0
      decomposed.concat ncp
    # if the codepoint is decomposable in with the current decomposition type
    elsif (ncp = UCD[cp].decomp_mapping) and (!UCD[cp].decomp_type || type == :compatability)
      decomposed.concat decompose_codepoints(type, ncp.dup)
    else
      decomposed << cp
    end
  end
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 337
def g_pack(unpacked)
  unpacked.flatten
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 306
def g_unpack(str)
  codepoints = u_unpack(str)
  unpacked = []
  pos = 0
  marker = 0
  eoc = codepoints.length
  while(pos < eoc)
    pos += 1
    previous = codepoints[pos-1]
    current = codepoints[pos]
    if (
        # CR X LF
        one = ( previous == UCD.boundary[:cr] and current == UCD.boundary[:lf] ) or
        # L X (L|V|LV|LVT)
        two = ( UCD.boundary[:l] === previous and in_char_class?(current, [:l,:v,:lv,:lvt]) ) or
        # (LV|V) X (V|T)
        three = ( in_char_class?(previous, [:lv,:v]) and in_char_class?(current, [:v,:t]) ) or
        # (LVT|T) X (T)
        four = ( in_char_class?(previous, [:lvt,:t]) and UCD.boundary[:t] === current ) or
        # X Extend
        five = (UCD.boundary[:extend] === current)
      )
    else
      unpacked << codepoints[marker..pos-1]
      marker = pos
    end
  end 
  unpacked
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 292
def in_char_class?(codepoint, classes)
  classes.detect { |c| UCD.boundary[c] === codepoint } ? true : false
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 355
def reorder_characters(codepoints)
  length = codepoints.length- 1
  pos = 0
  while pos < length do
    cp1, cp2 = UCD[codepoints[pos]], UCD[codepoints[pos+1]]
    if (cp1.combining_class > cp2.combining_class) && (cp2.combining_class > 0)
      codepoints[pos..pos+1] = cp2.code, cp1.code
      pos += (pos > 0 ? -1 : 1)
    else
      pos += 1
    end
  end
  codepoints
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 342
def to_case(way, str)
  u_unpack(str).map do |codepoint|
    cp = UCD[codepoint] 
    unless cp.nil?
      ncp = cp.send(way)
      ncp > 0 ? ncp : codepoint
    else
      codepoint
    end
  end.pack('U*')
end

# File rails/activesupport/lib/active_support/multibyte/handlers/utf8_handler.rb, line 297
def u_unpack(str)
  begin
    str.unpack 'U*'
  rescue ArgumentError
    raise EncodingError.new('malformed UTF-8 character')
  end
end