icu 0.10.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88c426a1c84d5ad423a04c26d3d741129a1bac3b
-  data.tar.gz: 292b9ac2acfc8e71165ba4b060022691cbe9a8b3
+  metadata.gz: 0d1207d28f79754afd8b68f7ecf9d298d62f4aab
+  data.tar.gz: ce0b6e3e1fcc8ca6bdac3091ddbda9111f3cb99b
 SHA512:
-  metadata.gz: 9647d17ce98b27ed7157c4be7a43d0601d5b37473d1ad3efd0d7f67d2da9329a63d08c06f975884166973f42f93405a32d0adb6662e4ed1508a8c7d43076efbd
-  data.tar.gz: 76fc785f28a3a5681a89087c968fcbd1a8007ed5a2fe1925501c7d248fd6cb50a86ccad6369cb4e8599d6ce75bfe859a5f59ef0d6ecc764bb5d38bce91b401d6
+  metadata.gz: 9acb80e891bd190cfde5b4a877723d97c31c25ea30004c70f5cb8232c93ffd9c3d413d57ef08d01713068352c2163906cd79bbc2efea4f572ac558b1b09763a8
+  data.tar.gz: f3e384258d81c4e2435797cb58754b471535ae90bd6b7bcaee67177023ea8a20fa1e4eab21b24c687e0b910a93a41ceed902a9d43a4b59c0ceea114cd9980fad

data/ext/icu/extconf.rb

@@ -85,14 +85,14 @@ else
 
       if static_p
         self.configure_options += [
-            "--enable-shared",
             "--enable-static",
+            "--enable-shared",
             "--disable-renaming"
         ]
         env['CFLAGS'] = "-fPIC #{env['CFLAGS']}"
         env['CPPFLAGS'] = "-DU_CHARSET_IS_UTF8=1 -DU_USING_ICU_NAMESPACE=0 -DU_STATIC_IMPLEMENTATION #{env['CPPFLAGS']}"
         env['CXXFLAGS'] = "-fPIC -fno-exceptions #{env['CXXFLAGS']}"
-        env['LDFLAGS'] = "-fPIC -static-libstdc++ #{env['CFLAGS']}"
+        env['LDFLAGS'] = "-static-libstdc++ #{env['CFLAGS']}"
       else
         self.configure_options += [
             "--enable-shared",
@@ -167,7 +167,6 @@ If you are using Bundler, tell it to use the option:
 
   static_p = enable_config('static', true) or
       message "Static linking is disabled.\n"
-  recipes = []
 
   libicu_recipe = ICURecipe.new("libicu", "59.1", static_p) do |recipe|
     recipe.files = [{
@@ -191,9 +190,8 @@ If you are using Bundler, tell it to use the option:
                         # Primary key fingerprint: BA90 283A 60D6 7BA0 DD91  0A89 3932 080F 4FB4 19E3
                     }]
   end
-  recipes.push libicu_recipe
 
-  recipes.each do |recipe|
+  libicu_recipe.tap do |recipe|
     checkpoint = "#{recipe.target}/#{recipe.name}-#{recipe.version}-#{recipe.host}.installed"
     unless File.exist?(checkpoint)
       recipe.cook
@@ -203,40 +201,38 @@ If you are using Bundler, tell it to use the option:
     recipe.activate
   end
 
-  $libs = $libs.shellsplit.tap do |libs|
-    [libicu_recipe].each do |recipe|
-      libname = recipe.name[/\Alib(.+)\z/, 1]
-      # TODO: build with pkg-config
-      # Should do like PKG_CONFIG_PATH=/root/icu4r/ports/x86_64-pc-linux-gnu/libicu/59.1/lib/pkgconfig/ pkg-config --static  icu-uc
-      File.join(recipe.path, "bin", "#{libname}-config").tap do |config|
-        # call config scripts explicit with 'sh' for compat with Windows
-        $CPPFLAGS = '-DU_DISABLE_RENAMING=1 -DU_CHARSET_IS_UTF8=1 -DU_USING_ICU_NAMESPACE=0 -DU_STATIC_IMPLEMENTATION' << ' ' << $CPPFLAGS
-        `sh #{config} --ldflags`.strip.shellsplit.each do |arg|
-          case arg
-            when /\A-L(.+)\z/
-              # Prioritize ports' directories
-              if $1.start_with?(ROOT + '/')
-                $LIBPATH = [$1] | $LIBPATH
-              else
-                $LIBPATH = $LIBPATH | [$1]
-              end
-            when /\A-l./
-              libs.unshift(arg)
-            else
-              $LDFLAGS << ' ' << arg.shellescape
-          end
+  libname = libicu_recipe.name[/\Alib(.+)\z/, 1]
+  # TODO: build with pkg-config
+  # Should do like PKG_CONFIG_PATH=/root/icu4r/ports/x86_64-pc-linux-gnu/libicu/59.1/lib/pkgconfig/ pkg-config --static  icu-uc
+  File.join(libicu_recipe.path, "bin", "#{libname}-config").tap do |config|
+    # call config scripts explicit with 'sh' for compat with Windows
+    `sh #{config} --ldflags`.strip.shellsplit.each do |arg|
+      case arg
+      when /\A-L(.+)\z/
+        # Prioritize ports' directories
+        if $1.start_with?(ROOT + '/')
+          $LIBPATH.unshift($1)
+        else
+          $LIBPATH.push($1)
         end
-        $INCFLAGS = `sh #{config} --cppflags-searchpath `.strip << ' ' << $INCFLAGS
-        $CFLAGS = '-DU_DISABLE_RENAMING=1 -DU_CHARSET_IS_UTF8=1 -DU_USING_ICU_NAMESPACE=0 -DU_STATIC_IMPLEMENTATION' << ' ' << `sh #{config} --cflags`.strip << $CFLAGS
+      when /\A-l./
+        $LDFLAGS << ' ' << arg
+      else
+        $LDFLAGS << ' ' << arg.shellescape
       end
     end
-  end.shelljoin
-
+    $INCFLAGS = `sh #{config} --cppflags-searchpath `.strip << ' ' << $INCFLAGS
+    $CPPFLAGS = '-DU_DISABLE_RENAMING=1 -DU_CHARSET_IS_UTF8=1 -DU_USING_ICU_NAMESPACE=0 -DU_STATIC_IMPLEMENTATION' << ' ' << $CPPFLAGS
+    $CFLAGS = `sh #{config} --cflags`.strip << $CFLAGS
+  end
 end
 
 $CFLAGS << ' -O3 -funroll-loops -std=c99'
 $CFLAGS << ' -Wextra -O0 -ggdb3' if ENV['DEBUG']
 
-puts $CFLAGS, $CPPFLAGS, $CXXFLAGS
-
+unless have_library('icui18n', 'u_errorName') or
+  have_library('libicui18n', 'u_errorName') or
+  find_library('icui18n', 'u_errorName', *$LIBPATH)
+  crash("ICU build not found.")
+end
 create_makefile('icu/icu')

data/ext/icu/icu_spoof_checker.c

@@ -148,40 +148,89 @@ VALUE spoof_checker_get_skeleton(VALUE self, VALUE str)
     return icu_ustring_to_rb_enc_str_with_len(out, len_bytes);
 }
 
-#define DEFINE_SPOOF_ENUM_CONST(_MODULE, _NAME) rb_define_const(_MODULE, #_NAME, INT2NUM(USPOOF_##_NAME))
+VALUE spoof_checker_check(VALUE self, VALUE rb_str)
+{
+    StringValue(rb_str);
+    GET_SPOOF_CHECKER(this);
+
+    UErrorCode status = U_ZERO_ERROR;
+    int32_t result = 0;
+
+    if (icu_is_rb_str_as_utf_8(rb_str)) {
+       result = uspoof_check2UTF8(this->service,
+                                  RSTRING_PTR(rb_str),
+                                  RSTRING_LENINT(rb_str),
+                                  NULL,
+                                  &status);
+    } else {
+        VALUE in = icu_ustring_from_rb_str(rb_str);
+        result = uspoof_check2(this->service,
+                               icu_ustring_ptr(in),
+                               icu_ustring_len(in),
+                               NULL,
+                               &status);
+    }
+    if (U_FAILURE(status)) {
+        icu_rb_raise_icu_error(status);
+    }
+
+    return INT2NUM(result);
+}
+
+static const char* k_checks_name = "@checks";
+
+VALUE spoof_checker_available_checks(VALUE klass)
+{
+    VALUE iv = rb_iv_get(klass, k_checks_name);
+    if (NIL_P(iv)) {
+        iv = rb_hash_new();
+        rb_hash_aset(iv, ID2SYM(rb_intern("single_script_confusable")), INT2NUM(USPOOF_SINGLE_SCRIPT_CONFUSABLE));
+        rb_hash_aset(iv, ID2SYM(rb_intern("mixed_script_confusable")), INT2NUM(USPOOF_MIXED_SCRIPT_CONFUSABLE));
+        rb_hash_aset(iv, ID2SYM(rb_intern("whole_script_confusable")), INT2NUM(USPOOF_WHOLE_SCRIPT_CONFUSABLE));
+        rb_hash_aset(iv, ID2SYM(rb_intern("confusable")), INT2NUM(USPOOF_CONFUSABLE));
+        // USPOOF_ANY_CASE deprecated in 58
+        rb_hash_aset(iv, ID2SYM(rb_intern("restriction_level")), INT2NUM(USPOOF_RESTRICTION_LEVEL));
+        // USPOOF_SINGLE_SCRIPT deprecated in 51
+        rb_hash_aset(iv, ID2SYM(rb_intern("invisible")), INT2NUM(USPOOF_INVISIBLE));
+        rb_hash_aset(iv, ID2SYM(rb_intern("char_limit")), INT2NUM(USPOOF_CHAR_LIMIT));
+        rb_hash_aset(iv, ID2SYM(rb_intern("mixed_numbers")), INT2NUM(USPOOF_MIXED_NUMBERS));
+        rb_hash_aset(iv, ID2SYM(rb_intern("all_checks")), INT2NUM(USPOOF_ALL_CHECKS));
+        rb_hash_aset(iv, ID2SYM(rb_intern("aux_info")), INT2NUM(USPOOF_AUX_INFO));
+        rb_iv_set(klass, k_checks_name, iv);
+    }
+    return iv;
+}
+
+static const char* k_restriction_level_name = "@restriction_levels";
+
+VALUE spoof_checker_available_restriction_levels(VALUE klass)
+{
+    VALUE iv = rb_iv_get(klass, k_restriction_level_name);
+    if (NIL_P(iv)) {
+        iv = rb_hash_new();
+        rb_hash_aset(iv, ID2SYM(rb_intern("ascii")), INT2NUM(USPOOF_ASCII));
+        rb_hash_aset(iv, ID2SYM(rb_intern("single_script_restrictive")), INT2NUM(USPOOF_SINGLE_SCRIPT_RESTRICTIVE));
+        rb_hash_aset(iv, ID2SYM(rb_intern("highly_restrictive")), INT2NUM(USPOOF_HIGHLY_RESTRICTIVE));
+        rb_hash_aset(iv, ID2SYM(rb_intern("moderately_restrictive")), INT2NUM(USPOOF_MODERATELY_RESTRICTIVE));
+        rb_hash_aset(iv, ID2SYM(rb_intern("minimally_restrictive")), INT2NUM(USPOOF_MINIMALLY_RESTRICTIVE));
+        rb_hash_aset(iv, ID2SYM(rb_intern("unrestrictive")), INT2NUM(USPOOF_UNRESTRICTIVE));
+        rb_hash_aset(iv, ID2SYM(rb_intern("restriction_level_mask")), INT2NUM(USPOOF_RESTRICTION_LEVEL_MASK));
+        rb_hash_aset(iv, ID2SYM(rb_intern("undefined_restrictive")), INT2NUM(USPOOF_UNDEFINED_RESTRICTIVE));
+        rb_iv_set(klass, k_restriction_level_name, iv);
+    }
+    return iv;
+}
 
 void init_icu_spoof_checker(void)
 {
     rb_cICU_SpoofChecker = rb_define_class_under(rb_mICU, "SpoofChecker", rb_cObject);
-    rb_mChecks = rb_define_module_under(rb_cICU_SpoofChecker, "Checks");
-    rb_mRestrictionLevel = rb_define_module_under(rb_cICU_SpoofChecker, "RestrictionLevel");
-    rb_include_module(rb_cICU_SpoofChecker, rb_mChecks);
-    rb_include_module(rb_cICU_SpoofChecker, rb_mRestrictionLevel);
-    DEFINE_SPOOF_ENUM_CONST(rb_mChecks, SINGLE_SCRIPT_CONFUSABLE);
-    DEFINE_SPOOF_ENUM_CONST(rb_mChecks, MIXED_SCRIPT_CONFUSABLE);
-    DEFINE_SPOOF_ENUM_CONST(rb_mChecks, WHOLE_SCRIPT_CONFUSABLE);
-    DEFINE_SPOOF_ENUM_CONST(rb_mChecks, CONFUSABLE);
-    DEFINE_SPOOF_ENUM_CONST(rb_mChecks, ANY_CASE);
-    DEFINE_SPOOF_ENUM_CONST(rb_mChecks, RESTRICTION_LEVEL);
-    DEFINE_SPOOF_ENUM_CONST(rb_mChecks, SINGLE_SCRIPT);
-    DEFINE_SPOOF_ENUM_CONST(rb_mChecks, INVISIBLE);
-    DEFINE_SPOOF_ENUM_CONST(rb_mChecks, CHAR_LIMIT);
-    DEFINE_SPOOF_ENUM_CONST(rb_mChecks, MIXED_NUMBERS);
-    DEFINE_SPOOF_ENUM_CONST(rb_mChecks, ALL_CHECKS);
-    DEFINE_SPOOF_ENUM_CONST(rb_mChecks, AUX_INFO);
-    DEFINE_SPOOF_ENUM_CONST(rb_mRestrictionLevel, ASCII);
-    DEFINE_SPOOF_ENUM_CONST(rb_mRestrictionLevel, SINGLE_SCRIPT_RESTRICTIVE);
-    DEFINE_SPOOF_ENUM_CONST(rb_mRestrictionLevel, HIGHLY_RESTRICTIVE);
-    DEFINE_SPOOF_ENUM_CONST(rb_mRestrictionLevel, MODERATELY_RESTRICTIVE);
-    DEFINE_SPOOF_ENUM_CONST(rb_mRestrictionLevel, MINIMALLY_RESTRICTIVE);
-    DEFINE_SPOOF_ENUM_CONST(rb_mRestrictionLevel, UNRESTRICTIVE);
-    DEFINE_SPOOF_ENUM_CONST(rb_mRestrictionLevel, RESTRICTION_LEVEL_MASK);
-    DEFINE_SPOOF_ENUM_CONST(rb_mRestrictionLevel, UNDEFINED_RESTRICTIVE);
-
+    rb_define_singleton_method(rb_cICU_SpoofChecker, "available_checks", spoof_checker_available_checks, 0);
+    rb_define_singleton_method(rb_cICU_SpoofChecker, "available_restriction_levels", spoof_checker_available_restriction_levels, 0);
     rb_define_alloc_func(rb_cICU_SpoofChecker, spoof_checker_alloc);
     rb_define_method(rb_cICU_SpoofChecker, "initialize", spoof_checker_initialize, 0);
     rb_define_method(rb_cICU_SpoofChecker, "restriction_level", spoof_checker_get_restriction_level, 0);
     rb_define_method(rb_cICU_SpoofChecker, "restriction_level=", spoof_checker_set_restriction_level, 1);
+    rb_define_method(rb_cICU_SpoofChecker, "check", spoof_checker_check, 1);
     rb_define_method(rb_cICU_SpoofChecker, "checks", spoof_checker_get_checks, 0);
     rb_define_method(rb_cICU_SpoofChecker, "checks=", spoof_checker_set_checks, 1);
     rb_define_method(rb_cICU_SpoofChecker, "confusable?", spoof_checker_confusable, 2);

data/ext/icu/internal_utils.c

@@ -1,4 +1,5 @@
 #include "icu.h"
+#include "unicode/utypes.h"
 
 VALUE icu_enum_to_rb_ary(UEnumeration* icu_enum, UErrorCode status, long pre_allocated)
 {

data/lib/icu/version.rb

@@ -1,3 +1,3 @@
 module ICU
-  VERSION = "0.10.0"
+  VERSION = "0.10.1"
 end

data/spec/spoof_checker_spec.rb

@@ -1,19 +1,20 @@
 require 'spec_helper'
 
 describe ICU::SpoofChecker do
+  let(:checker) { ICU::SpoofChecker.new }
   describe 'get and set checks' do
     it 'is successful' do
-      subject.checks = ICU::SpoofChecker::Checks::CHAR_LIMIT | ICU::SpoofChecker::Checks::MIXED_NUMBERS
-      expect(subject.checks).to eq ICU::SpoofChecker::Checks::CHAR_LIMIT | ICU::SpoofChecker::Checks::MIXED_NUMBERS
-      subject.checks = ICU::SpoofChecker::Checks::ALL_CHECKS & ~ICU::SpoofChecker::Checks::CONFUSABLE
-      expect(subject.checks).to eq ICU::SpoofChecker::Checks::ALL_CHECKS & ~ICU::SpoofChecker::Checks::CONFUSABLE
+      checker.checks = ICU::SpoofChecker.available_checks[:char_limit] | ICU::SpoofChecker.available_checks[:mixed_numbers]
+      expect(checker.checks).to eq ICU::SpoofChecker.available_checks[:char_limit] | ICU::SpoofChecker.available_checks[:mixed_numbers]
+      checker.checks = ICU::SpoofChecker.available_checks[:all_checks] & ~ICU::SpoofChecker.available_checks[:confusable]
+      expect(checker.checks).to eq ICU::SpoofChecker.available_checks[:all_checks] & ~ICU::SpoofChecker.available_checks[:confusable]
     end
   end
 
   describe 'get and set restriction_level' do
     it 'is successful' do
-      subject.restriction_level = ICU::SpoofChecker::RestrictionLevel::HIGHLY_RESTRICTIVE
-      expect(subject.restriction_level).to eq ICU::SpoofChecker::RestrictionLevel::HIGHLY_RESTRICTIVE
+      checker.restriction_level = ICU::SpoofChecker.available_restriction_levels[:highly_restrictive]
+      expect(checker.restriction_level).to eq ICU::SpoofChecker.available_restriction_levels[:highly_restrictive]
     end
   end
 
@@ -21,9 +22,9 @@ describe ICU::SpoofChecker do
     shared_examples "confusable example" do |encodings|
       encodings.each do |encoding|
         it "can examine the confusable" do
-          expect(subject.confusable?("lscopecC鬼obƅa", "1scopecC⿁оbьа")).to be > 0
-          expect(subject.confusable?("lscopecC鬼obƅa".encode(encoding), "1scopecC⿁оbьа")).to be > 0
-          expect(subject.confusable?("lscopecC鬼obƅa".encode(encoding), "1scopecC⿁оbьа".encode(encoding))).to be > 0
+          expect(checker.confusable?("lscopecC鬼obƅa", "1scopecC⿁оbьа")).to be > 0
+          expect(checker.confusable?("lscopecC鬼obƅa".encode(encoding), "1scopecC⿁оbьа")).to be > 0
+          expect(checker.confusable?("lscopecC鬼obƅa".encode(encoding), "1scopecC⿁оbьа".encode(encoding))).to be > 0
         end
       end
     end
@@ -31,9 +32,9 @@ describe ICU::SpoofChecker do
     shared_examples "normal example" do |encodings|
       encodings.each do |encoding|
         it "returns 0 when it's not confusable" do
-          expect(subject.confusable?("abc", "def")).to eq 0
-          expect(subject.confusable?("abc".encode(encoding), "def")).to eq 0
-          expect(subject.confusable?("abc".encode(encoding), "def".encode(encoding))).to eq 0
+          expect(checker.confusable?("abc", "def")).to eq 0
+          expect(checker.confusable?("abc".encode(encoding), "def")).to eq 0
+          expect(checker.confusable?("abc".encode(encoding), "def".encode(encoding))).to eq 0
         end
       end
     end
@@ -42,15 +43,21 @@ describe ICU::SpoofChecker do
     it_should_behave_like "normal example", %w(UTF-8 UTF-16 UTF-32)
   end
 
+  describe '.check' do
+    it 'returns a integer contains about check result' do
+      expect(checker.check('sсcs')).to eq ICU::SpoofChecker.available_checks[:restriction_level]
+    end
+  end
+
   describe '.get_skeleton' do
     it 'can gets the skeleton representation' do
-      expect(subject.get_skeleton("𝔭𝒶ỿ𝕡𝕒ℓ")).not_to be_empty
-      expect(subject.get_skeleton("𝔭𝒶ỿ𝕡𝕒ℓ") == subject.get_skeleton("ρ⍺у𝓅𝒂ן")).to be_truthy
-      expect(subject.get_skeleton("𝔭𝒶ỿ𝕡𝕒ℓ".encode("UTF-16")) == subject.get_skeleton("ρ⍺у𝓅𝒂ן")).to be_truthy
-      expect(subject.get_skeleton("𝔭𝒶ỿ𝕡𝕒ℓ".encode("UTF-16")) == subject.get_skeleton("ρ⍺у𝓅𝒂ן".encode("UTF-16"))).to be_truthy
-      expect(subject.get_skeleton("𝔭𝒶ỿ𝕡𝕒ℓ") == subject.get_skeleton("paypal")).to be_truthy
-      expect(subject.get_skeleton("𝔭𝒶ỿ𝕡𝕒ℓ") == subject.get_skeleton("ρ⍺у𝓅𝒂ן")).to be_truthy
-      expect(subject.get_skeleton("𝔭𝒶ỿ𝕡𝕒ℓ") == subject.get_skeleton("paypal")).to be_truthy
+      expect(checker.get_skeleton("𝔭𝒶ỿ𝕡𝕒ℓ")).not_to be_empty
+      expect(checker.get_skeleton("𝔭𝒶ỿ𝕡𝕒ℓ") == checker.get_skeleton("ρ⍺у𝓅𝒂ן")).to be_truthy
+      expect(checker.get_skeleton("𝔭𝒶ỿ𝕡𝕒ℓ".encode("UTF-16")) == checker.get_skeleton("ρ⍺у𝓅𝒂ן")).to be_truthy
+      expect(checker.get_skeleton("𝔭𝒶ỿ𝕡𝕒ℓ".encode("UTF-16")) == checker.get_skeleton("ρ⍺у𝓅𝒂ן".encode("UTF-16"))).to be_truthy
+      expect(checker.get_skeleton("𝔭𝒶ỿ𝕡𝕒ℓ") == checker.get_skeleton("paypal")).to be_truthy
+      expect(checker.get_skeleton("𝔭𝒶ỿ𝕡𝕒ℓ") == checker.get_skeleton("ρ⍺у𝓅𝒂ן")).to be_truthy
+      expect(checker.get_skeleton("𝔭𝒶ỿ𝕡𝕒ℓ") == checker.get_skeleton("paypal")).to be_truthy
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: icu
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.10.1
 platform: ruby
 authors:
 - Erick Guan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-02 00:00:00.000000000 Z
+date: 2017-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler