text_comb 0.0.2-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e4df656cd44bb7a284b5e98201fb6085e5e91cc0
+  data.tar.gz: 858677d69dfaa6d2c4f2f386e44a41dc7f1f0cbd
+SHA512:
+  metadata.gz: 83d309b17b501242535177dc601317daca51dc972d65c07d721d5c341b2fe9e60852286a4370d337a82ba4dabbb4a5b8647e4acebdddaeda813cdb71d74e947a
+  data.tar.gz: a13e54b3c74d2ba01f3c1b806b4b7ca1ef5e8915fa3cb00ab36820d8a37d1011eb46ba762956297a39c974e09394c4b36b0fed86deb63c364db909583e17b1b7

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Dan Bernier
+
+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,132 @@
+# Integration Exercise: Java Library Wrapper
+
+## Exercise Summary
+
+- You should create a gem using JRuby that wraps an existing Java library.
+- Your gem should work with a Java library that doesn't already have
+  a good wrapper.
+- You should make the API for your library look and feel like Ruby, not Java.
+
+## Wrapping cue.language
+
+For this assignment, I'm wrapping the
+[cue.language](https://github.com/vcl/cue.language) library, which
+handles "counting strings, identifying languages, and removing stop
+words."
+
+## How to Use It
+
+### It's All In the TextComb Module
+
+There are methods for splitting up text:
+
+```ruby
+require 'text_comb'
+
+string = "He must be a little nuts. He is. I mean he just isn't well
+          screwed on is he?"
+
+p TextComb.words(string).to_a
+
+# prints:
+["He", "must", "be", "a", "little", "nuts", "He", "is", "I", "mean"...
+
+TextComb.sentences(string).each do |sentence|
+  p sentence
+end
+
+# prints:
+"He must be a little nuts. "
+"He is. "
+"I mean he just isn't well screwed on is he?"
+
+TextComb.ngrams(string, 5).each do |ngram|
+  p ngram
+end
+
+# prints:
+"He must be a little"
+"must be a little nuts"
+"I mean he just isn't"
+...
+```
+
+TextComb can take a guess at the language, and use the appropriate stop-words:
+
+```ruby
+string = "That's a great mustache, grandma!"
+TextComb.ngrams(string, 2, :stop_words=>:guess).to_a
+
+# returns:
+["great mustache", "mustache grandma"]
+```
+
+If it picks wrong, and you know what you're dealing with, you can specify:
+
+```ruby
+TextComb.ngrams(string, 3, :stop_words=>:Croatian).each do |ngram|
+  puts ngram
+end
+```
+
+If you're curious, TextComb will tell you how it guessed:
+
+```ruby
+string = "J'ai la moutarde dans ma moustache."
+TextComb.guess_language(string).to_s   # "French"
+```
+
+### Mix-in TextComb::StringExtensions
+
+Extend a string with TextComb::StringExtensions, and it'll have those
+methods:
+
+```ruby
+require 'text_comb'
+
+motto = "I came. I saw. I hacked."
+motto.extend(TextComb::StringExtensions)
+
+motto.sentences.to_a    # ["I came. ", "I saw. ", "I hacked."]
+motto.words.to_a.uniq   # ["I", "came", "saw", "hacked"]
+```
+
+Stop-words for n-grams work the same way, too.
+
+```ruby
+string = "I saw red roosters at Ted's farm."
+string.extend(TextComb::StringExtensions)
+string.ngrams(2, :stop_words => :English).to_a
+
+# returns:
+["saw red", "red roosters", "Ted's farm"]
+```
+
+### Make a TextComb::String
+
+TextComb::String includes TextComb::StringExtensions, but delegates everything
+else to its string. It's like mixing TextComb::StringExtensions into your
+own string.
+
+```ruby
+require 'text_comb'
+
+littany = TextComb::String.new("I must not fear.")
+littany.ngrams(3).to_a   # ["I must not", "must not fear"]
+```
+
+Even handier, there's the TextComb.string method to save you some 
+finger-tapping.
+
+```ruby
+require 'text_comb'
+littany = TextComb.string("I must not fear.")
+littany.words.to_a  # -> ["I", "must", "not", "fear."]
+
+littany.guess_language.to_s  # -> :English
+```
+
+### Future Plans
+
+- code(TextComb.ngrams) currently yields whole strings - maybe split
+  them into Arrays of words.

data/Rakefile

@@ -0,0 +1,4 @@
+require 'rake/testtask'
+
+Rake::TestTask.new
+task :default => :test

data/lib/text_comb.rb

@@ -0,0 +1,72 @@
+require 'java'
+require_relative '../vendor/cue.language.jar'
+require_relative 'text_comb/string_extensions'
+require_relative 'text_comb/string'
+require_relative 'text_comb/iterator'
+
+module TextComb
+
+  def self.words(string)
+    enumerate(cue.WordIterator.new(string))
+  end
+
+  def self.sentences(string)
+    enumerate(cue.SentenceIterator.new(string))
+  end
+
+  # TextComb.ngrams(string, 3)
+  # TextComb.ngrams(string, 3, :locale => java.util.Locale.default)
+  # TextComb.ngrams(string, 3, :stop_words => :guess)
+  # TextComb.ngrams(string, 3, :stop_words => :English)
+  # TextComb.ngrams(string, 3, TextComb.guess_language(string))
+  def self.ngrams(string, n, options={})
+
+    locale = options[:locale] || java.util.Locale.default
+
+    stop_words_val = case options[:stop_words]
+      when :guess
+        guess_language(string)
+      when Symbol
+        stop_words(options[:stop_words])
+      when stop.StopWords
+        options[:stop_words]
+      when nil
+        nil
+      else
+        raise "Can't recognize the stop_words: #{options[:stop_words]}"
+    end
+
+    enumerate(cue.NGramIterator.new(n, string, locale, stop_words_val))
+  end
+
+  # TextComb.guess_language "How are you?"
+  def self.guess_language(string)
+    stop.StopWords.guess(string)
+  end
+
+  # TextComb.stop_words :English
+  # TextComb.stop_words :French
+  def self.stop_words(stopwords_symbol)
+    stop.StopWords.const_get(stopwords_symbol)
+  end
+  
+  
+  # For convenience
+  def self.string(s)
+    TextComb::String.new(s)
+  end
+  
+
+  private
+  def self.cue
+    Java::CueLang
+  end
+
+  def self.stop
+    Java::CueLangStop
+  end
+
+  def self.enumerate(iterator)
+    Iterator.new(iterator)
+  end
+end

data/lib/text_comb/iterator.rb

@@ -0,0 +1,18 @@
+module TextComb
+
+  class Iterator
+    include Enumerable
+
+    def initialize(java_iter)
+      @java_iter = java_iter
+    end
+
+    def each
+      while @java_iter.has_next
+        yield @java_iter.next
+      end
+    end
+
+  end
+
+end

data/lib/text_comb/string.rb

@@ -0,0 +1,9 @@
+require 'delegate'
+
+module TextComb
+
+  class String < DelegateClass(::String)
+    include StringExtensions
+  end
+
+end

data/lib/text_comb/string_extensions.rb

@@ -0,0 +1,23 @@
+module TextComb
+
+  module StringExtensions
+
+    def words
+      TextComb.words(self.to_s)
+    end
+
+    def sentences
+      TextComb.sentences(self.to_s)
+    end
+
+    def ngrams(n, options={})
+      TextComb.ngrams(self.to_s, n, options)
+    end
+
+    def guess_language
+      TextComb.guess_language(self.to_s)
+    end
+
+  end
+
+end

data/lib/text_comb/version.rb

@@ -0,0 +1,3 @@
+module TextComb
+  VERSION = "0.0.2"
+end

data/test/test_java_interface.rb

@@ -0,0 +1,48 @@
+require 'minitest/autorun'
+require 'text_comb'
+
+class TestJavaInterface < MiniTest::Unit::TestCase
+
+  LITTANY = "
+    I must not fear.  Fear is the mind-killer.  Fear is the little-death
+    that brings total obliteration.  I will face my fear.  I will permit
+    it to pass over me and through me.  And when it has gone past I will
+    turn the inner eye to see its path.  Where the fear has gone there
+    will be nothing.  Only I will remain.".strip
+
+  def test_each_word
+    expected = %w[I must not fear]
+
+    assert_equal expected, TextComb.words("I must not fear. ").to_a
+  end
+
+  def test_each_sentence
+
+    expected = [
+      "I must not fear. ",
+      "Fear is the mind-killer. ",
+      "Fear is the little-death that brings total obliteration. ",
+      "I will face my fear. ",
+      "I will permit it to pass over me and through me. ",
+      "And when it has gone past I will turn the inner eye to see its path. ",
+      "Where the fear has gone there will be nothing. ",
+      "Only I will remain."
+    ]
+
+    assert_equal expected, TextComb.sentences(LITTANY).to_a
+  end
+
+  def test_each_ngram
+    expected = ["I must", "must not", "not fear"]
+
+    assert_equal expected, TextComb.ngrams("I must not fear. ", 2).to_a
+  end
+
+  def test_each_ngram_with_stop_words
+    text = "Fear is the little-death that brings total obliteration."
+    expected = ["brings total obliteration"]
+    ngrams = TextComb.ngrams(text, 3, :stop_words => :English).to_a
+
+    assert_equal expected, ngrams
+  end
+end

data/test/test_textcomb_string.rb

@@ -0,0 +1,51 @@
+require 'minitest/autorun'
+require 'text_comb'
+
+class TestTextCombString < MiniTest::Unit::TestCase
+
+  def test_can_call_normal_string_methods
+    plain_string = "I came. I saw. I hacked."
+    textcomb = TextComb.string(plain_string)
+
+    assert_equal plain_string.upcase, textcomb.upcase
+    assert_equal plain_string.reverse, textcomb.reverse
+    assert_equal plain_string.gsub(/i/i, "We"), textcomb.gsub(/i/i, "We")
+  end
+
+  def test_can_call_each_word
+    textcomb = TextComb.string("I came. I saw. I hacked.")
+    expected = %w[I came I saw I hacked]
+
+    assert_equal expected, textcomb.words.to_a
+  end
+
+  def test_can_call_each_sentence
+    textcomb = TextComb.string("I came. I saw. I hacked.")
+    expected = ["I came. ", "I saw. ", "I hacked."]
+
+    assert_equal expected, textcomb.sentences.to_a
+  end
+
+  def test_can_call_each_ngram
+    textcomb = TextComb.string("Never wake a sleeping cat.")
+    expected = ["Never wake a", "wake a sleeping", "a sleeping cat"]
+
+    assert_equal expected, textcomb.ngrams(3).to_a
+  end
+
+  def test_ngrams_with_stop_words
+    textcomb = TextComb.string("I saw red roosters at Willy's farm.")
+    expected = ["saw red", "red roosters", "Willy's farm"]
+
+    ngrams = textcomb.ngrams(2, :stop_words => :English).to_a
+    assert_equal expected, ngrams
+  end
+
+  def test_can_guess_its_language
+    textcomb = TextComb.string("I ate all the peanuts, then threw them up.")
+    assert_equal TextComb.stop_words(:English), textcomb.guess_language
+
+    textcomb = TextComb.string("J'ai la moutarde dans ma moustache.")
+    assert_equal TextComb.stop_words(:French), textcomb.guess_language
+  end
+end

data/text_comb.gemspec

@@ -0,0 +1,30 @@
+require_relative "lib/text_comb/version"
+
+spec = Gem::Specification.new do |s|
+  s.name = 'text_comb'
+  s.version = TextComb::VERSION
+
+  s.summary = %{
+    Extract words, sentences, and n-grams from natural-language text.
+  }.strip
+
+  s.description = %{A Ruby wrapper for the cue.language java library.}
+
+  s.licenses = ['MIT']
+
+  s.files = Dir['lib/**/*.rb'] + Dir['test/**/*.rb'] + %w[
+    LICENSE
+    README.md
+    Rakefile
+    text_comb.gemspec
+    vendor/cue.language.jar
+  ]
+
+  s.require_path = 'lib'
+  s.platform = 'java'
+  s.required_ruby_version = ">= 1.9.2"
+
+  s.author = "Dan Bernier"
+  s.email = "danbernier@gmail.com"
+  s.homepage = "https://github.com/danbernier/text_comb"
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: text_comb
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: java
+authors:
+- Dan Bernier
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-09-14 00:00:00.000000000 Z
+dependencies: []
+description: A Ruby wrapper for the cue.language java library.
+email: danbernier@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- lib/text_comb.rb
+- lib/text_comb/iterator.rb
+- lib/text_comb/string.rb
+- lib/text_comb/string_extensions.rb
+- lib/text_comb/version.rb
+- test/test_java_interface.rb
+- test/test_textcomb_string.rb
+- text_comb.gemspec
+- vendor/cue.language.jar
+homepage: https://github.com/danbernier/text_comb
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.4.5
+signing_key:
+specification_version: 4
+summary: Extract words, sentences, and n-grams from natural-language text.
+test_files: []