Ruby on Rails 5.2 - ActiveSupport::Multibyte::Unicode

मॉड्यूल ActiveSupport :: मल्टीबाइट :: यूनिकोड




ruby

मॉड्यूल ActiveSupport :: मल्टीबाइट :: यूनिकोड

स्थिरांक

HANGUL_LBASE
HANGUL_LCOUNT
HANGUL_NCOUNT
HANGUL_SBASE

हंगुल चरित्र सीमाएँ और गुण

HANGUL_SCOUNT
HANGUL_SLAST
HANGUL_TBASE
HANGUL_TCOUNT
HANGUL_VBASE
HANGUL_VCOUNT
NORMALIZATION_FORMS

सभी उपलब्ध सामान्यीकरण रूपों की एक सूची। सामान्यीकरण के बारे में अधिक जानकारी के लिए www.unicode.org/reports/tr15/tr15-29.html देखें।

UNICODE_VERSION

Unicode संस्करण जो कार्यान्वयन द्वारा समर्थित है

गुण

default_normalization_form [RW]

सामान्य संचालन के लिए उपयोग किए जाने वाले डिफ़ॉल्ट सामान्यीकरण की आवश्यकता होती है। इसे NORMALIZATION_FORMS में किसी भी सामान्यीकरण पर सेट किया जा सकता है।

ActiveSupport::Multibyte::Unicode.default_normalization_form = :c

सार्वजनिक प्रवृत्ति के तरीके

रचना (कोडपॉइंट्स) स्रोत दिखाएं
# File activesupport/lib/active_support/multibyte/unicode.rb, line 161
def compose(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 && lindex < HANGUL_LCOUNT
      vindex = codepoints[starter_pos + 1] - HANGUL_VBASE rescue vindex = -1
      if 0 <= vindex && vindex < HANGUL_VCOUNT
        tindex = codepoints[starter_pos + 2] - HANGUL_TBASE rescue tindex = -1
        if 0 <= tindex && 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 = database.codepoints[current_char]
      if current.combining_class > previous_combining_class
        if ref = database.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 activesupport/lib/active_support/multibyte/unicode.rb, line 140
def decompose(type, codepoints)
  codepoints.inject([]) do |decomposed, cp|
    # if it's a hangul syllable starter character
    if HANGUL_SBASE <= cp && 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 = database.codepoints[cp].decomp_mapping) && (!database.codepoints[cp].decomp_type || type == :compatibility)
      decomposed.concat decompose(type, ncp.dup)
    else
      decomposed << cp
    end
  end
end

विघटित रूप में रचित वर्णों का विघटन।

डाउनकेस (स्ट्रिंग) दिखाएँ स्रोत
# File activesupport/lib/active_support/multibyte/unicode.rb, line 284
def downcase(string)
  apply_mapping string, :lowercase_mapping
end
in_char_class? (कोडपॉइंट, कक्षाएं) स्रोत दिखाएं
# File activesupport/lib/active_support/multibyte/unicode.rb, line 42
def in_char_class?(codepoint, classes)
  classes.detect { |c| database.boundary[c] === codepoint } ? true : false
end

पता लगाएँ कि क्या कोडपॉइंट एक निश्चित वर्ण वर्ग में है। जब यह निर्दिष्ट वर्ण वर्ग में होता है और अन्यथा false होता true तो वापस लौटाता true । मान्य वर्ण वर्ग हैं:: :cr :lf :l :v :lv :lvt और :t

मुख्य रूप से अंगूर क्लस्टर समर्थन द्वारा उपयोग किया जाता है।

normalize (string, form = nil) शो सोर्स
# File activesupport/lib/active_support/multibyte/unicode.rb, line 266
def normalize(string, form = nil)
  form ||= @default_normalization_form
  # See http://www.unicode.org/reports/tr15, Table 1
  codepoints = string.codepoints.to_a
  case form
  when :d
    reorder_characters(decompose(:canonical, codepoints))
  when :c
    compose(reorder_characters(decompose(:canonical, codepoints)))
  when :kd
    reorder_characters(decompose(:compatibility, codepoints))
  when :kc
    compose(reorder_characters(decompose(:compatibility, codepoints)))
  else
    raise ArgumentError, "#{form} is not a valid normalization variant", caller
  end.pack("U*".freeze)
end

डिफ़ॉल्ट रूप से स्ट्रिंग का KC सामान्यीकरण लौटाता है। NFKC को डेटाबेस और सत्यापन के लिए तार पास करने के लिए सबसे अच्छा सामान्यीकरण फॉर्म माना जाता है।

  • string - सामान्य पर प्रदर्शन करने के लिए स्ट्रिंग।

  • form - वह फ़ॉर्म जिसे आप सामान्य करना चाहते हैं। निम्न में से एक होना चाहिए :c :kc :d , या :kd । डिफ़ॉल्ट #default_normalization_form

pack_graphemes ( अनपैक्ड ) शो स्रोत
# File activesupport/lib/active_support/multibyte/unicode.rb, line 119
def pack_graphemes(unpacked)
  unpacked.flatten.pack("U*")
end

Unpack_graphemes का रिवर्स ऑपरेशन।

Unicode.pack_graphemes(Unicode.unpack_graphemes('क्षि')) # => 'क्षि'
reorder_characters ( कोडपॉइंट्स ) स्रोत दिखाएं
# File activesupport/lib/active_support/multibyte/unicode.rb, line 124
def reorder_characters(codepoints)
  length = codepoints.length - 1
  pos = 0
  while pos < length do
    cp1, cp2 = database.codepoints[codepoints[pos]], database.codepoints[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 activesupport/lib/active_support/multibyte/unicode.rb, line 292
def swapcase(string)
  apply_mapping string, :swapcase_mapping
end
tidy_bytes (स्ट्रिंग, बल = गलत) स्रोत दिखाएं
# File activesupport/lib/active_support/multibyte/unicode.rb, line 226
def tidy_bytes(string, force = false)
  return string if string.empty?
  return recode_windows1252_chars(string) if force
  string.scrub { |bad| recode_windows1252_chars(bad) }
end

सभी ISO-8859-1 या CP1252 वर्णों को उनके UTF-8 समकक्ष से बदल देता है, जिसके परिणामस्वरूप एक मान्य UTF-8 स्ट्रिंग होता है।

पासिंग true के एन्कोडिंग पूरी तरह से CP1252 या ISO-8851-1 है, यह मानते हुए कि सभी बाइट्स को जबरन पास कर दिया जाएगा।

unpack_graphemes (string) स्रोत दिखाएँ
# File activesupport/lib/active_support/multibyte/unicode.rb, line 51
def unpack_graphemes(string)
  codepoints = string.codepoints.to_a
  unpacked = []
  pos = 0
  marker = 0
  eoc = codepoints.length
  while (pos < eoc)
    pos += 1
    previous = codepoints[pos - 1]
    current = codepoints[pos]

    # See http://unicode.org/reports/tr29/#Grapheme_Cluster_Boundary_Rules
    should_break =
      if pos == eoc
        true
      # GB3. CR X LF
      elsif previous == database.boundary[:cr] && current == database.boundary[:lf]
        false
      # GB4. (Control|CR|LF) ÷
      elsif previous && in_char_class?(previous, [:control, :cr, :lf])
        true
      # GB5. ÷ (Control|CR|LF)
      elsif in_char_class?(current, [:control, :cr, :lf])
        true
      # GB6. L X (L|V|LV|LVT)
      elsif database.boundary[:l] === previous && in_char_class?(current, [:l, :v, :lv, :lvt])
        false
      # GB7. (LV|V) X (V|T)
      elsif in_char_class?(previous, [:lv, :v]) && in_char_class?(current, [:v, :t])
        false
      # GB8. (LVT|T) X (T)
      elsif in_char_class?(previous, [:lvt, :t]) && database.boundary[:t] === current
        false
      # GB9. X (Extend | ZWJ)
      elsif in_char_class?(current, [:extend, :zwj])
        false
      # GB9a. X SpacingMark
      elsif database.boundary[:spacingmark] === current
        false
      # GB9b. Prepend X
      elsif database.boundary[:prepend] === previous
        false
      # GB10. (E_Base | EBG) Extend* X E_Modifier
      elsif (marker...pos).any? { |i| in_char_class?(codepoints[i], [:e_base, :e_base_gaz]) && codepoints[i + 1...pos].all? { |c| database.boundary[:extend] === c } } && database.boundary[:e_modifier] === current
        false
      # GB11. ZWJ X (Glue_After_Zwj | EBG)
      elsif database.boundary[:zwj] === previous && in_char_class?(current, [:glue_after_zwj, :e_base_gaz])
        false
      # GB12. ^ (RI RI)* RI X RI
      # GB13. [^RI] (RI RI)* RI X RI
      elsif codepoints[marker..pos].all? { |c| database.boundary[:regional_indicator] === c } && codepoints[marker..pos].count { |c| database.boundary[:regional_indicator] === c }.even?
        false
      # GB999. Any ÷ Any
      else
        true
      end

    if should_break
      unpacked << codepoints[marker..pos - 1]
      marker = pos
    end
  end
  unpacked
end

स्ट्रिंग को अंगूर की सीमाओं पर अनपैक करें। चरित्र सूची की सूची देता है।

Unicode.unpack_graphemes('क्षि') # => [[2325, 2381], [2359], [2367]]
Unicode.unpack_graphemes('Café') # => [[67], [97], [102], [233]]
upcase (string) शो सोर्स
# File activesupport/lib/active_support/multibyte/unicode.rb, line 288
def upcase(string)
  apply_mapping string, :uppercase_mapping
end