stringprep 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 53c5549dcea0b8123d552f5560d3f73d0fb9ae3b
+  data.tar.gz: e46aac94f3974548ecbc06b7a4cc08b7367292e5
+SHA512:
+  metadata.gz: 0362f7124c807224bd07d0a39d7b9aefdddecc8e5eb8fed54871059308ff445b58f3cd7f7829543ce6d1f79f587addc05a8d88437b967abf5e3cdd98c6439d03
+  data.tar.gz: 9f7ab163f277f67c1b92952c4a554ba7580043f6ae5cfbad1eec89b0f5aa0cbdfd772e0559884b8e6d8af1a72d2f041b9868b141cddd77ff03b619d281e82863

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/README.md

@@ -0,0 +1,56 @@
+[![Build Status](https://travis-ci.org/steakknife/stringprep.svg)](https://travis-ci.org/steakknife/stringprep)
+
+# Stringprep
+
+Pure Ruby implementation
+
+## Usage
+
+```ruby
+require 'stringprep'
+
+# code can be a 1 character string OR an Integer,
+# and it will return the same type that was passed
+
+Stringprep.in_a1 "\u1234"      # code in Table A.1 ?
+# => false
+# or
+Stringprep.in_a1 0x1234
+# => false
+
+Stringprep.in_c11 "\u1234"     # code in Table C.1.1 ?
+# => false
+
+Stringprep.in_c21_c22 "\u1234" # code in Table C.2.1 or C.2.2 ?
+# => false
+
+Stringprep.map_b2 "\u1234"     # map Table B.2
+# => "ሴ"
+```
+
+## Installation
+
+### Signed gem
+
+    [sudo] gem cert --add <(curl -L https://raw.githubusercontent.com/steakknife/stringprep/master/gem-public_cert.pem) # adds my cert (do once)
+    [sudo] gem install stringprep -P HighSecurity
+
+### Bundler
+
+    gem 'stringprep'
+
+## Contributors
+
+! Your Name Here ! (in neon lights, top of the bill even)
+
+## Author
+
+Barry Allard
+
+## License
+
+MIT
+
+## References
+
+- Stringprep [rfc3494](http://tools.ietf.org/html/rfc3494)

data/Rakefile

@@ -0,0 +1,25 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  fail 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+fail 'Gemfile missing' unless defined? Bundler::GemHelper
+Bundler::GemHelper.install_tasks
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Stringprep'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Run RSpec specs'
+task :spec do
+  ARGV.delete 'spec'
+  sh "bundle exec rspec #{ARGV.join ' '}"
+end
+
+task default: :spec

data/lib/stringprep/rfc3454.rb

@@ -0,0 +1,62 @@
+autoload :FileUtils, 'fileutils'
+autoload :JSON,      'json'
+
+module Stringprep
+  module Rfc3454
+
+    # Loads code point tables from data/rfc3454.json, creates it if it does not exist
+    def self.tables
+      tries = READ_RETRIES
+      @tables ||= begin
+        raw_read_tables
+      rescue Errno::ENOENT
+        write_tables(parse_rfc_txt)
+        retry if (tries -= 1) > 0
+        raise
+      end
+    end
+
+  private
+
+    TABLES_DATA_DIR = 'data'
+            RFC_DIR = 'data'
+    TABLES_FILE = File.join(TABLES_DATA_DIR, 'rfc3454.json')
+    RFC_FILE = File.join(TABLES_DATA_DIR, 'rfc3454.txt')
+
+
+    START_TABLE = /^[[:space:]]*----- Start Table ([^-]*) -----[[:space:]]*$/
+    END_TABLE = /^[[:space:]]*----- End Table ([^-]*) -----[[:space:]]*$/
+    DATA_LINE = /[[:xdigit:]]{2}/
+    SKIP_LINE = /Standards Track|RFC /
+    READ_RETRIES = 4
+
+    def self.raw_read_tables
+      JSON.parse(File.read(TABLES_FILE))
+    end
+
+    def self.parse_rfc_txt
+      tables = {}
+      table_name = nil
+      started = false
+      File.readlines(RFC_FILE).each do |line|
+        if line =~ START_TABLE
+          started = true
+          table_name = $1.gsub('.', '').downcase
+          tables[table_name] = []
+        elsif line =~ END_TABLE
+          started = false
+        elsif started && line =~ DATA_LINE && line !~ SKIP_LINE
+          tables[table_name] << line.strip
+        end
+      end
+      tables
+    end
+
+    def self.write_tables(tables)
+      FileUtils.mkdir_p TABLES_DATA_DIR
+      File.open(TABLES_FILE, 'w') { |f|
+        f.write(JSON.generate(tables))
+      }
+    end
+  end
+end

data/lib/stringprep/table/base.rb

@@ -0,0 +1,12 @@
+module Stringprep
+  module Table
+    class Base
+      private_class_method :new
+      def self.create_read_only(*args, &block)
+        x = new(*args, &block)
+        x.freeze
+        x
+      end
+    end
+  end
+end

data/lib/stringprep/table/in.rb

@@ -0,0 +1,36 @@
+require 'stringprep/table/base'
+
+module Stringprep
+  module Table
+    class In < Base
+      def initialize(data)
+        @code_list = In.parse(data)
+      end
+
+      def include?(code)
+        if code.is_a?(String)
+          unpacked = code.unpack('U*')
+          raise ArgumentError, 'Only one character is allowed' unless unpacked.length == 1
+          code = unpacked[0]
+        end
+        return unless code.class < Integer
+        @code_list.any? { |x| (x.is_a?(Range)) ? x.include?(code) : x == code }
+      end
+
+    private
+
+      # returns an Array
+      def self.parse(data)
+        data.map { |line|
+          if line =~ /([[:xdigit:]]+)-([[:xdigit:]]+)/ 
+            $1.to_i(16) .. $2.to_i(16)
+          elsif line =~ /([[:xdigit:]]+)/ 
+            $1.to_i(16)
+          else
+            raise "Parse error '#{data}'"
+          end
+        }
+      end
+    end
+  end
+end

data/lib/stringprep/table/map.rb

@@ -0,0 +1,53 @@
+require 'stringprep/table/base'
+
+module Stringprep
+  module Table
+    class Map < Base
+      def initialize(data)
+        @codes = Map.parse(data)
+      end
+
+      def map(code)
+        if string_char = ((code.is_a?(String)) && (code.length == 1))
+          code = code.unpack('U')[0]
+        end
+        return unless code.class < Integer
+        new_code = @codes[code] || code
+        if string_char
+          if new_code.is_a?(Array)
+            new_code = new_code.pack('U*')
+          else
+            new_code = [new_code].pack('U') if !new_code.nil?
+          end
+        end
+        new_code
+      end
+
+    private
+      def self.parse(data)
+        Hash[ data.map { |line|
+          parse_line(line).tap { |x|
+            raise "Parse error '#{line}'" if x.nil?
+          }
+        }]
+      end
+
+      def self.parse_line(line)
+        parse_map_to_nothing(line) || parse_case_map(line)
+      end
+
+      def self.parse_map_to_nothing(line)
+        if line =~ /([[:xdigit:]]+);[[:space:]]*;[[:space:]]*/
+          [ $1.to_i(16), nil ]
+        end
+      end
+
+      def self.parse_case_map(line)
+        if r = line.match(/([[:xdigit:]]+);(?:[[:space:]]*([[:xdigit:]]+))+;[[:space:]]*/)
+          [ r[1].to_i(16), r[2..-1].map { |x| x.to_i(16) } ]
+        end
+      end
+    end
+  end
+end
+

data/lib/stringprep/version.rb

@@ -0,0 +1,3 @@
+module Stringprep
+  VERSION = '0.0.1'
+end

data/lib/stringprep.rb

@@ -0,0 +1,124 @@
+module Stringprep
+  extend self
+
+  # Determine whether code is in tableA.1 (Unassigned code points in Unicode 3.2).
+  def in_a1(code)
+    @a1 ||= Table::In.create_read_only(Rfc3454.tables['a1'])
+    @a1.include?(code)
+  end
+
+  # Determine whether code is in tableB.1 (Commonly mapped to nothing).
+  def in_b1(code)
+    @b1 ||= Table::In.create_read_only(Rfc3454.tables['b1'])
+    @b1.include?(code)
+  end
+
+  # Return the mapped value for code according to tableB.2 (Mapping for case-folding used with NFKC).
+  def map_b2(code)
+    @b2 ||= Table::Map.create_read_only(Rfc3454.tables['b2'])
+    @b2.map(code)
+  end
+
+  # Return the mapped value for code according to tableB.3 (Mapping for case-folding used with no normalization).
+  def map_b3(code)
+    @b3 ||= Table::Map.create_read_only(Rfc3454.tables['b3'])
+    @b3.map(code)
+  end
+
+  # Determine whether code is in tableC.1.1 (ASCII space characters).
+  def in_c11(code)
+    @c11 ||= Table::In.create_read_only(Rfc3454.tables['c11'])
+    @c11.include? code
+  end
+
+  # Determine whether code is in tableC.1.2 (Non-ASCII space characters).
+  def in_c12(code)
+    @c12 ||= Table::In.create_read_only(Rfc3454.tables['c12'])
+    @c12.include? code
+  end
+
+  # Determine whether code is in tableC.1 (Space characters, union of C.1.1 and C.1.2).
+  def in_c11_c12(code)
+    in_c11(code) || in_c12(code)
+  end
+
+  # Determine whether code is in tableC.2.1 (ASCII control characters).
+  def in_c21(code)
+    @c21 ||= Table::In.create_read_only(Rfc3454.tables['c21'])
+    @c21.include? code
+  end
+
+  # Determine whether code is in tableC.2.2 (Non-ASCII control characters).
+  def in_c22(code)
+    @c22 ||= Table::In.create_read_only(Rfc3454.tables['c22'])
+    @c22.include? code
+  end
+
+  # Determine whether code is in tableC.2 (Control characters, union of C.2.1 and C.2.2).
+  def in_c21_c22(code)
+    in_c21(code) || in_c22(code)
+  end
+
+  # Determine whether code is in tableC.3 (Private use).
+  def in_c3(code)
+    @c3 ||= Table::In.create_read_only(Rfc3454.tables['c3'])
+    @c3.include?(code)
+  end
+
+  # Determine whether code is in tableC.4 (Non-character code points).
+  def in_c4(code)
+    @c4 ||= Table::In.create_read_only(Rfc3454.tables['c4'])
+    @c4.include?(code)
+  end
+
+  # Determine whether code is in tableC.5 (Surrogate codes).
+  def in_c5(code)
+    @c5 ||= Table::In.create_read_only(Rfc3454.tables['c5'])
+    @c5.include?(code)
+  end
+
+  # Determine whether code is in tableC.6 (Inappropriate for plain text).
+  def in_c6(code)
+    @c6 ||= Table::In.create_read_only(Rfc3454.tables['c6'])
+    @c6.include?(code)
+  end
+
+  # Determine whether code is in tableC.7 (Inappropriate for canonical representation).
+  def in_c7(code)
+    @c7 ||= Table::In.create_read_only(Rfc3454.tables['c7'])
+    @c7.include?(code)
+  end
+
+  # Determine whether code is in tableC.8 (Change display properties or are deprecated).
+  def in_c8(code)
+    @c8 ||= Table::In.create_read_only(Rfc3454.tables['c8'])
+    @c8.include?(code)
+  end
+
+  # Determine whether code is in tableC.9 (Tagging characters).
+  def in_c9(code)
+    @c9 ||= Table::In.create_read_only(Rfc3454.tables['c9'])
+    @c9.include?(code)
+  end
+
+  # Determine whether code is in tableD.1 (Characters with bidirectional property “R” or “AL”).
+  def in_d1(code)
+    @d1 ||= Table::In.create_read_only(Rfc3454.tables['d1'])
+    @d1.include?(code)
+  end
+
+  # Determine whether code is in tableD.2 (Characters with bidirectional property “L”).
+  def in_d2(code)
+    @d2 ||= Table::In.create_read_only(Rfc3454.tables['d2'])
+    @d2.include?(code)
+  end
+
+private
+
+  autoload :Rfc3454, 'stringprep/rfc3454'
+
+  module Table
+    autoload :In, 'stringprep/table/in'
+    autoload :Map, 'stringprep/table/map'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/stringprep_spec.rb

@@ -0,0 +1,96 @@
+require 'stringprep'
+
+# thank you Python for your test cases ;)
+# adapted from test_stringprep.py
+
+describe Stringprep do
+  describe '.in_a1' do
+    it { expect(Stringprep::in_a1("\u0221")).to be_true }
+    it { expect(Stringprep::in_a1("\u0222")).to be_false }
+  end
+
+  describe '.in_b1' do
+    it { expect(Stringprep::in_b1("\u00ad")).to be_true }
+    it { expect(Stringprep::in_b1("\u00ae")).to be_false }
+  end
+
+  describe '.map_b3' do
+    it { expect(Stringprep::map_b2("\u0041")).to eq("\u0061") }
+    it { expect(Stringprep::map_b2("\u0061")).to eq("\u0061") }
+  end
+
+  describe '.in_c11' do
+    it { expect(Stringprep::in_c11("\u0020")).to be_true }
+    it { expect(Stringprep::in_c11("\u0021")).to be_false }
+  end
+
+  describe '.in_c12' do
+    it { expect(Stringprep::in_c12("\u00a0")).to be_true }
+    it { expect(Stringprep::in_c12("\u00a1")).to be_false }
+  end
+
+  describe '.in_c11_c12' do
+    it { expect(Stringprep::in_c11_c12("\u00a0")).to be_true }
+    it { expect(Stringprep::in_c11_c12("\u00a1")).to be_false }
+  end
+
+  describe '.in_c21' do
+    it { expect(Stringprep::in_c21("\u001f")).to be_true }
+    it { expect(Stringprep::in_c21("\u0020")).to be_false }
+  end
+
+  describe '.in_c22' do
+    it { expect(Stringprep::in_c22("\u009f")).to be_true }
+    it { expect(Stringprep::in_c22("\u00a0")).to be_false }
+  end
+
+  describe '.in_c21_c22' do
+    it { expect(Stringprep::in_c21_c22("\u009f")).to be_true }
+    it { expect(Stringprep::in_c21_c22("\u00a0")).to be_false }
+  end
+
+  describe '.in_c3' do
+    it { expect(Stringprep::in_c3("\ue000")).to be_true }
+    it { expect(Stringprep::in_c3("\uf900")).to be_false }
+  end
+
+  describe '.in_c4' do
+    it { expect(Stringprep::in_c4("\uffff")).to be_true }
+    it { expect(Stringprep::in_c4("\u0000")).to be_false }
+  end
+
+  describe '.in_c5' do
+    it { expect(Stringprep::in_c5("\ud800")).to be_true }
+    it { expect(Stringprep::in_c5("\ud7ff")).to be_false }
+  end
+
+  describe '.in_c6' do
+    it { expect(Stringprep::in_c6("\ufff9")).to be_true }
+    it { expect(Stringprep::in_c6("\ufffe")).to be_false }
+  end
+
+  describe '.in_c7' do
+    it { expect(Stringprep::in_c7("\u2ff0")).to be_true }
+    it { expect(Stringprep::in_c7("\u2ffc")).to be_false }
+  end
+
+  describe '.in_c8' do
+    it { expect(Stringprep::in_c8("\u0340")).to be_true }
+    it { expect(Stringprep::in_c8("\u0342")).to be_false }
+  end
+
+  describe '.in_c9' do
+    it { expect(Stringprep::in_c9("\u{e0001}")).to be_true }
+    it { expect(Stringprep::in_c9("\u{e0002}")).to be_false }
+  end
+
+  describe '.in_d1' do
+    it { expect(Stringprep::in_d1("\u05be")).to be_true }
+    it { expect(Stringprep::in_d1("\u05bf")).to be_false }
+  end
+
+  describe '.in_d2' do
+    it { expect(Stringprep::in_d2("\u0041")).to be_true }
+    it { expect(Stringprep::in_d2("\u0040")).to be_false }
+  end
+end

data.tar.gz.sig

@@ -0,0 +1 @@
+}�C�	���=�<J��4�ǟ��<�����i��:$��zf��3QJ>�h�J����3V���`��;2M/��1�#������~@8�(@9����0@q	�׵��pR���:��5%���&#���$�z��"~W��������ˑy�L�/��a���

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: stringprep
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Barry Allard
+autorequire: 
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDOjCCAiKgAwIBAgIBADANBgkqhkiG9w0BAQUFADBDMRUwEwYDVQQDDAxiYXJy
+  eS5hbGxhcmQxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixkARkW
+  A2NvbTAeFw0xMzA0MDgwMTI0NThaFw0xNDA0MDgwMTI0NThaMEMxFTATBgNVBAMM
+  DGJhcnJ5LmFsbGFyZDEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPy
+  LGQBGRYDY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvDcmlxJH
+  eySiUBcYTqGXaWETRVYmgfGwWRPZzqkmBdIVZkbk9SWxseiHWIReFWjP438UoUTs
+  J17G/HuQb0SmjPCMZy8967Fb2wqs+QRbcmpnmtYA1vilgC2CIzntFOFLSA2KpfZH
+  dJSsg6aaXqwS4/KJxK6ooDsp+iR6zGTINwkdUt4ktpqgCHz1VYuzvii2slnazbm4
+  cQUi/wWIynHyzzdrPvDhGgaZm161MYHidCtV+wzqwjeVeFsyQwCFVEkrD/0G98ho
+  Gti8vB6Xj6VjO3n+kh/KlYZgmM7SWauLpo+2RGlIYVYdpQQWGwhMEmvSgBxjfX4c
+  unDFxO1ZAQIRBQIDAQABozkwNzAJBgNVHRMEAjAAMB0GA1UdDgQWBBS+Kk7ypi9u
+  kFUcaqJlpaKO7eWiUTALBgNVHQ8EBAMCBLAwDQYJKoZIhvcNAQEFBQADggEBALie
+  YCNeW9EIQ/j8+2emMm0484JVtycOqPyIu5UALtsU42En392HVOZ6oEA/rh2KFRvq
+  dcDwcJPI/u7PzWp9TNp81PTShtHMtSs7Wv1UsC04vQ9b6XBEomWbbzoxxgzyjP7l
+  ZV4L5HzmX0nDOSEFJyYkqbwgYjIoldg2TMlw2BeoVqGm7Gx1ljXKb2Kg5iasyDpI
+  C/gAiGBIAX7FxyIXmjZq38xWBOxyGF3NFL/W6z+vhJg81HGdNBCpIdwrQ/eXOjba
+  VqwwfY+Ms3gcCHSERG1X4AFW1zesX+UWcTCwVLtAsuRWQhC8odDSVDWzUfkZmOQt
+  ViIxU1ZphInql7L5g34=
+  -----END CERTIFICATE-----
+date: 2014-04-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: should_not
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+description: Pure Ruby Stringprep implementation (RFC 3494)
+email:
+- barry.allard@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- README.md
+- Rakefile
+- lib/stringprep.rb
+- lib/stringprep/rfc3454.rb
+- lib/stringprep/table/base.rb
+- lib/stringprep/table/in.rb
+- lib/stringprep/table/map.rb
+- lib/stringprep/version.rb
+- spec/spec_helper.rb
+- spec/stringprep_spec.rb
+homepage: https://github.com/steakknife/stringprep
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/steakknife/stringprep.git
+  project_uri: https://github.com/steakknife/stringprep
+  bug_tracker_uri: https://github.com/steakknife/stringprep/issues
+  wiki_uri: https://github.com/steakknife/stringprep/wiki
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Stringprep
+test_files:
+- spec/spec_helper.rb
+- spec/stringprep_spec.rb
+- ".rspec"
+has_rdoc: 

metadata.gz.sig

@@ -0,0 +1,3 @@
+n��
+�\�,�,}���x��G�,yb|��Flmנ��.�䱓�;��Z� 6I!��qn��7~�J�������.ŴcD
\��j�sB���\��������s�`�x�eƻ��pg��M���r�� �8���.��b�DW�t���C���V�#�I�"2��*J�9H���W�g���^t�R�Ӕ��nj���tF���,0I�wf�bqNq
+bM<��Lغ7�>ˈ��:~����h*6��]/!�-�@�l