simpleidn 0.0.1

data/LICENCE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2011 Morten Møller Riis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Manifest

@@ -0,0 +1,8 @@
+LICENCE
+Manifest
+README.rdoc
+Rakefile
+lib/simpleidn.rb
+simpleidn.gemspec
+spec/idn.rb
+spec/test_vectors.rb

data/README.rdoc

@@ -0,0 +1,37 @@
+== SimpleIDN
+
+This gem allows easy conversion from punycode ACE strings to unicode UTF-8 strings and visa versa.
+
+The implementation is heavily based on the RFC3492 C example implementation but simplified since it does not preserve case.
+
+This gem works with both Ruby 1.8.7 and 1.9.2.
+
+* http://www.whatastruggle.com
+
+== Installation
+
+  [sudo] gem install simpleidn
+
++sudo+ is optional depending on your setup.
+
+In your Ruby script you can now.
+
+  require 'rubygems'
+  require 'simpleidn'
+  
+  SimpleIDN.to_unicode("xn--mllerriis-l8a.com")
+  => "møllerriis.com" 
+  
+	SimpleIDN.to_ascii("møllerriis.com")
+  => "xn--mllerriis-l8a.com" 
+  
+== Testing / RSpec
+
+In order to run the test suite you must have <tt>rspec</tt> installed.
+
+The test suite has been copied from the IDN gem and uses examples from JOSEFSSON test vectors, taken from DRAFT-JOSEFSSON-IDN-TEST-VECTORS-00:
+http://www.gnu.org/software/libidn/draft-josefsson-idn-test-vectors.html
+
+== Known issues
+
+None at the moment, but please report any issues!

data/Rakefile

@@ -0,0 +1,13 @@
+# encoding: utf-8
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('simpleidn', '0.0.1') do |p|
+  p.description    = "This gem allows easy conversion from punycode ACE strings to unicode UTF-8 strings and visa versa."
+  p.url            = "http://github.com/mmriis/simpleidn"
+  p.author         = "Morten Møller Riis"
+  p.email          = "mortenmoellerriis _AT_ gmail.com"
+  p.ignore_pattern = ["tmp/*", "script/*"]
+end
+

data/lib/simpleidn.rb

@@ -0,0 +1,252 @@
+# encoding: UTF-8
+if RUBY_VERSION =~ /^1\.8/
+  $KCODE = "UTF-8"
+  class String
+    def ord
+      self[0]
+    end
+  end
+else
+  Encoding.default_internal = "UTF-8"  
+end
+
+class Integer
+  def to_utf8_character
+    [self].pack("U*")
+  end
+end
+
+module SimpleIDN
+    
+  module Punycode
+    
+    INITIAL_N = 0x80
+    INITIAL_BIAS = 72
+    DELIMITER = 0x2D
+    BASE = 36
+    DAMP = 700
+    TMIN = 1
+    TMAX = 26
+    SKEW = 38
+    MAXINT = 0x7FFFFFFF
+
+    module_function  
+    
+    # decode_digit(cp) returns the numeric value of a basic code 
+    # point (for use in representing integers) in the range 0 to
+    # base-1, or base if cp is does not represent a value. 
+    def decode_digit(cp)
+      cp - 48 < 10 ? cp - 22 : cp - 65 < 26 ? cp - 65 : cp - 97 < 26 ? cp - 97 : BASE
+    end
+  
+    # encode_digit(d,flag) returns the basic code point whose value
+    # (when used for representing integers) is d, which needs to be in
+    # the range 0 to base-1. The lowercase form is used unless flag is
+    # nonzero, in which case the uppercase form is used. The behavior
+    # is undefined if flag is nonzero and digit d has no uppercase form. 
+    def encode_digit(d)
+      d + 22 + 75 * (d < 26 ? 1 : 0)
+      #  0..25 map to ASCII a..z or A..Z 
+      # 26..35 map to ASCII 0..9
+    end
+  
+    # Bias adaptation function
+    def adapt(delta, numpoints, firsttime)
+      delta = firsttime ? (delta / DAMP) : (delta >> 1)
+      delta += (delta / numpoints)
+
+      k = 0
+      while delta > (((BASE - TMIN) * TMAX) / 2) do
+        delta /= BASE - TMIN
+        k += BASE
+      end
+      return k + (BASE - TMIN + 1) * delta / (delta + SKEW)
+    end
+  
+    # encode_basic(bcp,flag) forces a basic code point to lowercase if flag is zero,
+    # uppercase if flag is nonzero, and returns the resulting code point.
+    # The code point is unchanged if it is caseless.
+    # The behavior is undefined if bcp is not a basic code point.
+    def encode_basic(bcp, flag)
+      bcp -= (bcp - 97 < 26 ? 1 : 0) << 5
+      return bcp + ((!flag && (bcp - 65 < 26 ? 1 : 0)) << 5)
+    end
+  
+    # Main decode
+    def decode(input)
+      output = []
+
+      # Initialize the state: 
+      n = INITIAL_N
+      i = 0
+      bias = INITIAL_BIAS
+
+      # Handle the basic code points: Let basic be the number of input code 
+      # points before the last delimiter, or 0 if there is none, then
+      # copy the first basic code points to the output.
+      basic = input.rindex(DELIMITER.to_utf8_character) || 0
+
+      input.unpack("U*")[0, basic].each do |char|
+        raise(RangeError, "Illegal input >= 0x80") if char >= 0x80
+        output << char.chr # to_utf8_character not needed her because ord < 0x80 (128) which is within US-ASCII.
+      end
+
+      # Main decoding loop: Start just after the last delimiter if any
+      # basic code points were copied; start at the beginning otherwise. 
+
+      ic = basic > 0 ? basic + 1 : 0
+      while ic < input.length do
+        # ic is the index of the next character to be consumed,
+
+        # 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
+        while true do
+          raise(RangeError, "punycode_bad_input(1)") if ic >= input.length
+
+          digit = decode_digit(input[ic].ord)
+          ic += 1
+
+          raise(RangeError, "punycode_bad_input(2)") if digit >= BASE
+        
+          raise(RangeError, "punycode_overflow(1)") if digit > (MAXINT - i) / w
+
+          i += digit * w
+          t = k <= bias ? TMIN : k >= bias + TMAX ? TMAX : k - bias
+          break if digit < t
+          raise(RangeError, "punycode_overflow(2)") if w > MAXINT / (BASE - t)
+        
+          w *= BASE - t
+          k += BASE
+        end
+
+        out = output.length + 1
+        bias = adapt(i - oldi, out, oldi == 0)
+
+        # i was supposed to wrap around from out to 0,
+        # incrementing n each time, so we'll fix that now: 
+        raise(RangeError, "punycode_overflow(3)") if (i / out) > MAXINT - n
+
+        n += (i / out)
+        i %= out
+
+        # Insert n at position i of the output: 
+        output.insert(i, n.to_utf8_character)
+        i += 1
+      end
+    
+      return output.join
+    end
+
+    # Main encode function
+    def encode(input)
+
+      input = input.downcase.unpack("U*")
+      output = []
+
+      # Initialize the state: 
+      n = INITIAL_N
+      delta = 0
+      bias = INITIAL_BIAS
+
+      # Handle the basic code points: 
+      output = input.select do |char|
+        char if char < 0x80
+      end
+    
+      h = b = output.length
+
+      # h is the number of code points that have been handled, b is the
+      # number of basic code points 
+
+      output << DELIMITER if b > 0
+
+      # Main encoding loop:
+      while h < input.length do
+        # All non-basic code points < n have been
+        # handled already. Find the next larger one: 
+
+        m = MAXINT
+        
+        input.each do |char|
+          m = char if char >= n && char < m
+        end
+
+        # Increase delta enough to advance the decoder's
+        # <n,i> state to <m,0>, but guard against overflow: 
+
+        raise(RangeError, "punycode_overflow (1)") if m - n > ((MAXINT - delta) / (h + 1)).floor
+
+        delta += (m - n) * (h + 1)
+        n = m
+
+        input.each_with_index do |char, j|
+          if char < n
+            delta += 1
+            raise(StandardError,"punycode_overflow(2)") if delta > MAXINT
+          end
+
+          if (char == n)
+              # Represent delta as a generalized variable-length integer: 
+              q = delta
+              k = BASE
+              while true do
+                  t = k <= bias ? TMIN : k >= bias + TMAX ? TMAX : k - bias
+                  break if q < t
+                  output << encode_digit(t + (q - t) % (BASE - t))
+                  q = ( (q - t) / (BASE - t) ).floor
+                  k += BASE
+              end
+              output << encode_digit(q)
+              bias = adapt(delta, h + 1, h == b)
+              delta = 0
+              h += 1
+          end
+        end
+
+        delta += 1
+        n += 1
+      end
+      return output.collect {|c| c.to_utf8_character}.join
+    end
+
+  end
+  
+  module_function
+  
+  # Converts a UTF-8 unicode string to a punycode ACE string.
+  # == Example
+  #   SimpleIDN.to_ascii("møllerriis.com")
+  #    => "xn--mllerriis-l8a.com" 
+  def to_ascii(domain) 
+    domain_array = domain.split(".")
+    out = []
+    i = 0
+    while i < domain_array.length
+      s = domain_array[i]
+      out << (s =~ /[^A-Z0-9\-]/i ? "xn--" + Punycode.encode(s) : s)
+      i += 1
+    end
+    return out.join(".")
+  end
+
+  # Converts a punycode ACE string to a UTF-8 unicode string.
+  # == Example
+  #   SimpleIDN.to_unicode("xn--mllerriis-l8a.com")
+  #    => "møllerriis.com" 
+  def to_unicode(domain)
+    domain_array = domain.split(".")
+    out = []
+    i = 0
+    while i < domain_array.length
+      s = domain_array[i]
+      out << (s =~ /^xn\-\-/i ? Punycode.decode(s.gsub('xn--','')) : s)
+      i += 1
+    end
+    return out.join(".")
+  end
+end

data/simpleidn.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{simpleidn}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Morten Møller Riis"]
+  s.cert_chain = ["/Users/mmr/gem-public_cert.pem"]
+  s.date = %q{2011-05-09}
+  s.description = %q{This gem allows easy conversion from punycode ACE strings to unicode UTF-8 strings and visa versa.}
+  s.email = %q{mortenmoellerriis _AT_ gmail.com}
+  s.extra_rdoc_files = ["README.rdoc", "lib/simpleidn.rb"]
+  s.files = ["LICENCE", "Manifest", "README.rdoc", "Rakefile", "lib/simpleidn.rb", "simpleidn.gemspec", "spec/idn.rb", "spec/test_vectors.rb"]
+  s.homepage = %q{http://github.com/mmriis/simpleidn}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Simpleidn", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{simpleidn}
+  s.rubygems_version = %q{1.6.2}
+  s.signing_key = %q{/Users/mmr/gem-private_key.pem}
+  s.summary = %q{This gem allows easy conversion from punycode ACE strings to unicode UTF-8 strings and visa versa.}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/spec/idn.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+require 'rspec'
+require 'simpleidn'
+require 'test_vectors'
+
+  
+describe "SimpleIDN" do
+  describe "to_unicode" do
+    it "should pass all test cases" do
+      TESTCASES_JOSEFSSON.sort.each do |testcase, vector|
+        SimpleIDN.to_unicode(vector[1]).should == vector[0]
+      end
+    end
+  end
+  describe "to_ascii" do
+    it "should pass all test cases" do
+      TESTCASES_JOSEFSSON.sort.each do |testcase, vector|
+        SimpleIDN.to_ascii(vector[0]) == vector[1]
+      end
+    end
+  end
+end

data/spec/test_vectors.rb

@@ -0,0 +1,138 @@
+# JOSEFSSON test vectors, taken from DRAFT-JOSEFSSON-IDN-TEST-VECTORS-00:
+# http://www.gnu.org/software/libidn/draft-josefsson-idn-test-vectors.html
+#
+# Modifications:
+#   - omission of 5.20 since it is identical with 5.8 (case H below)
+
+TESTCASES_JOSEFSSON = {
+'A' => [
+  [ 0x0644, 0x064A, 0x0647, 0x0645, 0x0627, 0x0628, 0x062A, 0x0643,
+    0x0644, 0x0645, 0x0648, 0x0634, 0x0639, 0x0631, 0x0628, 0x064A,
+    0x061F ].pack('U*'),
+  'xn--egbpdaj6bu4bxfgehfvwxn'
+],
+
+'B' => [
+  [ 0x4ED6, 0x4EEC, 0x4E3A, 0x4EC0, 0x4E48, 0x4E0D, 0x8BF4, 0x4E2D,
+    0x6587 ].pack('U*'),
+  'xn--ihqwcrb4cv8a8dqg056pqjye'
+],
+
+'C' => [
+  [ 0x4ED6, 0x5011, 0x7232, 0x4EC0, 0x9EBD, 0x4E0D, 0x8AAA, 0x4E2D,
+    0x6587 ].pack('U*'),
+  'xn--ihqwctvzc91f659drss3x8bo0yb'
+],
+
+'D' => [
+  [ 0x0050, 0x0072, 0x006F, 0x010D, 0x0070, 0x0072, 0x006F, 0x0073,
+    0x0074, 0x011B, 0x006E, 0x0065, 0x006D, 0x006C, 0x0075, 0x0076,
+    0x00ED, 0x010D, 0x0065, 0x0073, 0x006B, 0x0079 ].pack('U*'),
+  'xn--Proprostnemluvesky-uyb24dma41a'
+],
+
+'E' => [
+  [ 0x05DC, 0x05DE, 0x05D4, 0x05D4, 0x05DD, 0x05E4, 0x05E9, 0x05D5,
+    0x05D8, 0x05DC, 0x05D0, 0x05DE, 0x05D3, 0x05D1, 0x05E8, 0x05D9,
+    0x05DD, 0x05E2, 0x05D1, 0x05E8, 0x05D9, 0x05EA ].pack('U*'),
+  'xn--4dbcagdahymbxekheh6e0a7fei0b'
+],
+
+'F' => [
+  [ 0x092F, 0x0939, 0x0932, 0x094B, 0x0917, 0x0939, 0x093F, 0x0928,
+    0x094D, 0x0926, 0x0940, 0x0915, 0x094D, 0x092F, 0x094B, 0x0902,
+    0x0928, 0x0939, 0x0940, 0x0902, 0x092C, 0x094B, 0x0932, 0x0938,
+    0x0915, 0x0924, 0x0947, 0x0939, 0x0948, 0x0902 ].pack('U*'),
+  'xn--i1baa7eci9glrd9b2ae1bj0hfcgg6iyaf8o0a1dig0cd'
+],
+
+'G' => [
+  [ 0x306A, 0x305C, 0x307F, 0x3093, 0x306A, 0x65E5, 0x672C, 0x8A9E,
+    0x3092, 0x8A71, 0x3057, 0x3066, 0x304F, 0x308C, 0x306A, 0x3044,
+    0x306E, 0x304B ].pack('U*'),
+  'xn--n8jok5ay5dzabd5bym9f0cm5685rrjetr6pdxa'
+],
+
+'H' => [
+  [ 0x043F, 0x043E, 0x0447, 0x0435, 0x043C, 0x0443, 0x0436, 0x0435,
+    0x043E, 0x043D, 0x0438, 0x043D, 0x0435, 0x0433, 0x043E, 0x0432,
+    0x043E, 0x0440, 0x044F, 0x0442, 0x043F, 0x043E, 0x0440, 0x0443,
+    0x0441, 0x0441, 0x043A, 0x0438 ].pack('U*'),
+  'xn--b1abfaaepdrnnbgefbadotcwatmq2g4l'
+],
+
+'I' => [
+  [ 0x0050, 0x006F, 0x0072, 0x0071, 0x0075, 0x00E9, 0x006E, 0x006F,
+    0x0070, 0x0075, 0x0065, 0x0064, 0x0065, 0x006E, 0x0073, 0x0069,
+    0x006D, 0x0070, 0x006C, 0x0065, 0x006D, 0x0065, 0x006E, 0x0074,
+    0x0065, 0x0068, 0x0061, 0x0062, 0x006C, 0x0061, 0x0072, 0x0065,
+    0x006E, 0x0045, 0x0073, 0x0070, 0x0061, 0x00F1, 0x006F,
+    0x006C ].pack('U*'),
+  'xn--PorqunopuedensimplementehablarenEspaol-fmd56a'
+],
+
+'J' => [
+  [ 0x0054, 0x1EA1, 0x0069, 0x0073, 0x0061, 0x006F, 0x0068, 0x1ECD,
+    0x006B, 0x0068, 0x00F4, 0x006E, 0x0067, 0x0074, 0x0068, 0x1EC3,
+    0x0063, 0x0068, 0x1EC9, 0x006E, 0x00F3, 0x0069, 0x0074, 0x0069,
+    0x1EBF, 0x006E, 0x0067, 0x0056, 0x0069, 0x1EC7, 0x0074 ].pack('U*'),
+  'xn--TisaohkhngthchnitingVit-kjcr8268qyxafd2f1b9g'
+],
+
+'K' => [
+  [ 0x0033, 0x5E74, 0x0042, 0x7D44, 0x91D1, 0x516B, 0x5148,
+    0x751F ].pack('U*'),
+  'xn--3B-ww4c5e180e575a65lsy2b'
+],
+
+'L' => [
+  [ 0x5B89, 0x5BA4, 0x5948, 0x7F8E, 0x6075, 0x002D, 0x0077, 0x0069,
+    0x0074, 0x0068, 0x002D, 0x0053, 0x0055, 0x0050, 0x0045, 0x0052,
+    0x002D, 0x004D, 0x004F, 0x004E, 0x004B, 0x0045, 0x0059,
+    0x0053 ].pack('U*'),
+  'xn---with-SUPER-MONKEYS-pc58ag80a8qai00g7n9n'
+],
+
+'M' => [
+  [ 0x0048, 0x0065, 0x006C, 0x006C, 0x006F, 0x002D, 0x0041, 0x006E,
+    0x006F, 0x0074, 0x0068, 0x0065, 0x0072, 0x002D, 0x0057, 0x0061,
+    0x0079, 0x002D, 0x305D, 0x308C, 0x305E, 0x308C, 0x306E, 0x5834,
+    0x6240 ].pack('U*'),
+  'xn--Hello-Another-Way--fc4qua05auwb3674vfr0b'
+],
+
+'N' => [
+  [ 0x3072, 0x3068, 0x3064, 0x5C4B, 0x6839, 0x306E, 0x4E0B,
+    0x0032 ].pack('U*'),
+  'xn--2-u9tlzr9756bt3uc0v'
+],
+
+'O' => [
+  [ 0x004D, 0x0061, 0x006A, 0x0069, 0x3067, 0x004B, 0x006F, 0x0069,
+    0x3059, 0x308B, 0x0035, 0x79D2, 0x524D ].pack('U*'),
+  'xn--MajiKoi5-783gue6qz075azm5e'
+],
+
+'P' => [
+  [ 0x30D1, 0x30D5, 0x30A3, 0x30FC, 0x0064, 0x0065, 0x30EB, 0x30F3,
+    0x30D0 ].pack('U*'),
+  'xn--de-jg4avhby1noc0d'
+],
+
+'Q' => [
+  [ 0x305D, 0x306E, 0x30B9, 0x30D4, 0x30FC, 0x30C9, 0x3067 ].pack('U*'),
+  'xn--d9juau41awczczp'
+],
+
+'R' => [
+  [ 0x03B5, 0x03BB, 0x03BB, 0x03B7, 0x03BD, 0x03B9, 0x03BA,
+    0x03AC ].pack('U*'),
+  'xn--hxargifdar'
+],
+
+'S' => [
+  [ 0x0062, 0x006F, 0x006E, 0x0121, 0x0075, 0x0073, 0x0061, 0x0127,
+    0x0127, 0x0061 ].pack('U*'),
+  'xn--bonusaa-5bb1da'
+]
+}

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: simpleidn
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- "Morten M\xC3\xB8ller Riis"
+autorequire: 
+bindir: bin
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDRDCCAiygAwIBAgIBADANBgkqhkiG9w0BAQUFADBIMRowGAYDVQQDDBFtb3J0
+  ZW5tb2VsbGVycmlpczEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPy
+  LGQBGRYDY29tMB4XDTEwMTIwNjEzMTQ0NloXDTExMTIwNjEzMTQ0NlowSDEaMBgG
+  A1UEAwwRbW9ydGVubW9lbGxlcnJpaXMxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDET
+  MBEGCgmSJomT8ixkARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC
+  ggEBAKtTB3aT+LG2jPkb7hfGKTpyizK6MdOZmnt2xv3dlfA+aPnpliY3QccdJE3R
+  d9nNHOaQ1rrCuhBBpZu/q7nuGD8ZuMxPcqYriBzfeUv2Nsgc2XXKp9E0UIpkuxf2
+  Xkv26iWI7sYDzS0pCtu2of6Zw9GyVDVmB8Zf/xYQjDHDZZF6qNAVFTYvnAdl+qxb
+  1VQmOmzVszc33Ic9ZtJ896QjtBPUf82FIbEYz3uy75KwDfKHM4AS85wtWEFDL0Qt
+  FXGlxmq3DkNKmTPrfQ/+i2Oy8JB+OdY9ZMDsOKS17LJh+CsadQNXrp1WvZgxgo/1
+  HfsXb1m+lPZZIuN3WgKCDQMAxqECAwEAAaM5MDcwCQYDVR0TBAIwADALBgNVHQ8E
+  BAMCBLAwHQYDVR0OBBYEFFhp4owxGE1Gv7NPEdw7gyx6YfozMA0GCSqGSIb3DQEB
+  BQUAA4IBAQAr/Vq+06hYH60Tldjc2ikzFP4q3NbMjwEMarlZTnNFXsjjNJP6uzJu
+  8MV7ti/sslVKe82HUcrvFpMng2RsDHWt9YwPgWR/px8dyKoaZf1CjSf4O/qS317N
+  atSQvqSu+4cg5hpA87d0YIAeIEsEfWJuxmQ1jk/2Bsn/HQbLPE3vcGHF14H3U+O6
+  QYZoEtohq7CjW3fqKvQ7l2/fIFiMj8vTxdualWXX0RoF3QRKIuonpaYkDO+CrLoX
+  dDGWqJ1r5VRKULVNTLI6XwS0AbB93CaACN5AVFdhKOZNU1M0L4zyGWF9GMQfY74N
+  Pv5fihHPGcYA3voHCFu2/KGlBiF8TBQ6
+  -----END CERTIFICATE-----
+
+date: 2011-05-09 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: This gem allows easy conversion from punycode ACE strings to unicode UTF-8 strings and visa versa.
+email: mortenmoellerriis _AT_ gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- lib/simpleidn.rb
+files: 
+- LICENCE
+- Manifest
+- README.rdoc
+- Rakefile
+- lib/simpleidn.rb
+- simpleidn.gemspec
+- spec/idn.rb
+- spec/test_vectors.rb
+has_rdoc: true
+homepage: http://github.com/mmriis/simpleidn
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Simpleidn
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+requirements: []
+
+rubyforge_project: simpleidn
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: This gem allows easy conversion from punycode ACE strings to unicode UTF-8 strings and visa versa.
+test_files: []
+

metadata.gz.sig

@@ -0,0 +1,2 @@
+cq���#C~��r��rug�;* �?�
+��N'�Vp�J���]���:��7����e���KK��{��
�a�k۪��o��a�6�A��DK�W���e�^�Xr�D�}����.u�/��9�MG