worte 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d5d0ecb6b4947b4cc77c25c2c591f6752f6adf02
+  data.tar.gz: 665ef1e8b37121de5ebe170e04b018be3a673486
+SHA512:
+  metadata.gz: 76c11f99ddaa9e8ef5f94d7dbf1a0e77ff66fdefd98cff4216ceda67e10d595e1846a5f989a9bc7e96ceb3150ec34f7746f9e781b895b4779059a9e634c31988
+  data.tar.gz: 50b940b66d00a3d1ac27d9c0d1ed69875149b36a036f4ef1b9777eaefddc3c26b259d55c6443bff852d82442220db04c090126ceab4720c978e34ef80c0f9473

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+gemspec name: 'worte'
+
+gem 'rake', '~> 10.4.2'
+gem 'rspec', '~> 3.3.0'

data/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    worte (0.0.1)
+      ffi-aspell (~> 1.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    ffi (1.9.6)
+    ffi-aspell (1.1.0)
+      ffi
+    rake (10.4.2)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake (~> 10.4.2)
+  rspec (~> 3.3.0)
+  worte!

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Jonas Oberschweiber
+
+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,83 @@
+# worte - A simple Ruby spell checker
+
+[![Build Status](https://travis-ci.org/jonasoberschweiber/worte.svg?branch=master)](https://travis-ci.org/jonasoberschweiber/worte)
+
+Worte is a simple spell checker based on [ffi-aspell](https://github.com/YorickPeterse/ffi-aspell).
+It tokenizes strings, spell checks the tokens and can then print out the lines
+of the original text containing spelling mistakes.
+
+## Installation
+
+Just install it using `gem install worte` or add it to your Gemfile. Please note
+that worte depends on ffi-aspell, which requires an installation of aspell.
+
+## Usage
+
+Spell checking is done by `Worte::Worte`. Create a new instance, passing it the
+language you want to check:
+
+```ruby
+worte = Worte::Worte.new('en')
+```
+
+You can also pass in some options, most of which will be passed through to
+ffi-aspell. The most useful one might be `:personal`, which you can use to tell
+aspell the path to your personal word list. The word list has to be in a
+[specific format.](http://aspell.net/man-html/Format-of-the-Personal-and-Replacement-Dictionaries.html)
+
+The `:filter` and `:filters` option can be used to specify one or more filters.
+See below for details.
+
+Use the `check` method to spell check some text and get back a list of `Token`
+objects. The most important attributes of each token are `word`, `position` and
+`correct`.
+
+You can use the token list with one of the built-in printers to highlight
+spelling mistakes in the original text, or use the information contained in the
+token objects to do your own highlighting.
+
+### Filters
+
+Filters are used to filter out some parts of the original text before spell
+checking, e.g. URLs or formatting. They are simple Ruby classes that implement
+a `filter` method, which just takes a string and returns a string. A filter must
+replace the filtered out bits by space characters. Otherwise the positions in
+the tokens returned by check don't match the original text.
+
+Worte ships with two filters. The first is `Worte::Filter::URL`, which simply
+strips all URLs from the text. The other one is `Worte::Filter::Markdown`, which
+filters out Markdown formatting. The Markdown filter is still very much a work
+in progress!
+
+### Printing
+
+There are two printers included with worte: `Worte::Printer::Simple` and
+`Worte::Printer::Colorized`. The simple printer prints out all lines containing
+at least one spelling mistake and marks the mistake in the line below. Like
+this:
+
+```
+1: A sipmle spelling mistake.
+     ^^^^^^
+```
+
+The colorized variant prints out the markings in red.
+
+## Example
+
+```ruby
+require 'worte'
+
+text = "A sipmle spelling mistake"
+
+tokens = Worte::Worte.new('en').check(text)
+Worte::Printer::Simple.print(text, tokens)
+
+# Output:
+# 1: A sipmle spelling mistake
+#      ^^^^^^
+```
+
+## License
+
+Worte is licensed under the MIT license. See the `LICENSE` file for details.

data/Rakefile

@@ -0,0 +1,27 @@
+# These are shamelessly copied from https://github.com/jnunemaker/flipper
+
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+require "worte/version"
+
+desc 'Build gem into the pkg directory'
+task :build do
+  FileUtils.rm_rf('pkg')
+  system "gem build worte.gemspec"
+  FileUtils.mkdir_p('pkg')
+  FileUtils.mv(Dir['*.gem'], 'pkg')
+end
+
+desc 'Tags version, pushes to remote, and pushes gem'
+task :release => :build do
+  sh 'git', 'tag', "v#{Worte::VERSION}"
+  sh "git push origin master"
+  sh "git push origin v#{Worte::VERSION}"
+  sh "ls pkg/*.gem | xargs -n 1 gem push"
+end
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = %w(--color)
+end
+
+task :default => :spec

data/lib/worte/filter/markdown.rb

@@ -0,0 +1,12 @@
+module Worte
+  module Filter
+    class Markdown
+      def filter(str)
+        str = str.gsub(/^([ \t]*[#]+)/) { |c| ' ' * c.length }
+        str = str.gsub(/\*\*(.*?)\*\*/) { |c| '  ' + c[2..-3] + '  ' }
+        str = str.gsub(/\*(.*?)\*/) { |c| ' ' + c[1..-2] + ' ' }
+        str = str.gsub(/[!]?\[.*\]\(.*\)/) { |c| ' ' * c.length }
+      end
+    end
+  end
+end

data/lib/worte/filter/url.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'uri'
+
+module Worte
+  module Filter
+    class URL
+      def filter(str)
+        str.gsub(URI.regexp) { |c| ' ' * c.length }
+      end
+    end
+  end
+end

data/lib/worte/printer/colorized.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+module Worte
+  module Printer
+    class Colorized < Simple
+      def error_marker(length)
+        "\e[31m" + ('^' * length) + "\e[0m"
+      end
+    end
+  end
+end

data/lib/worte/printer/simple.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module Worte
+  module Printer
+    class Simple
+      def print(text, tokens, where=STDOUT)
+        text.split("\n").each_with_index do |line, l|
+          line_tokens = tokens.select { |t| t.position[0] == l }
+          if line_tokens.collect(&:correct).all?
+            next # Do not print lines without errors
+          end
+          where.print "#{l + 1}: "
+          where.puts line
+          col = 0
+          where.print ' ' * ((l + 1).to_s.length + 2)
+          line_tokens.each do |token|
+            if !token.correct
+              if col != token.position[1]
+                where.print (' ' * (token.position[1] - col))
+                col = token.position[1]
+              end
+              where.print error_marker(token.word.length)
+              col += token.word.length
+            end
+          end
+          where.puts
+        end
+      end
+
+      def error_marker(length)
+        '^' * length
+      end
+    end
+  end
+end

data/lib/worte/token.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module Worte
+  class Token
+    attr_accessor :word, :position, :correct, :newline
+
+    def initialize(word, position)
+      @word = word
+      @position = position
+      @correct = true
+      @newline = false
+    end
+  end
+end

data/lib/worte/tokenizer.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+# Inspired by tokenizer (https://github.com/arbox/tokenizer)
+
+FS = Regexp.new('[[:blank:]]+')
+
+BREAK = ['(', ')', '[', ']', '<', '>', '!', '?', ',', '.', ';', ':', '.', '"', "'"]
+
+module Worte
+  class Tokenizer
+    def tokenize(str)
+      reset
+
+      str.split("\n").each_with_index do |line, l|
+        @start_word = -1
+        @buf_word = ''
+        @last_token = nil
+
+        line.each_char.with_index do |ch, c|
+          case
+          when FS.match(ch) || BREAK.include?(ch)
+            add_token_from_buffer(l)
+          else
+            if @start_word == -1
+              @start_word = c
+            end
+            @buf_word += ch
+          end
+        end
+
+        add_token_from_buffer(l)
+
+        if !@last_token
+          # Add a dummy token that will get the newline flag
+          @last_token = Token.new('', [l, 0])
+          @tokens << @last_token
+        end
+
+        @last_token.newline = true
+      end
+
+      @tokens
+    end
+
+    private
+
+    def reset
+      @tokens = []
+      @start_word = -1
+      @buf_word = ''
+      @last_token = nil
+    end
+
+    def add_token_from_buffer(line)
+      if @buf_word.length > 0
+        @last_token = Token.new(@buf_word, [line, @start_word])
+        @tokens << @last_token
+        @buf_word = ''
+        @start_word = -1
+      end
+    end
+  end
+end

data/lib/worte/version.rb

@@ -0,0 +1,3 @@
+module Worte
+  VERSION = '0.0.1'
+end

data/lib/worte/worte.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'ffi/aspell'
+
+module Worte
+  class Worte
+    def initialize(language, options={})
+      @language = language
+
+      @filters = options.delete(:filters) || []
+      single_filter = options.delete(:filter)
+      @filters << single_filter if single_filter
+
+      @options = options
+    end
+
+    def check(str)
+      @filters.each do |filter|
+        str = filter.filter(str)
+      end
+      tokens = Tokenizer.new.tokenize(str)
+      FFI::Aspell::Speller.open(@language, @options) do |speller|
+        tokens.each do |token|
+          token.correct = speller.correct?(token.word)
+        end
+      end
+      tokens
+    end
+  end
+end

data/lib/worte.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+require 'worte/token'
+require 'worte/tokenizer'
+require 'worte/printer/simple'
+require 'worte/printer/colorized'
+require 'worte/filter/url'
+require 'worte/filter/markdown'
+require 'worte/worte'

data/spec/colorized_printer_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Worte::Printer::Colorized do
+  it "marks incorrect tokens with red marker" do
+    pr = Worte::Printer::Colorized.new
+    o = StringIO.new
+    sample = "This is a simple test"
+    tokens = Worte::Tokenizer.new.tokenize(sample)
+    tokens[3].correct = false
+    pr.print(sample, tokens, o)
+    expect(o.string.split("\n")[1]).to start_with("             \e[31m^^^^^^\e[0m")
+  end
+end

data/spec/simple_printer_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Worte::Printer::Simple do
+  TEXT = <<-EOF
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aenean vitae mi neque. Sed tempus libero placerat tellus
+scelerisque condimentum. Nunc augue orci, aliquam sit amet lacus sit amet, volutpat molestie tellus. In eu egestas erat, et
+fringilla orci. Suspendisse est ipsum, scelerisque varius porta a, ornare non dolor. Sed placerat ex risus. Donec posuere
+fringilla ornare. Aliquam suscipit gravida ex sit amet rhoncus. Vivamus fringilla dui ut dui fermentum, eu volutpat justo
+vulputate. Sed ut semper ipsum. Pellentesque varius tempus congue. Duis ullamcorper gravida velit non rhoncus. Nulla
+facilisi. In vel placerat mauris, semper venenatis metus. Sed efficitur, metus eu efficitur placerat, lacus diam pharetra
+lectus, a accumsan ante mi ut neque. Integer vitae posuere nisl.
+  EOF
+
+  it "skips lines without incorrect tokens" do
+    pr = Worte::Printer::Simple.new
+    o = StringIO.new
+    tokens = Worte::Tokenizer.new.tokenize(TEXT)
+    pr.print(TEXT, tokens, o)
+    expect(o.string.length).to eq(0)
+  end
+
+  it "prints line numbers" do
+    pr = Worte::Printer::Simple.new
+    o = StringIO.new
+    tokens = Worte::Tokenizer.new.tokenize(TEXT)
+    tokens[40].correct = false
+    pr.print(TEXT, tokens, o)
+    expect(o.string).to start_with('3: ')
+  end
+
+  it "marks incorrect words" do
+    pr = Worte::Printer::Simple.new
+    o = StringIO.new
+    sample = "This is a simple test"
+    tokens = Worte::Tokenizer.new.tokenize(sample)
+    tokens[3].correct = false
+    pr.print(sample, tokens, o)
+    expect(o.string.split("\n")[1]).to start_with('             ^^^^^^')
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,101 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+$:.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'worte'
+
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # 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
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/spec/tokenizer_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Worte::Tokenizer do
+  it "sets newline flag on last token in line" do
+    t = Worte::Tokenizer.new
+    token = t.tokenize("test\n").first
+    expect(token.newline).to be(true)
+  end
+
+  it "sets all tokens correct after tokenization" do
+    t = Worte::Tokenizer.new
+    tokens = t.tokenize("test test2 test3")
+    expect(tokens.collect(&:correct).all?).to be(true)
+  end
+
+  it "removes parens and brackets" do
+    t = Worte::Tokenizer.new
+    tokens = t.tokenize("(test1) [test2] <test3>")
+    expect(tokens.length).to eq(3)
+    expect(tokens[0].word).to eq('test1')
+    expect(tokens[1].word).to eq('test2')
+    expect(tokens[2].word).to eq('test3')
+  end
+
+  it "breaks on punctuation" do
+    t = Worte::Tokenizer.new
+    tokens = t.tokenize("Ich, ging! Nach. Hause? Nicht: so; schnell")
+    expect(tokens.length).to eq(7)
+    %w(Ich ging Nach Hause Nicht so schnell).each_with_index do |e, i|
+      expect(tokens[i].word).to eq(e)
+    end
+  end
+
+  it "breaks on quotes" do
+    t = Worte::Tokenizer.new
+    tokens = t.tokenize("'Hello' sweet \"World\"")
+    expect(tokens.length).to eq(3)
+    %w(Hello sweet World).each_with_index do |e, i|
+      expect(tokens[i].word).to eq(e)
+    end
+  end
+
+  it "stores position in token" do
+    t = Worte::Tokenizer.new
+    tokens = t.tokenize("a bcd \n efg ")
+    expect(tokens[0].position).to eq([0, 0])
+    expect(tokens[1].position).to eq([0, 2])
+    expect(tokens[2].position).to eq([1, 1])
+  end
+end

data/spec/url_filter_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Worte::Filter::URL do
+  it "replaces urls with spaces" do
+    f = Worte::Filter::URL.new
+    t = f.filter('Test http://google.de Test')
+    expect(t).to eq('Test                  Test')
+  end
+end

data/worte.gemspec

@@ -0,0 +1,23 @@
+require File.expand_path('../lib/worte/version', __FILE__)
+
+ignored_files = [".travis.yml", ".gitignore"]
+ignored_files.uniq!
+
+ignored_test_files = []
+
+Gem::Specification.new do |gem|
+  gem.authors = ["Jonas Oberschweiber"]
+  gem.email = ["jonas@oberschweiber.com"]
+  gem.summary = %q{Simple spell checker based on ffi-aspell}
+  gem.description = %q{A simple spell checker based on ffi-aspell. Tokenizes texts, checks them and prints them out.}
+  gem.homepage = "https://github.com/jonasoberschweiber/worte"
+  gem.license = "MIT"
+
+  gem.files         = `git ls-files`.split("\n") - ignored_files + ["lib/worte/version.rb"]
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n") - ignored_test_files
+  gem.require_paths = ["lib"]
+  gem.name = "worte"
+  gem.version = Worte::VERSION
+
+  gem.add_runtime_dependency "ffi-aspell", ["~> 1.1.0"]
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: worte
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jonas Oberschweiber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi-aspell
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+description: A simple spell checker based on ffi-aspell. Tokenizes texts, checks them
+  and prints them out.
+email:
+- jonas@oberschweiber.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/worte.rb
+- lib/worte/filter/markdown.rb
+- lib/worte/filter/url.rb
+- lib/worte/printer/colorized.rb
+- lib/worte/printer/simple.rb
+- lib/worte/token.rb
+- lib/worte/tokenizer.rb
+- lib/worte/version.rb
+- lib/worte/worte.rb
+- spec/colorized_printer_spec.rb
+- spec/simple_printer_spec.rb
+- spec/spec_helper.rb
+- spec/tokenizer_spec.rb
+- spec/url_filter_spec.rb
+- worte.gemspec
+homepage: https://github.com/jonasoberschweiber/worte
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Simple spell checker based on ffi-aspell
+test_files:
+- spec/colorized_printer_spec.rb
+- spec/simple_printer_spec.rb
+- spec/spec_helper.rb
+- spec/tokenizer_spec.rb
+- spec/url_filter_spec.rb