Module: Idnx::Ruby::Punycode

Defined in:: lib/idnx/ruby.rb

Overview

:nocov: -*- coding: utf-8 -*- – punycode.rb - PunyCode encoder for the Domain Name library

Ported from puny.c, a part of VeriSign XCode (encode/decode) IDN Library.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1) Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.

2) Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in
   the documentation and/or other materials provided with the
   distribution.

3) Neither the name of the VeriSign Inc. nor the names of its
   contributors may be used to endorse or promote products derived
   from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

This software is licensed under the BSD open source license. For more information visit www.opensource.org.

Authors:

John Colosi (VeriSign)
Srikanth Veeramachaneni (VeriSign)
Nagesh Chigurupati (Verisign)
Praveen Srinivasan(Verisign)

Defined Under Namespace

Classes: ArgumentError, BufferOverflowError

Constant Summary collapse

BASE =

TMIN =

TMAX =

SKEW =

DAMP =

INITIAL_BIAS =

INITIAL_N =

0x80

DELIMITER =

"-"

MAXINT =

(1 << 32) - 1

LOBASE =

BASE - TMIN

CUTOFF =

LOBASE * TMAX / 2

RE_NONBASIC =

/[^\x00-\x7f]/.freeze

DECODE_DIGIT = Returns the numeric value of a basic code point (for use in representing integers) in the range 0 to base-1, or nil if cp is does not represent a value.

{}.tap do |map|
  # ASCII A..Z map to 0..25
  # ASCII a..z map to 0..25
  (0..25).each { |i| map[65 + i] = map[97 + i] = i }
  # ASCII 0..9 map to 26..35
  (26..35).each { |i| map[22 + i] = i }
end

ENCODE_DIGIT = Returns the basic code point whose value (when used for representing integers) is d, which must be in the range 0 to BASE-1. The lowercase form is used unless flag is true, in which case the uppercase form is used. The behavior is undefined if flag is nonzero and digit d has no uppercase form.

proc { |d, flag|
  (d + 22 + (d < 26 ? 75 : 0) - (flag ? (1 << 5) : 0)).chr
  #  0..25 map to ASCII a..z or A..Z
  # 26..35 map to ASCII 0..9
}

DOT =

"."

PREFIX =

"xn--"

Class Method Summary collapse

.decode(string) ⇒ Object

Decode a string encoded in Punycode.
.decode_hostname(hostname) ⇒ Object

Decode a hostname using IDN/Punycode algorithms.
.encode(string) ⇒ Object

Encode a string in Punycode.
.encode_hostname(hostname) ⇒ Object

Encode a hostname using IDN/Punycode algorithms.

Class Method Details

.decode(string) ⇒ `Object`

Decode a string encoded in Punycode

# File 'lib/idnx/ruby.rb', line 206

def decode(string)
  # Initialize the state
  n = INITIAL_N
  i = 0
  bias = INITIAL_BIAS

  if j = string.rindex(DELIMITER)
    b = string[0...j]

    b.match(RE_NONBASIC) &&
      raise(ArgumentError, "Illegal character is found in basic part: #{string.inspect}")

    # Handle the basic code points

    output = b.unpack("U*")
    u = string[(j + 1)..-1]
  else
    output = []
    u = string
  end

  # Main decoding loop: Start just after the last delimiter if any
  # basic code points were copied; start at the beginning
  # otherwise.

  input = u.unpack("C*")
  input_length = input.length
  h = 0
  out = output.length

  while h < input_length
    # Decode a generalized variable-length integer into delta,
    # which gets added to i.  The overflow checking is easier
    # if we increase i as we go, then subtract off its starting
    # value at the end to obtain delta.

    oldi = i
    w = 1
    k = BASE

    loop do
      (digit = DECODE_DIGIT[input[h]]) ||
        raise(ArgumentError, "Illegal character is found in non-basic part: #{string.inspect}")
      h += 1
      i += digit * w
      raise BufferOverflowError if i > MAXINT

      t = k <= bias ? TMIN : k - bias >= TMAX ? TMAX : k - bias
      break if digit < t

      w *= BASE - t
      raise BufferOverflowError if w > MAXINT

      k += BASE
      (h < input_length) || raise(ArgumentError, "Malformed input given: #{string.inspect}")
    end

    # Adapt the bias
    delta = oldi == 0 ? i / DAMP : (i - oldi) >> 1
    delta += delta / (out + 1)
    bias = 0
    while delta > CUTOFF
      delta /= LOBASE
      bias += BASE
    end
    bias += (LOBASE + 1) * delta / (delta + SKEW)

    # i was supposed to wrap around from out+1 to 0, incrementing
    # n each time, so we'll fix that now:

    q, i = i.divmod(out + 1)
    n += q
    raise BufferOverflowError if n > MAXINT

    # Insert n at position i of the output:

    output[i, 0] = n

    out += 1
    i += 1
  end
  output.pack("U*")
end

.decode_hostname(hostname) ⇒ `Object`

Decode a hostname using IDN/Punycode algorithms

# File 'lib/idnx/ruby.rb', line 291

def decode_hostname(hostname)
  hostname.gsub(/(\A|#{Regexp.quote(DOT)})#{Regexp.quote(PREFIX)}([^#{Regexp.quote(DOT)}]*)/o) do
    Regexp.last_match(1) << decode(Regexp.last_match(2))
  end
end

.encode(string) ⇒ `Object`

Encode a string in Punycode

# File 'lib/idnx/ruby.rb', line 111

def encode(string)
  input = string.unpack("U*")
  output = +""

  # Initialize the state
  n = INITIAL_N
  delta = 0
  bias = INITIAL_BIAS

  # Handle the basic code points
  input.each { |cp| output << cp.chr if cp < 0x80 }

  h = b = output.length

  # h is the number of code points that have been handled, b is the
  # number of basic code points, and out is the number of characters
  # that have been output.

  output << DELIMITER if b > 0

  # Main encoding loop

  while h < input.length
    # All non-basic code points < n have been handled already.  Find
    # the next larger one

    m = MAXINT
    input.each do |cp|
      m = cp if (n...m) === cp
    end

    # Increase delta enough to advance the decoder's <n,i> state to
    # <m,0>, but guard against overflow

    delta += (m - n) * (h + 1)
    raise BufferOverflowError if delta > MAXINT

    n = m

    input.each do |cp|
      # AMC-ACE-Z can use this simplified version instead
      if cp < n
        delta += 1
        raise BufferOverflowError if delta > MAXINT
      elsif cp == n
        # Represent delta as a generalized variable-length integer
        q = delta
        k = BASE
        loop do
          t = k <= bias ? TMIN : k - bias >= TMAX ? TMAX : k - bias
          break if q < t

          q, r = (q - t).divmod(BASE - t)
          output << ENCODE_DIGIT[t + r, false]
          k += BASE
        end

        output << ENCODE_DIGIT[q, false]

        # Adapt the bias
        delta = h == b ? delta / DAMP : delta >> 1
        delta += delta / (h + 1)
        bias = 0
        while delta > CUTOFF
          delta /= LOBASE
          bias += BASE
        end
        bias += (LOBASE + 1) * delta / (delta + SKEW)

        delta = 0
        h += 1
      end
    end

    delta += 1
    n += 1
  end

  output
end

.encode_hostname(hostname) ⇒ `Object`

Encode a hostname using IDN/Punycode algorithms

# File 'lib/idnx/ruby.rb', line 193

def encode_hostname(hostname)
  hostname.match(RE_NONBASIC) || (return hostname)

  hostname.split(DOT).map do |name|
    if name.match(RE_NONBASIC)
      PREFIX + encode(name)
    else
      name
    end
  end.join(DOT)
end