husc 0.1.0

data/vendor/bundle/gems/unf-0.1.4/test/test_unf.rb

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+require 'helper'
+require 'pathname'
+
+class TestUNF < Test::Unit::TestCase
+  should "raise ArgumentError if an unknown normalization form is given" do
+    normalizer = UNF::Normalizer.instance
+    assert_raises(ArgumentError) { normalizer.normalize("が", :nfck) }
+  end
+
+  should "pass all tests bundled with the original unf" do
+    normalizer = UNF::Normalizer.instance
+    open(Pathname(__FILE__).dirname + 'normalization-test.txt', 'r:utf-8').each_slice(6) { |lines|
+      flunk "broken test file" if lines.size != 6 || lines.pop !~ /^$/
+      str, nfd, nfc, nfkd, nfkc = lines
+      assert nfd,  normalizer.normalize(str,  :nfd)
+      assert nfd,  normalizer.normalize(nfd,  :nfd)
+      assert nfd,  normalizer.normalize(nfc,  :nfd)
+      assert nfkd, normalizer.normalize(nfkc, :nfd)
+      assert nfkd, normalizer.normalize(nfkc, :nfd)
+
+      assert nfc,  normalizer.normalize(str,  :nfd)
+      assert nfc,  normalizer.normalize(nfd,  :nfc)
+      assert nfc,  normalizer.normalize(nfc,  :nfc)
+      assert nfkc, normalizer.normalize(nfkc, :nfc)
+      assert nfkc, normalizer.normalize(nfkd, :nfc)
+
+      assert nfkd, normalizer.normalize(str,  :nfkd)
+      assert nfkd, normalizer.normalize(nfd,  :nfkd)
+      assert nfkd, normalizer.normalize(nfc,  :nfkd)
+      assert nfkd, normalizer.normalize(nfkc, :nfkd)
+      assert nfkd, normalizer.normalize(nfkd, :nfkd)
+
+      assert nfkc, normalizer.normalize(str,  :nfkc)
+      assert nfkc, normalizer.normalize(nfd,  :nfkc)
+      assert nfkc, normalizer.normalize(nfc,  :nfkc)
+      assert nfkc, normalizer.normalize(nfkc, :nfkc)
+      assert nfkc, normalizer.normalize(nfkd, :nfkc)
+    }
+  end
+end

data/vendor/bundle/gems/unf-0.1.4/unf.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/unf/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "unf"
+  gem.version       = UNF::VERSION
+  gem.authors       = ["Akinori MUSHA"]
+  gem.email         = ["knu@idaemons.org"]
+  gem.description   = <<-'EOS'
+This is a wrapper library to bring Unicode Normalization Form support
+to Ruby/JRuby.
+  EOS
+  gem.summary       = %q{A wrapper library to bring Unicode Normalization Form support to Ruby/JRuby}
+  gem.homepage      = "https://github.com/knu/ruby-unf"
+  gem.platform      = defined?(JRUBY_VERSION) ? 'java' : Gem::Platform::RUBY
+  gem.license       = "2-clause BSDL"
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/.*\.rb})
+  gem.require_paths = ["lib"]
+  gem.extra_rdoc_files = ['README.md', 'LICENSE']
+
+  gem.add_dependency 'unf_ext', '>= 0' unless defined?(JRUBY_VERSION)
+
+  gem.add_development_dependency 'shoulda', [RUBY_VERSION < '1.9' ? '< 3.5.0' : '>= 0']
+  if RUBY_VERSION < '1.9'
+    # Cap dependency on activesupport with < 4.0 on behalf of
+    # shoulda-matchers to satisfy bundler.
+    gem.add_development_dependency 'activesupport', ['< 4.0']
+  end
+  gem.add_development_dependency 'bundler', '>= 1.2.0'
+  gem.add_development_dependency 'rake', '>= 0.9.2.2'
+  gem.add_development_dependency 'rdoc', '> 2.4.2'
+end

data/vendor/bundle/gems/unf_ext-0.0.7.6/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/vendor/bundle/gems/unf_ext-0.0.7.6/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+*.so
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+ext/*/Makefile
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/vendor/bundle/gems/unf_ext-0.0.7.6/.travis.yml

@@ -0,0 +1,24 @@
+language: ruby
+sudo: false
+rvm:
+  - 1.8.7
+  - ree
+  - 1.9.3
+  - 2.0
+  - 2.1
+  - 2.2
+  - 2.3
+  - 2.4
+  - 2.5
+  - ruby-head
+  - rbx-18mode
+  - rbx-19mode
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: rbx-18mode
+    - rvm: rbx-19mode
+before_install:
+  - gem install bundler
+before_script:
+  - rake compile

data/vendor/bundle/gems/unf_ext-0.0.7.6/CHANGELOG.md

@@ -0,0 +1,42 @@
+## 0.0.7.6 (2019-03-19)
+
+- Version bump just for adding Windows binaries for Ruby 2.6.
+
+## 0.0.7.5 (2018-02-06)
+
+- Version bump just for adding Windows binaries for Ruby 2.5.
+
+## 0.0.7.4 (2017-04-19)
+
+- Fix build on ARM and GCC 6 again.
+
+## 0.0.7.3 (2017-04-11)
+
+- Update the base Unicode version to 9.
+
+- Fix compile issues on ARM and GCC 6.
+
+## 0.0.7.2 (2016-02-01)
+
+- Version bump just for adding Windows binaries for Ruby 2.3.
+
+## 0.0.7.1 (2015-04-18)
+
+- Windows fat binary gems no longer require libstd++ to
+  run, which are statically linked.
+
+- Add a fat binary gem for x64-mingw32 (64bit Windows).
+
+- Windows fat binary gems now include binaries for Ruby up to 2.2.
+
+## 0.0.6 (2013-02-16)
+
+- Migrate from Jeweler to Bundler.
+
+## 0.0.5 (2012-05-30)
+
+- Fix a type error for strict compilers.
+
+## 0.0.4 (2011-12-08)
+
+- Release under the current name of `unf_ext`.

data/vendor/bundle/gems/unf_ext-0.0.7.6/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ruby-unf_ext.gemspec
+gemspec

data/vendor/bundle/gems/unf_ext-0.0.7.6/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2010 Takeru Ohta <phjgt308@gmail.com>
+Copyright (c) 2011-2018 Akinori MUSHA <knu@idaemons.org> (extended Ruby support)
+
+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/vendor/bundle/gems/unf_ext-0.0.7.6/README.md

@@ -0,0 +1,57 @@
+ruby-unf_ext
+============
+
+Synopsis
+--------
+
+* Unicode Normalization Form support library for CRuby
+
+Description
+-----------
+
+* Normalizes UTF-8 strings into and from NFC, NFD, NFKC or NFKD
+
+        # For bulk conversion
+        normalizer = UNF::Normalizer.new
+        a_bunch_of_strings.map! { |string|
+          normalizer.normalize(string, :nfc) #=> string in NFC
+        }
+
+* Compliant with Unicode 9.0
+
+Requirement
+-----------
+
+* Ruby 1.8.7+, 1.9.2+
+
+* C++ compiler and libstdc++
+
+Installation
+------------
+
+	gem install unf_ext
+
+Or:
+
+    ruby extconf.rb && make && make install
+
+Development Resources
+---------------------
+
+* https://github.com/sile/unf
+
+    For issues regarding files under the directory `unf`, please
+    contact this upstream.
+
+* https://github.com/knu/ruby-unf_ext
+
+    The development site and the repository.
+
+License
+-------
+
+Copyright (c) 2010-2017 Takeru Ohta
+Copyright (c) 2011-2018 Akinori MUSHA
+
+Licensed under the MIT license.
+See `LICENSE` for details.

data/vendor/bundle/gems/unf_ext-0.0.7.6/Rakefile

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+require 'bundler/gem_tasks'
+
+gemspec = Bundler::GemHelper.gemspec
+
+require 'rake/extensiontask'
+Rake::ExtensionTask.new('unf_ext', gemspec) do |ext|
+  ext.cross_compile = true
+  ext.cross_platform = %w[x86-mingw32 x64-mingw32]
+  ext.cross_config_options << '--with-ldflags="-static-libgcc"' << '--with-static-libstdc++'
+end
+
+namespace :gem do
+  task :native do
+    require 'rake_compiler_dock'
+    RakeCompilerDock.sh "(bundle --local --quiet || bundle) && rake cross native gem"
+  end
+
+  task :all => [:build, :native]
+end
+
+task :gems => :'gem:all'
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.test_files = gemspec.test_files
+  test.verbose = true
+end
+
+task :default => :test

data/vendor/bundle/gems/unf_ext-0.0.7.6/ext/unf_ext/extconf.rb

@@ -0,0 +1,50 @@
+require 'mkmf'
+
+if with_config('static-libstdc++')
+  $LDFLAGS << ' ' << `#{CONFIG['CC']} -print-file-name=libstdc++.a`.chomp
+else
+  have_library('stdc++')
+
+  case RbConfig::CONFIG['host_os']
+  when /solaris(!?2.11)/
+    # Do a little trickery here to enable C++ standard on Solaris 11 if found.
+    # This also forces 64bit compilation mode.
+    $CXX = CONFIG['CXX']
+    $CXX << ' ' << '-m64'
+    $CFLAGS = CONFIG['CFLAGS'].gsub(/-std=c99/, '')
+    $CFLAGS << ' ' << '-m64 -std=c++11'
+    $CPPFLAGS = CONFIG['CFLAGS'].gsub(/-std=c99/, '')
+    $CPPFLAGS << ' ' << '-m64 -std=c++11'
+    $CXXFLAGS = CONFIG['CFLAGS'].gsub(/-std=c99/, '')
+    $CXXFLAGS << ' ' << '-m64 -std=c++11'
+  when /aix/
+    # Compiler flags necessary on AIX.
+    # rubocop:disable Style/GlobalVars
+    $CFLAGS << ' ' << '-D_ALL_SOURCE=1'
+    $CPPFLAGS << ' ' << '-D_ALL_SOURCE=1'
+    $CXXFLAGS << ' ' << '-D_ALL_SOURCE=1'
+  end
+end
+
+create_makefile 'unf_ext'
+
+unless CONFIG['CXX']
+  case CONFIG['CC']
+  when %r{((?:.*[-/])?)gcc([-0-9.]*)$}
+    cxx = $1 + 'g++' + $2
+  when %r{((?:.*[-/])?)clang([-0-9.]*)$}
+    cxx = $1 + 'clang++' + $2
+  else
+    cxx = CONFIG['CC']
+  end
+
+  warn "CXX is automatically set to #{cxx}"
+
+  new_mf = <<-EOF << File.read('Makefile')
+CXX=#{cxx}
+  EOF
+
+  File.open('Makefile', 'w') { |mf|
+    mf.print new_mf
+  }
+end

data/vendor/bundle/gems/unf_ext-0.0.7.6/ext/unf_ext/unf.cc

@@ -0,0 +1,75 @@
+#include "unf/normalizer.hh"
+
+#include <ruby.h>
+#if defined(HAVE_RUBY_ENCODING_H)
+#include <ruby/encoding.h>
+#endif
+
+extern "C" {
+  VALUE unf_allocate(VALUE klass);
+  VALUE unf_initialize(VALUE self);
+  void unf_delete(UNF::Normalizer* ptr);
+  VALUE unf_normalize(VALUE self, VALUE source, VALUE normalization_form);
+
+  ID FORM_NFD;
+  ID FORM_NFC;
+  ID FORM_NFKD;
+  ID FORM_NFKC;
+
+  void Init_unf_ext() {
+    VALUE mdl = rb_define_module("UNF");
+
+    VALUE cls = rb_define_class_under(mdl, "Normalizer", rb_cObject);
+    rb_define_alloc_func(cls, unf_allocate);
+    rb_define_method(cls, "initialize", (VALUE (*)(...))unf_initialize, 0);
+    rb_define_method(cls, "normalize", (VALUE (*)(...))unf_normalize, 2);
+
+    FORM_NFD = rb_intern("nfd");
+    FORM_NFC = rb_intern("nfc");
+    FORM_NFKD= rb_intern("nfkd");
+    FORM_NFKC= rb_intern("nfkc");
+  }
+
+
+  VALUE unf_allocate(VALUE klass) {
+    UNF::Normalizer* ptr;
+    VALUE obj = Data_Make_Struct(klass, UNF::Normalizer, NULL, unf_delete, ptr);
+    new ((void*)ptr) UNF::Normalizer;
+    return obj;
+  }
+
+  VALUE unf_initialize(VALUE self) {
+    return self;
+  }
+
+  void unf_delete(UNF::Normalizer* ptr) {
+    ptr->~Normalizer();
+    ruby_xfree(ptr);
+  }
+
+  VALUE unf_normalize(VALUE self, VALUE source, VALUE normalization_form) {
+    UNF::Normalizer* ptr;
+    Data_Get_Struct(self, UNF::Normalizer, ptr);
+
+    const char* src = StringValueCStr(source);
+    const char* rlt;
+    ID form_id = SYM2ID(normalization_form);
+
+    if(form_id == FORM_NFD)
+      rlt = ptr->normalize(src, UNF::Normalizer::FORM_NFD);
+    else if(form_id == FORM_NFC)
+      rlt = ptr->normalize(src, UNF::Normalizer::FORM_NFC);
+    else if(form_id == FORM_NFKD)
+      rlt = ptr->normalize(src, UNF::Normalizer::FORM_NFKD);
+    else if(form_id == FORM_NFKC)
+      rlt = ptr->normalize(src, UNF::Normalizer::FORM_NFKC);
+    else
+      rb_raise(rb_eArgError, "Specified Normalization-Form is unknown. Please select one from among :nfc, :nfd, :nfkc, :nfkd.");
+
+#if defined(HAVE_RUBY_ENCODING_H)
+    return rb_enc_str_new(rlt, strlen(rlt), rb_utf8_encoding());
+#else
+    return rb_str_new2(rlt);
+#endif
+  }
+}

data/vendor/bundle/gems/unf_ext-0.0.7.6/ext/unf_ext/unf/normalizer.hh

@@ -0,0 +1,139 @@
+#ifndef UNF_NORMALIZER_HH
+#define UNF_NORMALIZER_HH
+
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <cstring>
+#include "trie/searcher.hh"
+#include "trie/char_stream.hh"
+#include "table.hh"
+#include "util.hh"
+
+namespace UNF {
+  class Normalizer {
+  public:
+    enum Form { FORM_NFD, FORM_NFC, FORM_NFKD, FORM_NFKC };
+
+  public:
+    Normalizer()
+      : nf_d(TABLE::NODES, TABLE::CANONICAL_DECOM_ROOT, (const char *)TABLE::STRINGS),
+	nf_kd(TABLE::NODES, TABLE::COMPATIBILITY_DECOM_ROOT, (const char *)TABLE::STRINGS),
+	nf_c(TABLE::NODES, TABLE::CANONICAL_COM_ROOT, (const char *)TABLE::STRINGS),
+	nf_c_qc(TABLE::NODES, TABLE::NFC_ILLEGAL_ROOT),
+	nf_kc_qc(TABLE::NODES, TABLE::NFKC_ILLEGAL_ROOT),
+	ccc(TABLE::NODES, TABLE::CANONICAL_CLASS_ROOT)
+    {}
+
+    const char* normalize(const char* src, Form form) {
+      switch(form) {
+      case FORM_NFD:  return nfd(src);
+      case FORM_NFC:  return nfc(src);
+      case FORM_NFKD: return nfkd(src);
+      case FORM_NFKC: return nfkc(src);
+      default:        return src;
+      }
+    }
+    const char* nfd(const char* src)  { return decompose(src, nf_d); }
+    const char* nfkd(const char* src) { return decompose(src, nf_kd); }
+    const char* nfc(const char* src)  { return compose(src, nf_c_qc, nf_d); }
+    const char* nfkc(const char* src) { return compose(src, nf_kc_qc, nf_kd); }
+
+  private:
+    const char* decompose(const char* src, const Trie::NormalizationForm& nf) {
+      const char* beg = next_invalid_char(src, nf);
+      if(*beg=='\0')
+	return src;
+      
+      buffer.assign(src, beg);
+      do {
+	const char* end = next_valid_starter(beg, nf);
+	decompose_one(beg, end, nf, buffer);
+	beg = next_invalid_char(end, nf);
+	buffer.append(end, beg);
+      } while(*beg!='\0');
+      
+      return buffer.c_str();      
+    }
+
+    void decompose_one(const char* beg, const char* end, const Trie::NormalizationForm& nf, std::string& buf) {
+      unsigned last = buf.size();
+      nf.decompose(Trie::RangeCharStream(beg,end), buf);
+      char* bufbeg = const_cast<char*>(buf.data());
+      canonical_combining_class_ordering(bufbeg+last, bufbeg+buf.size());
+    }
+
+    const char* compose(const char* src, const Trie::NormalizationForm& nf, const Trie::NormalizationForm& nf_decomp) {
+      const char* beg = next_invalid_char(src, nf);
+      if(*beg=='\0')
+	return src;
+      
+      buffer.assign(src, beg);
+      while(*beg!='\0') {
+	const char* end = next_valid_starter(beg, nf);
+	buffer2.clear();
+	decompose_one(beg, end, nf_decomp, buffer2);
+	end = compose_one(buffer2.c_str(), end, buffer);
+	beg = next_invalid_char(end, nf);
+	buffer.append(end, beg);
+      }
+
+      return buffer.c_str();      
+    }
+
+    const char* compose_one(const char* starter, const char* rest_starter, std::string& buf) {
+      Trie::CharStreamForComposition in(starter, rest_starter, canonical_classes, buffer3);
+      while(in.within_first())
+	nf_c.compose(in, buf);
+      return in.cur();
+    }
+
+    void canonical_combining_class_ordering(char* beg, const char* end) {
+      canonical_classes.assign(end-beg+1, 0); // +1 is for sentinel value
+      ccc.sort(beg, canonical_classes);
+    }
+
+    const char* next_invalid_char(const char* src, const Trie::NormalizationForm& nf) const {
+      int last_canonical_class = 0;
+      const char* cur = Util::nearest_utf8_char_start_point(src);
+      const char* starter = cur;
+      
+      for(; *cur != '\0'; cur = Util::nearest_utf8_char_start_point(cur+1)) {
+	int canonical_class = ccc.get_class(cur);
+	if(last_canonical_class > canonical_class && canonical_class != 0)
+	  return starter;
+
+	if(nf.quick_check(cur)==false)
+	  return starter;
+
+	if(canonical_class==0)
+	  starter=cur;
+
+	last_canonical_class = canonical_class;
+      }
+      return cur;
+    }
+
+    const char* next_valid_starter(const char* src, const Trie::NormalizationForm& nf) const {
+      const char* cur = Util::nearest_utf8_char_start_point(src+1);
+      while(ccc.get_class(cur)!=0 || nf.quick_check(cur)==false)
+	cur = Util::nearest_utf8_char_start_point(cur+1);
+      return cur;
+    }
+
+  private:
+    const Trie::NormalizationForm nf_d;
+    const Trie::NormalizationForm nf_kd;
+    const Trie::NormalizationForm nf_c;
+    const Trie::NormalizationForm nf_c_qc;
+    const Trie::NormalizationForm nf_kc_qc;
+    const Trie::CanonicalCombiningClass ccc;
+    
+    std::string buffer;
+    std::string buffer2;
+    std::string buffer3;
+    std::vector<unsigned char> canonical_classes;
+  };
+}
+
+#endif