tolq-ffi-hunspell 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3ba672292b48ce7c197aba99a62971ac5e2355b1ff168058169c0edfcb25415f
+  data.tar.gz: 6d4193fe3895ee9fd2c94a02e712af29e4529ffa35c276926172fa3131b3d6d1
+SHA512:
+  metadata.gz: e80a32d978a7e641c99ef69119fabf4f3921c41e043db9aee8a132499b75e101e0a815310e43619896ab2537d0109dcf6135f8dabb912f583f536023986bc79d
+  data.tar.gz: 74c0273375c0681c5c466438366d9a86db9e0e9c01625b2caec4694f94b43548e667623360334f01bb04f22d6a2bebf9264f22c445a0cac11ab911b94ea2c0e2

data/.gitignore

@@ -0,0 +1,4 @@
+doc
+pkg
+.bundle
+.yardoc

data/.rspec

@@ -0,0 +1 @@
+--colour --format documentation

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+before_install:
+  - sudo apt-get install libhunspell-dev hunspell-en-us
+  - gem install ffi rubygems-tasks rspec yard
+rvm:
+  - 1.9.3
+  - 2.3.0
+  - jruby
+  - rbx
+matrix:
+  allow_failures:
+    - rvm: rbx
+script: rake spec

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown --title 'FFI Hunspell Documentation' --protected --files ChangeLog.md,LICENSE.txt

data/ChangeLog.md

@@ -0,0 +1,71 @@
+### 0.4.0 / 2017-04-21
+
+* Added support for libhunspell-1.6.
+* Added support for libhunspell-1.5 (@trench8891).
+* Added support for libhunspell-1.4 (@willmoorefyi).
+* Renamed `#add_affix` to {FFI::Hunspell::Dictionary#add_with_affix}
+  (@cdchapman).
+
+### 0.3.1 / 2016-01-14
+
+* Prefer loading hunspell-1.3 over hunspell-1.2, if both are installed.
+* Support auto-detection of hunspell installed by homebrew (@forward3d).
+
+### 0.3.0 / 2013-05-01
+
+* Detect Ubuntu's hunspell directory (`/usr/share/hunspell`).
+* {FFI::Hunspell::Dictionary#encoding} now returns an `Encoding` object.
+* Encode Strings returned from {FFI::Hunspell::Dictionary#stem} and
+  {FFI::Hunspell::Dictionary#suggest} to match the dictionary's native
+  encoding.
+
+### 0.2.6 / 2013-02-05
+
+* Removed the env dependency.
+* Check the returned count from `Hunsepll_stem` in
+  {FFI::Hunspell::Dictionary#stem}.
+* Check the returned count from `Hunspell_suggest` in
+  {FFI::Hunspell::Dictionary#suggest}.
+
+### 0.2.5 / 2012-05-11
+
+* Load `libhunspell-1.2.so.0` if `libhunspell-1.2.so` cannot be found.
+* Load `libhunspell-1.3.so.0` if `libhunspell-1.3.so` cannot be found.
+
+### 0.2.4 / 2012-04-27
+
+* Require ffi ~> 1.0.
+* Attempt loading `libhunspell-1.2` and `libhunspell-1.3`.
+
+### 0.2.3 / 2011-02-02
+
+* Require ffi >= 0.6.0 and <= 1.1.0:
+  * JRuby requires ffi >= 1.0.0.
+  * A lot of projects still require ffi ~> 0.6.0.
+
+### 0.2.2 / 2011-01-25
+
+* Added {FFI::Hunspell::USER_DIR}.
+* Added {FFI::Hunspell::KNOWN_DIRECTORIES}, containing known dictionary
+  directories used by Debian, Fedora and Mac Ports.
+* Have {FFI::Hunspell.directories} return the dictionary directories found
+  on the system.
+
+### 0.2.1 / 2011-01-23
+
+* Require env ~> 0.1.2.
+  * Use `Env.lang` to get the default language.
+* Updated the Copyright years.
+
+### 0.2.0 / 2011-01-22
+
+* Added {FFI::Hunspell.lang}.
+* Added {FFI::Hunspell.lang=}.
+* Added {FFI::Hunspell.directories}.
+* Have {FFI::Hunspell::Dictionary.open} accept a language name, and search
+  {FFI::Hunspell.directories} for the dictionary files.
+
+### 0.1.0 / 2010-10-05
+
+* Initial release.
+

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2010-2016 Hal Brodigan
+
+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,67 @@
+# ffi-hunspell
+
+* [Source](https://github.com/postmodern/ffi-hunspell)
+* [Issues](https://github.com/postmodern/ffi-hunspell/issues)
+* [Documentation](http://rubydoc.info/gems/ffi-hunspell/frames)
+* [Email](postmodern.mod3 at gmail.com)
+
+[![Build Status](https://secure.travis-ci.org/postmodern/ffi-hunspell.png?branch=master)](https://travis-ci.org/postmodern/ffi-hunspell)
+
+## Description
+
+Ruby FFI bindings for [Hunspell][libhunspell].
+
+## Examples
+
+Open a dictionary:
+```rb
+require 'ffi/hunspell'
+    
+FFI::Hunspell.dict do |dict|
+  # ...
+end
+
+FFI::Hunspell.dict('en_GB') do |dict|
+  # ...
+end
+
+dict = FFI::Hunspell.dict('en_GB')
+# ...
+dict.close
+```
+
+Check if a word is valid:
+```rb
+dict.check?('dog')
+# => true
+
+dict.check?('d0g')
+# => false
+```
+Find the stems of a word:
+```rb
+dict.stem('dogs')
+# => ["dog"]
+```
+Suggest alternate spellings for a word:
+```rb
+dict.suggest('arbitrage')
+# => ["arbitrage", "arbitrages", "arbitrager", "arbitraged", "arbitrate"]
+```
+## Requirements
+
+* [libhunspell] >= 1.2.0
+* [ffi] ~> 1.0
+
+## Install
+```sh
+$ gem install ffi-hunspell
+```
+## License
+
+Copyright (c) 2010-2016 Hal Brodigan
+
+See {file:LICENSE.txt} for license information.
+
+[libhunspell]: http://hunspell.sourceforge.net/
+[ffi]: https://github.com/ffi/ffi

data/Rakefile

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'rubygems/tasks'
+
+  Gem::Tasks.new
+rescue LoadError => e
+  warn e.message
+  warn "Run `gem install rubygems-tasks` to install 'rubygems/tasks'."
+end
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new
+rescue LoadError => e
+  task :spec do
+    abort "Please run `gem install rspec` to install RSpec."
+  end
+end
+task :test => :spec
+task :default => :spec
+
+begin
+  require 'yard'
+
+  YARD::Rake::YardocTask.new  
+rescue LoadError => e
+  task :yard do
+    abort "Please run `gem install yard` to install YARD."
+  end
+end

data/ffi-hunspell.gemspec

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+require 'yaml'
+
+Gem::Specification.new do |gem|
+  gemspec = YAML.load_file('gemspec.yml')
+
+  gem.name    = gemspec.fetch('name')
+  gem.version = gemspec.fetch('version') do
+                  lib_dir = File.join(File.dirname(__FILE__),'lib')
+                  $LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
+
+                  require 'ffi/hunspell/version'
+                  FFI::Hunspell::VERSION
+                end
+
+  gem.summary     = gemspec['summary']
+  gem.description = gemspec['description']
+  gem.licenses    = Array(gemspec['license'])
+  gem.authors     = Array(gemspec['authors'])
+  gem.email       = gemspec['email']
+  gem.homepage    = gemspec['homepage']
+
+  glob = lambda { |patterns| gem.files & Dir[*patterns] }
+
+  gem.files = `git ls-files`.split($/)
+  gem.files = glob[gemspec['files']] if gemspec['files']
+
+  gem.executables = gemspec.fetch('executables') do
+    glob['bin/*'].map { |path| File.basename(path) }
+  end
+  gem.default_executable = gem.executables.first if Gem::VERSION < '1.7.'
+
+  gem.extensions       = glob[gemspec['extensions'] || 'ext/**/extconf.rb']
+  gem.test_files       = glob[gemspec['test_files'] || '{test/{**/}*_test.rb']
+  gem.extra_rdoc_files = glob[gemspec['extra_doc_files'] || '*.{txt,md}']
+
+  gem.require_paths = Array(gemspec.fetch('require_paths') {
+    %w[ext lib].select { |dir| File.directory?(dir) }
+  })
+
+  gem.requirements              = gemspec['requirements']
+  gem.required_ruby_version     = gemspec['required_ruby_version']
+  gem.required_rubygems_version = gemspec['required_rubygems_version']
+  gem.post_install_message      = gemspec['post_install_message']
+
+  split = lambda { |string| string.split(/,\s*/) }
+
+  if gemspec['dependencies']
+    gemspec['dependencies'].each do |name,versions|
+      gem.add_dependency(name,split[versions])
+    end
+  end
+
+  if gemspec['development_dependencies']
+    gemspec['development_dependencies'].each do |name,versions|
+      gem.add_development_dependency(name,split[versions])
+    end
+  end
+end

data/gemspec.yml

@@ -0,0 +1,21 @@
+name: tolq-ffi-hunspell
+version: 0.5.0
+summary: FFI bindings for Hunspell
+description: Ruby FFI bindings for the Hunspell spell checker.
+license: MIT
+authors: Postmodern
+email: postmodern.mod3@gmail.com
+homepage: https://github.com/postmodern/ffi-hunspell#readme
+has_yard: true
+
+requirements: libhunspell >= 1.2.0
+
+required_ruby_version: ">= 1.9.1"
+
+dependencies:
+  ffi: ~> 1.0
+
+development_dependencies:
+  rubygems-tasks: ~> 0.1
+  rspec: ~> 3.0
+  yard: ~> 0.7

data/lib/ffi/hunspell.rb

@@ -0,0 +1,2 @@
+require 'ffi/hunspell/hunspell'
+require 'ffi/hunspell/dictionary'

data/lib/ffi/hunspell/dictionary.rb

@@ -0,0 +1,257 @@
+require 'ffi/hunspell/hunspell'
+
+module FFI
+  module Hunspell
+    #
+    # Represents a dictionary for a specific language.
+    #
+    class Dictionary
+
+      # The affix file extension
+      AFF_EXT = 'aff'
+
+      # The dictionary file extension
+      DIC_EXT = 'dic'
+
+      #
+      # Creates a new dictionary.
+      #
+      # @param [String] affix_path
+      #   The path to the `.aff` file.
+      #
+      # @param [String] dic_path
+      #   The path to the `.dic` file.
+      #
+      # @param [String] key
+      #   The optional key for encrypted dictionary files.
+      #
+      # @raise [RuntimeError]
+      #   Either the `.aff` or `.dic` files did not exist.
+      #
+      def initialize(affix_path,dic_path,key=nil)
+        unless File.file?(affix_path)
+          raise("invalid affix path #{affix_path.inspect}")
+        end
+
+        unless File.file?(dic_path)
+          raise("invalid dic path #{dic_path.inspect}")
+        end
+
+        @ptr = if key then Hunspell.Hunspell_create_key(affix_path,dic_path,key)
+               else        Hunspell.Hunspell_create(affix_path,dic_path)
+               end
+      end
+
+      #
+      # Opens a Hunspell dictionary.
+      #
+      # @param [Symbol, String] name
+      #   The name of the dictionary to open.
+      #
+      # @yield [dict]
+      #   The given block will be passed the Hunspell dictionary.
+      #
+      # @yieldparam [Dictionary] dict
+      #   The opened dictionary.
+      #
+      # @return [Dictionary]
+      #   If no block is given, the open dictionary will be returned.
+      #
+      # @raise [ArgumentError]
+      #   The dictionary files could not be found in any of the directories.
+      #
+      def self.open(name)
+        name = name.to_s
+
+        Hunspell.directories.each do |dir|
+          affix_path = File.join(dir,"#{name}.#{AFF_EXT}")
+          dic_path   = File.join(dir,"#{name}.#{DIC_EXT}")
+
+          if (File.file?(affix_path) && File.file?(dic_path))
+            dict = self.new(affix_path,dic_path)
+
+            if block_given?
+              yield dict
+
+              dict.close
+              return nil
+            else
+              return dict
+            end
+          end
+        end
+
+        raise(ArgumentError,"unable to find the dictionary #{name.dump} in any of the directories")
+      end
+
+      #
+      # Determines if the dictionary is closed.
+      #
+      # @return [Boolean]
+      #   Specifies whether the dictionary was closed.
+      #
+      def closed?
+        @ptr.nil?
+      end
+
+      #
+      # The encoding of the dictionary file.
+      #
+      # @return [Encoding]
+      #   The encoding of the dictionary file.
+      #
+      def encoding
+        @encoding ||= Encoding.const_get(
+          Hunspell.Hunspell_get_dic_encoding(self).gsub('-','_')
+        )
+      end
+
+      #
+      # Adds a word to the dictionary.
+      #
+      # @param [#to_s] word
+      #   The word to add to the dictionary.
+      #
+      def add(word)
+        Hunspell.Hunspell_add(self,word.to_s)
+      end
+
+      #
+      # Adds a word to the dictionary with affix flags.
+      #
+      # @param [#to_s] word
+      #   The word to add to the dictionary.
+      #
+      # @param [#to_s] example
+      #   Affix flags.
+      #
+      # @since 0.4.0
+      #
+      def add_with_affix(word,example)
+        Hunspell.Hunspell_add_with_affix(self,word.to_s,example.to_s)
+      end
+
+      #
+      # @deprecated Please use {#add_with_affix} instead.
+      #
+      def add_affix(word,example)
+        add_with_affix(word,example)
+      end
+
+      alias << add
+
+      #
+      # Removes a word from the dictionary.
+      #
+      # @param [#to_s] word
+      #   The word to remove.
+      #
+      def remove(word)
+        Hunspell.Hunspell_remove(self,word.to_s)
+      end
+
+      alias delete remove
+
+      #
+      # Checks if the word is validate.
+      #
+      # @param [#to_s] word
+      #   The word in question.
+      #
+      # @return [Boolean]
+      #   Specifies whether the word is valid.
+      #
+      def check?(word)
+        Hunspell.Hunspell_spell(self,word.to_s) != 0
+      end
+
+      alias valid? check?
+
+      #
+      # Finds the stems of a word.
+      #
+      # @param [#to_s] word
+      #   The word in question.
+      #
+      # @return [Array<String>]
+      #   The stems of the word.
+      #
+      def stem(word)
+        stems = []
+
+        FFI::MemoryPointer.new(:pointer) do |output|
+          count = Hunspell.Hunspell_stem(self,output,word.to_s)
+          ptr   = output.get_pointer(0)
+
+          if count > 0
+            stems = ptr.get_array_of_string(0,count)
+          end
+        end
+
+        return stems.map { |word| force_encoding(word) }
+      end
+
+      #
+      # Suggests alternate spellings of a word.
+      #
+      # @param [#to_s] word
+      #   The word in question.
+      #
+      # @return [Array<String>]
+      #   The suggestions for the word.
+      #
+      def suggest(word)
+        suggestions = []
+
+        FFI::MemoryPointer.new(:pointer) do |output|
+          count = Hunspell.Hunspell_suggest(self,output,word.to_s)
+          ptr   = output.get_pointer(0)
+
+          if count > 0
+            suggestions = ptr.get_array_of_string(0,count)
+          end
+        end
+
+        return suggestions.map { |word| force_encoding(word) }
+      end
+
+      #
+      # Closes the dictionary.
+      #
+      # @return [nil]
+      #
+      def close
+        Hunspell.Hunspell_destroy(self)
+
+        @ptr = nil
+        return nil
+      end
+
+      #
+      # Converts the dictionary to a pointer.
+      #
+      # @return [FFI::Pointer]
+      #   The pointer for the dictionary.
+      #
+      def to_ptr
+        @ptr
+      end
+
+      protected
+
+      #
+      # Encodes a String into the dictionary's encoding.
+      #
+      # @param [String] string
+      #   The unencoded String.
+      #
+      # @return [String]
+      #   The encoded String.
+      #
+      def force_encoding(string)
+        string.force_encoding(encoding)
+      end
+
+    end
+  end
+end

data/lib/ffi/hunspell/hunspell.rb

@@ -0,0 +1,127 @@
+require 'ffi'
+
+module FFI
+  module Hunspell
+    extend FFI::Library
+
+    ffi_lib [
+      'hunspell-1.7', 'libhunspell-1.7.so.0',
+      'hunspell-1.6', 'libhunspell-1.6.so.0',
+      'hunspell-1.5', 'libhunspell-1.5.so.0',
+      'hunspell-1.4', 'libhunspell-1.4.so.0',
+      'hunspell-1.3', 'libhunspell-1.3.so.0',
+      'hunspell-1.2', 'libhunspell-1.2.so.0'
+    ]
+
+
+    attach_function :Hunspell_create, [:string, :string], :pointer
+    attach_function :Hunspell_create_key, [:string, :string, :string], :pointer
+    attach_function :Hunspell_destroy, [:pointer], :void
+    attach_function :Hunspell_spell, [:pointer, :string], :int
+    attach_function :Hunspell_get_dic_encoding, [:pointer], :string
+    attach_function :Hunspell_suggest, [:pointer, :pointer, :string], :int
+    attach_function :Hunspell_analyze, [:pointer, :pointer, :string], :int
+    attach_function :Hunspell_stem, [:pointer, :pointer, :string], :int
+    attach_function :Hunspell_generate, [:pointer, :pointer, :string, :string], :int
+    attach_function :Hunspell_add, [:pointer, :string], :int
+    attach_function :Hunspell_add_with_affix, [:pointer, :string, :string], :int
+    attach_function :Hunspell_remove, [:pointer, :string], :int
+    attach_function :Hunspell_free_list, [:pointer, :pointer, :int], :void
+
+    #
+    # missing functions:
+    #
+    #   attach_function :Hunspell_stem2, [:pointer, :pointer, :pointer, :int], :int
+    #   attach_function :Hunspell_generate2, [:pointer, :pointer, :string, :pointer, :int], :int
+    #
+
+    # The language to default to, if no 'LANG' env variable was set.
+    DEFAULT_LANG = ENV.fetch('LANG','en_US.UTF-8').split('.',2).first
+
+    #
+    # The default language.
+    #
+    # @return [String]
+    #   The name of the default language.
+    #
+    # @since 0.2.0
+    #
+    def self.lang
+      @lang ||= DEFAULT_LANG
+    end
+
+    #
+    # Sets the default language.
+    #
+    # @param [String] new_lang
+    #   The new language name.
+    #
+    # @return [String]
+    #   The name of the new default language.
+    #
+    # @since 0.2.0
+    #
+    def self.lang=(new_lang)
+      @lang = new_lang.to_s
+    end
+
+    # The directory name used to store user installed dictionaries.
+    USER_DIR = '.hunspell_default'
+
+    # Known directories to search within for dictionaries.
+    KNOWN_DIRECTORIES = [
+      # User
+      File.join(Gem.user_home,USER_DIR),
+      # OS X brew-instlled hunspell
+      File.join(Gem.user_home,'Library/Spelling'),
+      '/Library/Spelling',
+      # Debian
+      '/usr/local/share/myspell/dicts',
+      '/usr/share/myspell/dicts',
+      # Ubuntu
+      '/usr/share/hunspell',
+      # Fedora
+      '/usr/local/share/myspell',
+      '/usr/share/myspell',
+      # Mac Ports
+      '/opt/local/share/hunspell',
+      '/opt/share/hunspell'
+    ]
+
+    #
+    # The dictionary directories to search for dictionary files.
+    #
+    # @return [Array<String, Pathname>]
+    #   The directory paths.
+    #
+    # @since 0.2.0
+    #
+    def self.directories
+      @directories ||= KNOWN_DIRECTORIES.select do |path|
+        File.directory?(path)
+      end
+    end
+
+    def self.directories=(dirs)
+      @directories = dirs
+    end
+
+    #
+    # Opens a Hunspell dictionary.
+    #
+    # @param [Symbol, String] name
+    #   The name of the dictionary to open.
+    #
+    # @yield [dict]
+    #   The given block will be passed the Hunspell dictionary.
+    #
+    # @yieldparam [Dictionary] dict
+    #   The opened dictionary.
+    #
+    # @return [nil]
+    #
+    def self.dict(name=Hunspell.lang,&block)
+      Dictionary.open(name,&block)
+    end
+  end
+end

data/spec/dictionary_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+require 'ffi/hunspell/dictionary'
+
+describe Hunspell::Dictionary do
+  subject { described_class }
+
+  let(:lang) { 'en_US' }
+  let(:affix_path) { File.join(Hunspell.directories.last,"#{lang}.aff") }
+  let(:dic_path)   { File.join(Hunspell.directories.last,"#{lang}.dic") }
+
+  describe "#initialize" do
+    subject { described_class.new(affix_path,dic_path) }
+
+    it "should create a dictionary from '.aff' and '.dic' files" do
+      expect(subject.to_ptr).to_not be_nil
+    end
+
+    after { subject.close }
+  end
+
+  describe ".open" do
+    subject { described_class }
+
+    it "should find and open a dictionary file for a given language" do
+      subject.open(lang) do |dict|
+        expect(dict).to_not be_nil
+      end
+    end
+
+    it "should close the dictionary" do
+      dict = subject.open(lang)
+      dict.close
+
+      expect(dict).to be_closed
+    end
+
+    context "when given an unknown dictionary name" do
+      it "should raise an ArgumentError" do
+        expect {
+          subject.open('foo')
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context "when opened" do
+    subject { described_class.new(affix_path,dic_path) }
+
+    after { subject.close }
+
+    it "should provide the encoding of the dictionary files" do
+      expect(subject.encoding).to be Encoding::ISO_8859_1
+    end
+
+    it "should check if a word is valid" do
+      expect(subject.valid?('dog')).to be true
+      expect(subject.valid?('dxg')).to be false
+    end
+
+    describe "#add" do
+      it "should add a word" do
+        expect(subject.add('cat')).to be 0
+      end
+    end
+
+    describe "#add_with_affix" do
+      it "should add a word with an example word" do
+        expect(subject.add_with_affix('cat', 'agree')).to be 0
+        expect(subject.valid?('disagreeable')).to be true
+        expect(subject.valid?('discatable')).to be true
+      end
+    end
+
+    describe "#stem" do
+      it "should find the stems of a word" do
+        expect(subject.stem('fishing')).to be == %w[fishing fish]
+      end
+
+      it "should force_encode all strings" do
+        expect(subject.suggest('fishing')).to all satisfy { |string|
+          string.encoding == subject.encoding
+        }
+      end
+
+      context "when there are no stems" do
+        it "should return []" do
+          expect(subject.stem("zzzzzzz")).to be == []
+        end
+      end
+    end
+
+    describe "#suggest" do
+      it "should suggest alternate spellings for words" do
+        expect(subject.suggest('arbitrage')).to include(
+          'arbitrage',
+          'arbitrages',
+          'arbitrager',
+          'arbitraged',
+          'arbitrate'
+        )
+      end
+
+      it "should force_encode all strings" do
+        expect(subject.suggest('arbitrage')).to all satisfy { |string|
+          string.encoding == subject.encoding
+        }
+      end
+
+      context "when there are no suggestions" do
+        it "should return []" do
+          expect(subject.suggest("________")).to be == []
+        end
+      end
+    end
+  end
+end

data/spec/hunspell_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'ffi/hunspell/hunspell'
+
+describe Hunspell do
+  describe ".lang" do
+    subject { super().lang }
+
+    it "should have a default language" do
+      expect(subject).to_not be_nil
+      expect(subject).to_not be_empty
+    end
+  end
+
+  describe ".directories" do
+    subject { super().directories }
+
+    it "should have directories to search within" do
+      expect(subject).to_not be_empty
+    end
+  end
+
+  describe ".dict" do
+    it "should open a dictionary file" do
+      subject.dict('en_US') do |dict|
+        expect(dict).to_not be_nil
+      end
+    end
+
+    it "should open the dictionary file for the default language" do
+      subject.dict do |dict|
+        expect(dict).to_not be_nil
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'rspec'
+require 'ffi/hunspell'
+
+include FFI
+
+RSpec.configure do |specs|
+  specs.before(:suite) do
+    if ENV['HUNSPELL_ROOT']
+      Hunspell.directories << ENV['HUNSPELL_ROOT']
+    end
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: tolq-ffi-hunspell
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Postmodern
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-09-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rubygems-tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+description: Ruby FFI bindings for the Hunspell spell checker.
+email: postmodern.mod3@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- ChangeLog.md
+- LICENSE.txt
+- README.md
+files:
+- ".gemtest"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- ".yardopts"
+- ChangeLog.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- ffi-hunspell.gemspec
+- gemspec.yml
+- lib/ffi/hunspell.rb
+- lib/ffi/hunspell/dictionary.rb
+- lib/ffi/hunspell/hunspell.rb
+- spec/dictionary_spec.rb
+- spec/hunspell_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/postmodern/ffi-hunspell#readme
+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.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- libhunspell >= 1.2.0
+rubygems_version: 3.0.2
+signing_key: 
+specification_version: 4
+summary: FFI bindings for Hunspell
+test_files: []