text_ux 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2e58920ebfec9f72c3303f6e09b5ea99949bfbac
+  data.tar.gz: fdcf6ac599b7d6305c33e1370d2deb2d1e43a989
+SHA512:
+  metadata.gz: fa023fe5a5bdc94354109873583e1b4566d78c955354e245741e3d4dde21a3853d37dd8c06aa27bc747a954d57646418e0b3d804848d6364e47e6a9328d7819e
+  data.tar.gz: 6bba44307fbfde6a8772d366547f8a80c578d1fe5d7cfdff033a1852b189533e7875b3c46877328ca5fa2603fd396cd4754bafd6506b183c5cc021a7280d3b67

data/.gitignore

@@ -0,0 +1,25 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+
+vendor/bundle
+sample

data/.rspec

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 yagince
+
+MIT License
+
+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/README.md

@@ -0,0 +1,51 @@
+# TextUx
+
+More Succinct Trie Data structure (binding for ux-trie)
+https://code.google.com/p/ux-trie/wiki/Tutorial_Japanese
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'text_ux'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install text_ux
+
+## Usage
+
+```ruby
+require "text_ux"
+
+ux = TextUx.new
+ux.build(%w( hoge foo bar baz footprint ), true)
+ux.save("path/to/index")
+
+# ux.load("path/to/index")
+
+ux.prefix_search("hoge---foo") # => hoge
+ux.prefix_search("xxx") # => nil
+
+ux.common_prefix_search("footprint") # => ["foo", "footprint"]
+ux.common_prefix_search("xxx") # => []
+
+ux.predictive_search("fo") # => ["foo", "footprint"]
+ux.predictive_search("xxx") # => []
+
+ux.decode_key(0) # => "hoge"
+ux.decode_key(10000) # => nil
+
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/text_ux/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/gem_tasks"
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new "text_ux" do |ext|
+  ext.lib_dir = "lib/text_ux"
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rspec_opts = ['-cfs']
+end
+
+task :test do
+  Rake::Task["clobber"].invoke
+  Rake::Task["compile"].invoke
+  Rake::Task["spec"].invoke
+end

data/ext/text_ux/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+if have_library('ux')
+  create_makefile("text_ux/text_ux")
+end

data/ext/text_ux/text_ux.cpp

@@ -0,0 +1,252 @@
+#include <new>
+#include <ruby.h>
+#include <ux/ux.hpp>
+#include <vector>
+#include <string>
+#include <sstream>
+
+VALUE rb_cTextUx;
+
+static void  ux_free(ux::Trie* ptr);
+static VALUE ux_alloc(VALUE klass);
+static VALUE ux_initialize(VALUE self);
+static VALUE ux_build(int argc, VALUE *argv, VALUE self);
+static VALUE ux_save(VALUE self, VALUE file_name);
+static VALUE ux_load(VALUE self, VALUE file_name);
+
+static VALUE ux_prefix_search(VALUE self, VALUE word);
+static VALUE ux_common_prefix_search(int argc, VALUE *argv, VALUE self);
+static VALUE ux_predictive_search(int argc, VALUE *argv, VALUE self);
+static VALUE ux_decode_key(VALUE self, VALUE index);
+
+static VALUE ux_size(VALUE self);
+static VALUE ux_clear(VALUE self);
+static VALUE ux_alloc_size(VALUE self);
+static VALUE ux_alloc_stat(VALUE self);
+
+extern "C" void Init_text_ux(void) {
+  rb_cTextUx = rb_define_class("TextUx", rb_cObject);
+  rb_define_alloc_func(rb_cTextUx, ux_alloc);
+  rb_define_private_method(rb_cTextUx, "initialize", RUBY_METHOD_FUNC(ux_initialize), 0);
+  rb_define_method(rb_cTextUx, "build", RUBY_METHOD_FUNC(ux_build), -1);
+  rb_define_method(rb_cTextUx, "save", RUBY_METHOD_FUNC(ux_save), 1);
+  rb_define_method(rb_cTextUx, "load", RUBY_METHOD_FUNC(ux_load), 1);
+
+  rb_define_method(rb_cTextUx, "prefix_search", RUBY_METHOD_FUNC(ux_prefix_search), 1);
+  rb_define_method(rb_cTextUx, "common_prefix_search", RUBY_METHOD_FUNC(ux_common_prefix_search), -1);
+  rb_define_method(rb_cTextUx, "predictive_search", RUBY_METHOD_FUNC(ux_predictive_search), -1);
+  rb_define_method(rb_cTextUx, "decode_key", RUBY_METHOD_FUNC(ux_decode_key), 1);
+
+  rb_define_method(rb_cTextUx, "size", RUBY_METHOD_FUNC(ux_size), 0);
+  rb_define_method(rb_cTextUx, "clear", RUBY_METHOD_FUNC(ux_clear), 0);
+  rb_define_method(rb_cTextUx, "alloc_size", RUBY_METHOD_FUNC(ux_alloc_size), 0);
+  rb_define_method(rb_cTextUx, "alloc_stat", RUBY_METHOD_FUNC(ux_alloc_stat), 0);
+
+  rb_define_const(rb_cTextUx, "DEFAULT_LIMIT", ux::LIMIT_DEFAULT);
+}
+
+static ux::Trie* getTrie(VALUE self) {
+  ux::Trie* p;
+  Data_Get_Struct(self, ux::Trie, p);
+  return p;
+}
+
+static void
+ux_free(ux::Trie* ptr)
+{
+  ptr->~Trie();
+  ruby_xfree(ptr);
+}
+
+static VALUE
+ux_alloc(VALUE klass)
+{
+  ux::Trie *ptr = new ux::Trie();
+  return Data_Wrap_Struct(klass, NULL, ux_free, ptr);
+}
+
+static VALUE
+ux_initialize(VALUE self)
+{
+  // TODO: 配列で辞書データを受け取る
+  return Qnil;
+}
+
+static VALUE
+// ux_build(VALUE self, VALUE words, VALUE is_tail_ux)
+ux_build(int argc, VALUE *argv, VALUE self)
+{
+  VALUE words, is_tail_ux;
+
+  rb_scan_args(argc, argv, "11", &words, &is_tail_ux);
+
+  Check_Type(words, T_ARRAY);
+  if ( is_tail_ux == Qnil ) {
+    is_tail_ux = Qtrue;
+  }
+
+  std::vector<std::string> keyList;
+  long len = RARRAY_LEN(words);
+  for (long i = 0; i < len; i++) {
+    VALUE rb_word = rb_ary_entry(words, i);
+    std::string word = StringValuePtr(rb_word);
+    keyList.push_back(std::string(word));
+  }
+
+  ux::Trie* trie = getTrie(self);
+  trie->build(keyList, RTEST(is_tail_ux));
+
+  return self;
+}
+
+static VALUE
+ux_save(VALUE self, VALUE file_name)
+{
+  Check_Type(file_name, T_STRING);
+
+  std::string f = StringValuePtr(file_name);
+  ux::Trie* trie = getTrie(self);
+  if (trie->save(f.c_str()) != ux::Trie::SUCCESS ) {
+    rb_exc_raise(rb_str_new2("Save Error"));
+  }
+  return self;
+}
+
+static VALUE
+ux_load(VALUE self, VALUE file_name)
+{
+  Check_Type(file_name, T_STRING);
+
+  std::string f = StringValuePtr(file_name);
+  ux::Trie* trie = getTrie(self);
+  if (trie->load(f.c_str()) != ux::Trie::SUCCESS ) {
+    rb_exc_raise(rb_str_new2("Load Error"));
+  }
+  return self;
+}
+
+static VALUE
+ux_prefix_search(VALUE self, VALUE word)
+{
+  Check_Type(word, T_STRING);
+
+  std::string w = StringValuePtr(word);
+
+  ux::Trie* trie = getTrie(self);
+  size_t ret_len;
+  ux::id_t id = trie->prefixSearch(w.c_str(), w.size(), ret_len);
+  if ( id == ux::NOTFOUND ) {
+    return Qnil;
+  } else {
+    std::string key = trie->decodeKey(id);
+    return rb_str_new2(key.c_str());
+  }
+}
+
+static VALUE
+ux_common_prefix_search(int argc, VALUE *argv, VALUE self)
+{
+  VALUE word, _limit;
+
+  rb_scan_args(argc, argv, "11", &word, &_limit);
+
+  Check_Type(word, T_STRING);
+  std::string w = StringValuePtr(word);
+
+  size_t limit;
+  if (_limit == Qnil) {
+    limit = ux::LIMIT_DEFAULT;
+  } else {
+    limit = NUM2INT(_limit);
+  }
+
+  ux::Trie* trie = getTrie(self);
+  std::vector<ux::id_t> ret_ids;
+  size_t keys_size  = trie->commonPrefixSearch(w.c_str(), w.size(), ret_ids, limit);
+  VALUE ary = rb_ary_new();
+  if (keys_size == 0) {
+    return ary;
+  }
+  for (size_t i = 0; i < keys_size; i++) {
+    std::string key = trie->decodeKey(ret_ids[i]);
+    rb_ary_push(ary, rb_str_new2(key.c_str()));
+  }
+  return ary;
+}
+
+static VALUE
+ux_predictive_search(int argc, VALUE *argv, VALUE self)
+{
+  VALUE word, _limit;
+
+  rb_scan_args(argc, argv, "11", &word, &_limit);
+
+  Check_Type(word, T_STRING);
+  std::string w = StringValuePtr(word);
+
+  size_t limit;
+  if (_limit == Qnil) {
+    limit = ux::LIMIT_DEFAULT;
+  } else {
+    limit = NUM2INT(_limit);
+  }
+
+  ux::Trie* trie = getTrie(self);
+  std::vector<ux::id_t> ret_ids;
+  size_t keys_size  = trie->predictiveSearch(w.c_str(), w.size(), ret_ids, limit);
+  VALUE ary = rb_ary_new();
+  if (keys_size == 0) {
+    return ary;
+  }
+  for (size_t i = 0; i < keys_size; i++) {
+    std::string key = trie->decodeKey(ret_ids[i]);
+    rb_ary_push(ary, rb_str_new2(key.c_str()));
+  }
+  return ary;
+}
+
+static VALUE
+ux_decode_key(VALUE self, VALUE index)
+{
+  
+  ux::id_t idx = NUM2INT(index);
+  ux::Trie* trie = getTrie(self);
+
+  if (trie->size() <= idx) {
+    return Qnil;
+  }
+
+  std::string key = trie->decodeKey(idx);
+  return key.empty() ? Qnil : rb_str_new2(key.c_str());
+}
+
+static VALUE
+ux_size(VALUE self)
+{
+  ux::Trie* trie = getTrie(self);
+  size_t size = trie->size();
+  return INT2NUM(size);
+}
+static VALUE
+ux_clear(VALUE self)
+{
+  ux::Trie* trie = getTrie(self);
+  trie->clear();
+  return Qtrue;
+}
+static VALUE
+ux_alloc_size(VALUE self)
+{
+  ux::Trie* trie = getTrie(self);
+  size_t size = trie->getAllocSize();
+  return INT2FIX(size);
+}
+static VALUE
+ux_alloc_stat(VALUE self)
+{
+  ux::Trie* trie = getTrie(self);
+  std::ostringstream os;
+  trie->stat(os);
+
+  return rb_str_new2(os.str().c_str());
+}

data/lib/text_ux.rb

@@ -0,0 +1,5 @@
+require "text_ux/version"
+require "text_ux/text_ux"
+
+class TextUx
+end

data/lib/text_ux/version.rb

@@ -0,0 +1,3 @@
+class TextUx
+  VERSION = "0.0.1"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'text_ux'
+
+# 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/text_ux_spec.rb

@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe TextUx do
+  let(:ux) { TextUx.new }
+  let(:builded) { ux.build(%w(hoge foo bar baz footprint), true) }
+  
+  describe :build do
+    context "配列を渡した場合" do
+      it { expect{ ux.build(%w(hoge foo bar), true) }.to_not raise_error }
+    end
+
+    context "配列以外を渡した場合" do
+      it { expect{ ux.build( :hoge, true ) }.to raise_error }
+    end
+
+    it "is_tail_uxは省略可能" do
+      expect{ ux.build(%w(hoge foo bar)) }.to_not raise_error
+    end
+  end
+
+  describe :save do
+    let(:name) { "test.ux" }
+
+    subject { builded.save(name) }
+
+    after do
+      File.exist?(name) and File.delete(name)
+    end
+    
+    it "ファイルに保存される" do
+      expect(subject).to be builded
+      expect(File.exist?(name)).to be true
+    end
+  end
+
+  describe :load do
+    let(:name) { "spec/fixtures/test.ux" }
+
+    subject { ux.load(name) }
+
+    it { expect(subject.prefix_search("hoge----foo")).to eq("hoge") }
+
+    context "loadに失敗した場合" do
+      it "例外がraiseされる" do
+        expect{ ux.load("hoge") }.to raise_error
+      end
+    end
+  end
+
+  describe :prefix_search do
+
+    context "結果がある場合" do
+      it "一致するキーが取得できる" do
+        expect(builded.prefix_search("hogeはfoo")).to eq("hoge")
+      end
+    end
+
+    context "結果がない場合" do
+      it { expect(builded.prefix_search("XXX")).to be_nil }
+    end
+  end
+
+
+  describe :common_prefix_search do
+
+    context "結果がある場合" do
+      it "一致するキーが全て取得できる" do
+        expect(builded.common_prefix_search("footprint")).to match_array(%w(foo footprint))
+      end
+    end
+
+    context "結果がない場合" do
+      it { expect(builded.common_prefix_search("XXX")).to be_empty }
+    end
+
+    context "limitを指定した場合" do
+      it "一致した結果からlimit以内の数だけ取得できる" do
+        expect(builded.common_prefix_search("footprint", 1)).to match_array(%w(foo))
+      end
+    end
+  end
+
+  describe :predictive_search do
+
+    context "結果がある場合" do
+      it "一致するキーが全て取得できる" do
+        expect(builded.predictive_search("fo")).to match_array(%w(foo footprint))
+      end
+    end
+
+    context "結果がない場合" do
+      it { expect(builded.predictive_search("XXX")).to be_empty }
+    end
+
+    context "limitを指定した場合" do
+      it "一致した結果からlimit以内の数だけ取得できる" do
+        expect(builded.predictive_search("fo", 1)).to match_array(%w(foo))
+      end
+    end
+  end
+
+  describe :decode_key do
+    context "結果がある場合" do
+      it "一致するキーが取得できる" do
+        expect(builded.decode_key(0)).to eq("hoge")
+      end
+    end
+
+    context "結果がない場合" do
+      it { expect(builded.decode_key(100000)).to be nil }
+    end
+  end
+
+  describe :size do
+    it { expect(builded.size).to eq(5) }
+  end
+  describe :clear do
+    it "空になる" do
+      expect(builded.clear).to be true
+      expect(builded.size).to eq(0)
+    end
+  end
+  describe :alloc_size do
+    it { expect(builded.alloc_size).to be >= 0 }
+  end
+  describe :alloc_stat do
+    it { expect(builded.alloc_stat).to_not be_empty }
+  end
+
+  describe :constants do
+    describe "DEFAULT_LIMIT" do
+      it { expect(TextUx::DEFAULT_LIMIT).to be_a Numeric }
+    end
+  end
+end
+