freeling-analyzer 0.1.0

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+*.swp
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  #- "1.8.7"
+  - "1.9.2"
+  - "1.9.3"
+  #- jruby-18mode # JRuby in 1.8 mode
+  #- jruby-19mode # JRuby in 1.9 mode
+  #- rbx-18mode
+  #- rbx-19mode

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem "mocha", :require => false
+
+# Specify your gem's dependencies in freeling-analyzer.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,17 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :minitest do
+  # with Minitest::Unit
+  #watch(%r|^test/(.*)\/?test_(.*)\.rb|)
+  #watch(%r|^lib/(.*)([^/]+)\.rb|)     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
+  #watch(%r|^test/test_helper\.rb|)    { "test" }
+  watch(%r{^lib/(.+)\.rb$})     { |m| "test/#{m[1].split("/").last}_test.rb" }
+  watch(%r{^test/.+_test\.rb$})
+  watch('test/test_helper.rb')  { "test" }
+
+  # with Minitest::Spec
+  # watch(%r|^spec/(.*)_spec\.rb|)
+  # watch(%r|^lib/(.*)([^/]+)\.rb|)     { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  # watch(%r|^spec/spec_helper\.rb|)    { "spec" }
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Damián Silvani
+
+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,85 @@
+# Freeling::Analyzer [![Build Status](https://secure.travis-ci.org/munshkr/freeling-analyzer-ruby.png?branch=master)](https://travis-ci.org/munshkr/freeling-analyzer-ruby)
+
+**FreeLing::Analyzer** is a Ruby wrapper around `analyzer`, a binary tool
+included in FreeLing's package that allows the user to process a stream of text
+with FreeLing.
+
+*This has been tested with version 3.0+ only*.
+
+## Usage
+
+```ruby
+text = "Mi amigo Juan Mesa se mesa la barba al lado de la mesa."
+analyzer = FreeLing::Analyzer.new(text, :language => :es)
+
+analyzer.tokens.first
+# => #<FreeLing::Analyzer::Token form="Mi" lemma="mi" prob=0.995536 tag="DP1CSS">
+
+analyzer.tokens.map { |t| t.lemma }
+# => ["mi", "amigo", "juan_mesa", "se", "mesar", "el", "barba", "a+el", "lado", "de", "el", "mesa", "."]
+```
+
+## Features
+
+* Analyzer is *lazy*, it does not spawn the process until needed and it sends
+  the input text to `analyzer` on demand.
+* It just works with the default instalation of FreeLing. Just set the language
+  to use and you're good to go.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'freeling-analyzer'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install freeling-analyzer
+
+## FreeLing
+
+[FreeLing](http://nlp.lsi.upc.edu/freeling/) is an open source suite of
+language analyzers written in C++.
+
+The main services offered are:
+  * Text tokenization
+  * Sentence splitting
+  * Morphological analysis
+  * Suffix treatment
+  * Retokenization of clitic pronouns
+  * Flexible multiword recognition
+  * Contraction splitting
+  * Probabilistic prediction of unkown word categories
+  * Named entity detection (NER)
+  * Recognition of dates, numbers, ratios, currency, and physical magnitudes
+    (speed, weight, temperature, density, etc.)
+  * PoS tagging
+  * Chart-based shallow parsing
+  * Named entity classification (NEC)
+  * WordNet based sense annotation and disambiguation
+  * Rule-based dependency parsing
+  * Nominal correference resolution.
+
+Currently supported languages are:
+  * Spanish
+  * Catalan
+  * Galician
+  * Italian
+  * English
+  * Welsh
+  * Portuguese
+  * Asturian
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << "lib" << "test"
+  t.test_files = FileList["test/*_test.rb"]
+  t.verbose = true
+end
+
+task :default => :test

data/freeling-analyzer.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/freeling/analyzer/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Damián Silvani"]
+  gem.email         = ["munshkr@gmail.com"]
+  gem.summary       = %q{Ruby wrapper for FreeLing's analyzer tool}
+  gem.description   = %q{FreeLing::Analyzer is a Ruby wrapper around
+                         `analyzer`, a binary tool included in FreeLing's
+                         package that allows the user to process a stream of
+                         text with FreeLing.}
+  gem.homepage      = "https://github.com/munshkr/freeling-analyzer-ruby"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "freeling-analyzer"
+  gem.require_paths = ["lib"]
+  gem.version       = FreeLing::Analyzer::VERSION
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "yard"
+  gem.add_development_dependency "mocha", "~> 0.13.3"
+  gem.add_development_dependency "minitest"
+  gem.add_development_dependency "minitest-wscolor"
+  gem.add_development_dependency "guard"
+  gem.add_development_dependency "guard-minitest"
+
+  gem.add_runtime_dependency "hashie"
+end

data/lib/freeling-analyzer.rb

@@ -0,0 +1 @@
+require "freeling/analyzer"

data/lib/freeling/analyzer.rb

@@ -0,0 +1,129 @@
+require "open3"
+require "hashie/mash"
+require "freeling/analyzer/process_wrapper"
+require "freeling/analyzer/freeling_default"
+
+module FreeLing
+  class Analyzer
+    attr_reader :document, :latest_error_log
+
+    Token = Class.new(Hashie::Mash)
+
+    def initialize(document, opts={})
+      @document = document
+
+      @options = {
+        :share_path    => freeling_path,
+        :analyze_path  => analyzer_path,
+        :input_format  => :plain,
+        :output_format => :tagged,
+        :memoize       => true,
+        :language      => :es
+      }.merge(opts)
+    end
+
+    def sentences(run_again=false)
+      if @options[:output_format] == :token
+        raise "Sentence splitter is not available with output format set to 'token'"
+      end
+
+      if not run_again and @sentences
+        return @sentences.to_enum
+      end
+
+      Enumerator.new do |yielder|
+        tokens = []
+        read_tokens.each do |token|
+          if token
+            tokens << token
+          else
+            yielder << tokens
+            if @options[:memoize]
+              @sentences ||= []
+              @sentences << tokens
+            end
+            tokens = []
+          end
+        end
+      end
+    end
+
+    def tokens(run_again=false)
+      if not run_again and @tokens
+        return @tokens.to_enum
+      end
+
+      if @sentences
+        @tokens ||= @sentences.flatten
+        return @tokens.to_enum
+      end
+
+      Enumerator.new do |yielder|
+        read_tokens.each do |token|
+          if token
+            yielder << token
+            if @options[:memoize]
+              @tokens ||= []
+              @tokens << token
+            end
+          end
+        end
+      end
+    end
+
+
+  private
+    def command
+      "#{@options[:analyze_path]} " \
+        "-f #{config_path} " \
+        "--inpf #{@options[:input_format]} " \
+        "--outf #{@options[:output_format]} " \
+        "--nec " \
+        "--noflush"
+    end
+
+    def config_path
+      @options[:config_path] || File.join(language_config, "#{@options[:language]}.cfg")
+    end
+
+    def read_tokens
+      Enumerator.new do |yielder|
+        output_fd = @document.respond_to?(:read) ? @document : StringIO.new(@document)
+        @process_wrapper = ProcessWrapper.new(command, output_fd, "FREELINGSHARE" => @options[:share_path])
+
+        @process_wrapper.run.each do |line|
+          if not line.empty?
+            yielder << parse_token_line(line)
+          end
+        end
+
+        @latest_error_log = @process_wrapper.error_log
+
+        @process_wrapper.close
+        @process_wrapper = nil
+      end
+    end
+
+    def parse_token_line(str)
+      form, lemma, tag, prob = str.split(' ')[0..3]
+      Token.new({
+        :form => form,
+        :lemma => lemma,
+        :tag => tag,
+        :prob => prob && prob.to_f,
+      }.reject { |k, v| v.nil? })
+    end
+
+    def language_config
+      FreelingDefault.language_config
+    end
+
+    def freeling_path
+      FreelingDefault.freeling_path
+    end
+
+    def analyzer_path
+      FreelingDefault.analyzer_path
+    end
+  end
+end

data/lib/freeling/analyzer/freeling_default.rb

@@ -0,0 +1,57 @@
+module FreeLing
+  class Analyzer
+    class FreelingDefault
+
+      LOCAL_ANALYZE_PATH         = "/usr/local/bin/analyzer"
+      USR_ANALYZE_PATH           = "/usr/bin/analyzer"
+      LOCAL_FREELING_SHARE_PATH  = "/usr/local/share/freeling"
+      USR_FREELING_SHARE_PATH    = "/usr/share/freeling"
+
+      class << self
+        def analyzer_path
+          self.new.analyzer_path
+        end
+
+        def freeling_path
+          self.new.freeling_path
+        end
+
+        def language_config
+          self.new.language_config
+        end
+      end
+
+      def language_config
+        if freeling_path.instance_of? String
+          File.join(freeling_path, "config")
+        else
+          raise_error(:analyze)
+        end
+      end
+
+      def analyzer_path
+        if File.exists? LOCAL_ANALYZE_PATH
+          LOCAL_ANALYZE_PATH
+        elsif File.exists? USR_ANALYZE_PATH
+          USR_ANALYZE_PATH
+        else
+          raise_error(:analyze)
+        end
+      end
+
+      def freeling_path
+        if Dir.exists? LOCAL_FREELING_SHARE_PATH
+          LOCAL_FREELING_SHARE_PATH
+        elsif Dir.exists? USR_FREELING_SHARE_PATH
+          USR_FREELING_SHARE_PATH
+        else
+          raise_error(:freeling)
+        end
+      end
+
+      def raise_error(type)
+        raise "#{type} is not installed."
+      end
+    end
+  end
+end

data/lib/freeling/analyzer/process_wrapper.rb

@@ -0,0 +1,82 @@
+require "enumerator"
+require "thread"
+require "open3"
+
+module FreeLing
+  class Analyzer
+    class ProcessWrapper
+      attr_accessor :command, :output_fd, :env, :error_log
+
+      def initialize(command, output_fd, env={})
+        @command = command
+        @output_fd = output_fd
+        @env = env
+        @error_log = nil
+      end
+
+      def run
+        @error_log = nil
+
+        Enumerator.new do |yielder|
+          open_process
+
+          if @stdout.nil?
+            run_process
+          end
+
+          while line = @stdout.gets
+            line.chomp!
+            yielder << line
+          end
+
+          @stdout.close_read
+          @error_log = @stderr.read
+          @write_thr.join
+          close_process
+        end
+      end
+
+      def close
+        close_process
+      end
+
+    private
+      def open_process
+        @stdin, @stdout, @stderr, @wait_thr = Open3.popen3(@env, command)
+
+        @write_thr = Thread.new do
+          begin
+            IO.copy_stream(@output_fd, @stdin)
+            @stdin.close_write
+          rescue Errno::EPIPE
+            @error_log = @stderr.read
+          end
+        end
+      end
+
+      def close_process
+        close_fds
+        kill_threads
+        @stdin = @stdout = @stderr = nil
+        @wait_thr = @write_thr = nil
+      end
+
+      def close_fds
+        [@stdin, @stdout, @stderr].each do |fd|
+          if fd and not fd.closed?
+            fd.close
+          end
+        end
+      end
+
+      def kill_threads
+        [@wait_thr, @write_thr].each do |thr|
+          if thr and thr.alive?
+            thr.kill
+          end
+        end
+      end
+
+    end # ProcessWrapper
+  end # Analyzer
+end # FreeLing

data/lib/freeling/analyzer/version.rb

@@ -0,0 +1,5 @@
+module FreeLing
+  class Analyzer
+    VERSION = "0.1.0"
+  end
+end

data/test/analyzer_test.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+require "test_helper"
+
+class AnalyzerTest < MiniTest::Unit::TestCase
+  def setup
+    @a = "El gato come pescado y bebe agua."
+    @b = "Yo bajo con el hombre bajo a tocar el bajo bajo la escalera."
+    @c = "Mi amigo Juan Mesa se mesa la barba al lado de la mesa."
+  end
+
+  def test_token_attributes
+    skip
+
+    expected_token = { form: "El", lemma: "el", prob: 1, tag: "DA0MS0" }
+
+    analyzer = FreeLing::Analyzer.new(@a, :language => :es)
+    token = analyzer.tokens.first
+
+    [:form, :lemma, :prob, :tag].each do |key|
+      assert_equal expected_token[key], token[key]
+    end
+  end
+
+  def test_token_list
+    skip
+
+    expected_tokens = [
+      { form: "El", lemma: "el", prob: 1, tag: "DA0MS0" },
+      { form: "gato", lemma: "gato", prob: 1, tag: "NCMS000" },
+      { form: "come", lemma: "comer", prob: 0.75, tag: "VMIP3S0" },
+      { form: "pescado", lemma: "pescado", prob: 0.833333, tag: "NCMS000" },
+      { form: "y", lemma: "y", prob: 0.999812, tag: "CC" },
+      { form: "bebe", lemma: "beber", prob: 0.994868, tag: "VMIP3S0" },
+      { form: "agua", lemma: "agua", prob: 0.973333, tag: "NCCS000" },
+      { form: ".", lemma: ".", prob: 1, tag: "Fp" },
+    ]
+
+    analyzer = FreeLing::Analyzer.new(@a, :language => :es)
+    analyzer.tokens.each.with_index do |token, i|
+      [:form, :lemma, :prob, :tag].each do |key|
+        assert_equal expected_tokens[i][key], token[key]
+      end
+    end
+  end
+end

data/test/freeling_default_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+class FreelingDefaultTest < MiniTest::Unit::TestCase
+  def setup
+    @usr_bin_analyzer     = "/usr/bin/analyzer"
+    @local_bin_analyzer   = "/usr/local/bin/analyzer"
+    @usr_share_freeling   = "/usr/share/freeling"
+    @local_share_freeling = "/usr/local/share/freeling"
+  end
+
+  def test_freeling_installed_on_usr
+    File.stubs("exists?").with(@usr_bin_analyzer).returns(true)
+    File.stubs("exists?").with(@local_bin_analyzer).returns(false)
+
+    FreeLing::Analyzer::FreelingDefault.analyzer_path.must_equal @usr_bin_analyzer
+  end
+
+  def test_freeling_installed_on_local
+    File.stubs("exists?").with(@usr_bin_analyzer).returns(false)
+    File.stubs("exists?").with(@local_bin_analyzer).returns(true)
+
+    FreeLing::Analyzer::FreelingDefault.analyzer_path.must_equal @local_bin_analyzer
+  end
+
+  def test_freeling_not_installed
+    File.stubs("exists?").with(@usr_bin_analyzer).returns(false)
+    File.stubs("exists?").with(@local_bin_analyzer).returns(false)
+
+    lambda {
+      FreeLing::Analyzer::FreelingDefault.analyzer_path.must_equal @local_bin_analyzer
+    }.must_raise RuntimeError
+  end
+
+  def test_instanciate_analyzer
+    File.stubs("exists?").with(@local_bin_analyzer).returns(true)
+    Dir.stubs("exists?").with(@local_share_freeling).returns(true)
+    document = mock("document")
+
+    assert FreeLing::Analyzer.new document
+  end
+end

data/test/process_wrapper_test.rb

@@ -0,0 +1,89 @@
+require "test_helper"
+
+class ProcessWrapperTest < MiniTest::Unit::TestCase
+  def setup
+    @command = "cat"
+    @text = ["Hello", "world!"]
+    @output_fd = StringIO.new(@text.join("\n"))
+    @pw = FreeLing::Analyzer::ProcessWrapper.new(@command, @output_fd)
+  end
+
+  def test_constructor_paramenters_can_be_read
+    assert_equal @command, @pw.command
+    assert_equal @output_fd, @pw.output_fd
+    assert_equal({}, @pw.env)
+  end
+
+  def test_constructor_paramenters_can_be_written
+    assert_equal @command, @pw.command
+    @pw.command = "cat -n"
+    assert_equal "cat -n", @pw.command
+
+    assert_equal @output_fd, @pw.output_fd
+    new_text_io = StringIO.new("New text")
+    @pw.output_fd = new_text_io
+    assert_equal new_text_io, @pw.output_fd
+
+    assert_equal({}, @pw.env)
+    @pw.env["FREELINGSHARE"] = "/usr/local/share/freeling"
+    assert_equal({
+      "FREELINGSHARE" => "/usr/local/share/freeling"
+    }, @pw.env)
+  end
+
+  def test_command_can_be_changed_once_wrapper_was_created
+    assert_equal @command, @pw.command
+    @pw.command = "cat -n"
+    assert_equal "cat -n", @pw.command
+  end
+
+  def test_run_returns_an_enumerator
+    enum = @pw.run
+    assert_instance_of Enumerator, enum
+  end
+
+  def test_run_returns_process_output_per_line
+    assert_equal @text, @pw.run.to_a
+  end
+
+  def test_run_twice_without_rewinding_output_fd
+    assert_equal @text, @pw.run.to_a
+    assert @pw.output_fd.eof?
+    assert_equal [], @pw.run.to_a
+  end
+
+  def test_run_twice_but_rewind_output_fd_after_first_run
+    assert_equal @text, @pw.run.to_a
+    assert @pw.output_fd.eof?
+    @pw.output_fd.rewind
+    assert_equal @text, @pw.run.to_a
+  end
+
+  def test_another_command
+    @pw.command = "cat -n"
+    assert_equal ["     1\tHello", "     2\tworld!"], @pw.run.to_a
+  end
+
+  def test_invalid_command
+    @pw.command = "inexistant_command"
+    assert_raises(Errno::ENOENT) { @pw.run.first }
+  end
+
+  def test_custom_env_variables
+    @pw.env["MY_VARIABLE"] = "foobar"
+    @pw.command = "echo $MY_VARIABLE"
+    assert_equal "foobar", @pw.run.first
+  end
+
+  def test_run_process_that_only_prints_to_stderr
+    @pw.command = "echo 'this is only printed on stderr' > /dev/fd/2"
+    assert @pw.run.first.nil?
+    assert @pw.error_log = "this is only printed on stderr\n"
+  end
+
+  def test_close_process_early
+    @pw.command = "echo '1\n2\n3'"
+    assert_equal @pw.run.first, "1"
+    @pw.close
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+require "minitest/autorun"
+require "minitest/wscolor"
+require "mocha/setup"
+
+require "freeling/analyzer"

metadata

@@ -0,0 +1,203 @@
+--- !ruby/object:Gem::Specification
+name: freeling-analyzer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Damián Silvani
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.13.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.13.3
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-wscolor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "FreeLing::Analyzer is a Ruby wrapper around\n                         `analyzer`,
+  a binary tool included in FreeLing's\n                         package that allows
+  the user to process a stream of\n                         text with FreeLing."
+email:
+- munshkr@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- freeling-analyzer.gemspec
+- lib/freeling-analyzer.rb
+- lib/freeling/analyzer.rb
+- lib/freeling/analyzer/freeling_default.rb
+- lib/freeling/analyzer/process_wrapper.rb
+- lib/freeling/analyzer/version.rb
+- test/analyzer_test.rb
+- test/freeling_default_test.rb
+- test/process_wrapper_test.rb
+- test/test_helper.rb
+homepage: https://github.com/munshkr/freeling-analyzer-ruby
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -171360197096185165
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -171360197096185165
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Ruby wrapper for FreeLing's analyzer tool
+test_files:
+- test/analyzer_test.rb
+- test/freeling_default_test.rb
+- test/process_wrapper_test.rb
+- test/test_helper.rb
+has_rdoc: