splitta 4.2.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6d8e46cae786dd0a359ae4ba07fc88991c8655957635a12e24acc73954005a9c
+  data.tar.gz: 835385acb2401790fd2c077607c77b7a45621e02317b8b83fd7cff869898aefc
+SHA512:
+  metadata.gz: 698ac3cbdaf4671b86f931e963c2b1bd7cbb193c381ac4ffb5817b66a6849a8da8a28c73ce2a1a322e6891736765802a80f1e7a43da4ff977e998b97e5adb392
+  data.tar.gz: f959bd4dd3a79f687321aafc78fd1e20e8f39964610da758779d7b52038232b3f41e150ea5c11b197b8bd58313c048a956a069eeb5a89e8b4bd3477b2bbe9cd7

data/.codeclimate.yml

@@ -0,0 +1,20 @@
+---
+engines:
+  duplication:
+    enabled: true
+    config:
+      languages:
+      - ruby
+    checks:
+      Similar code:
+        enabled: false
+  fixme:
+    enabled: true
+  rubocop:
+    enabled: true
+    channel: rubocop-0-85
+ratings:
+  paths:
+  - "**.rb"
+exclude_paths:
+- spec/

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/html/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rubocop.yml

@@ -0,0 +1,135 @@
+AllCops:
+  Exclude:
+    - splitta.gemspec
+    - Rakefile
+
+Layout/EmptyLinesAroundAttributeAccessor:
+  Enabled: true
+
+Layout/EmptyLinesAroundClassBody:
+  EnforcedStyle: empty_lines_except_namespace
+
+Layout/EmptyLinesAroundModuleBody:
+  EnforcedStyle: empty_lines_except_namespace
+
+Layout/ExtraSpacing:
+  Enabled: false
+
+Layout/LineLength:
+  Max: 120
+  Enabled: false
+
+Layout/SpaceAroundMethodCallOperator:
+  Enabled: true
+
+Lint/DeprecatedOpenSSLConstant:
+  Enabled: true
+
+Lint/MixedRegexpCaptureTypes:
+  Enabled: true
+
+Lint/RaiseException:
+  Enabled: true
+
+Lint/StructNewOverride:
+  Enabled: true
+
+Metrics/AbcSize:
+  Max: 50
+  Enabled: false
+
+Metrics/BlockLength:
+  Max: 50
+  Enabled: false
+
+Metrics/ClassLength:
+  Max: 50
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Max: 30
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 20
+  Enabled: false
+
+Metrics/ModuleLength:
+  Max: 1000
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Max: 30
+  Enabled: false
+
+Security/MarshalLoad:
+  Enabled: false
+
+Style/AndOr:
+  Enabled: false
+
+Style/CaseEquality:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/ExponentialNotation:
+  Enabled: true
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/GuardClause:
+  Enabled: false
+
+Style/HashEachMethods:
+  Enabled: true
+
+Style/HashTransformKeys:
+  Enabled: true
+
+Style/HashTransformValues:
+  Enabled: true
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/MultilineBlockChain:
+  Enabled: false
+
+Style/MultilineIfModifier:
+  Enabled: false
+
+Style/MutableConstant:
+  Enabled: false
+
+Style/RedundantRegexpCharacterClass:
+  Enabled: true
+
+Style/RedundantRegexpEscape:
+  Enabled: true
+
+Style/RescueModifier:
+  Enabled: false
+
+Style/RescueStandardError:
+  Enabled: false
+
+Style/SlicingWithRange:
+  Enabled: true
+
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/ZeroLengthPredicate:
+  Enabled: false

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.5.1

data/.travis.yml

@@ -0,0 +1,15 @@
+env:
+  global:
+    - CC_TEST_REPORTER_ID=35dd438da367278dc0d80cb7e21b3b0cd6eb207f60890a05c3fe1f0882981e64
+language: ruby
+rvm:
+  - 2.5.1
+before_install: gem install bundler -v 1.17.3
+before_script:
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
+  - ./cc-test-reporter before-build
+script:
+  - bundle exec rspec
+after_script:
+  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at david@bloomfire.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 David McCullars
+
+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,47 @@
+# Ruby Splitta
+
+* README:         https://github.com/david-mccullars/ruby-splitta
+* Documentation:  http://www.rubydoc.info/github/david-mccullars/ruby-splitta
+* Bug Reports:    https://github.com/david-mccullars/ruby-splitta/issues
+
+
+## Status
+
+[![Gem Version](https://badge.fury.io/rb/splitta.svg)](https://badge.fury.io/rb/splitta)
+[![Travis Build Status](https://travis-ci.org/david-mccullars/ruby-splitta.svg?branch=master)](https://travis-ci.org/david-mccullars/ruby-splitta)
+[![Code Climate](https://codeclimate.com/github/david-mccullars/ruby-splitta/badges/gpa.svg)](https://codeclimate.com/github/david-mccullars/ruby-splitta)
+[![Test Coverage](https://codeclimate.com/github/david-mccullars/ruby-splitta/badges/coverage.svg)](https://codeclimate.com/github/david-mccullars/ruby-splitta/coverage)
+
+## Description
+
+[Splitta](https://code.google.com/archive/p/splitta/) Includes proper
+tokenization and models for very high accuracy sentence boundary detection
+(English only for now). The models are trained from Wall Street Journal news
+combined with the Brown Corpus which is intended to be widely representative of
+written English. Error rates on test news data are near 0.25%.
+
+## Installation
+
+```
+gem install splitta
+```
+
+## Requirements
+
+* Ruby 2.5.1 or higher
+
+## Usage
+
+```ruby
+require 'splitta'
+
+Splitta.sentences("Some text goes here.")
+```
+
+## License
+
+MIT. See the `LICENSE` file.
+
+## References
+
+> Dan Gillick, “Sentence Boundary Detection and the Problem with the U.S.” at NAACL 2009, http://dgillick.com/resource/sbd_naacl_2009.pdf

data/Rakefile

@@ -0,0 +1,55 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+require 'rdoc/task'
+RDoc::Task.new do |rdoc|
+  rdoc.main = "README.md"
+  rdoc.rdoc_files.include("README.md", "lib/**/*.rb")
+end
+
+def unpickle(file)
+  require 'rubypython'
+
+  RubyPython.run do
+    cPickle = import 'cPickle'
+    gzip = import 'gzip'
+
+    io = gzip.open(file, 'rb')
+    data = cPickle.load(io)
+    io.close()
+
+    data = data.rubify
+    if data.keys.first.is_a?(RubyPython::Tuple)
+      data = data.each_with_object({}) do |(k, v), h|
+        h[k.to_a] = v
+      end
+    end
+
+    return data
+  end
+end
+
+def gzip_dump(file, obj)
+  require 'fileutils'
+  require 'zlib'
+
+  FileUtils.mkdir_p(File.dirname(file))
+  Zlib::GzipWriter.open(file) do |gz|
+    gz.write(Marshal.dump(obj))
+  end
+end
+
+task :unpickle, [:file] do |_t, args|
+  files = Dir[args[:file] || 'data/src/**/*'].select do |f|
+    File.file?(f)
+  end
+
+  files.each do |src|
+    puts "Unpickling #{src} ..."
+    gzip_dump(src.sub('/src/', '/'), unpickle(src))
+  end
+end

data/lib/splitta.rb

@@ -0,0 +1,21 @@
+require 'singleton'
+require 'zlib'
+
+##
+# Provides convenience methods for splitting text into sentences.
+#
+# @see README
+##
+module Splitta
+
+  autoload :Doc,              'splitta/doc'
+  autoload :Frag,             'splitta/frag'
+  autoload :Model,            'splitta/model'
+  autoload :VERSION,          'splitta/version'
+  autoload :WordTokenizer,    'splitta/word_tokenizer'
+
+  def self.sentences(text)
+    Doc.new(text, model: Model.instance).segments.map(&:strip)
+  end
+
+end

data/lib/splitta/doc.rb

@@ -0,0 +1,50 @@
+#
+# A Document points to a collection of Frags
+#
+module Splitta
+  class Doc
+
+    FRAG_SPLITTER = /
+      (
+        [.!?]         # sentence end punctuation
+        (?:
+          (?:<.*>)    # extra tag
+          |
+          [”"')\]}]   # right-handed punctuation to retain
+        )*
+        \s+           # must have whitespace
+      )
+    /ux
+
+    SEGMENT_THRESHOLD = 0.5
+
+    attr_reader :frags
+
+    def initialize(text, model:)
+      @frags = []
+      text.split(FRAG_SPLITTER).each_slice(2) do |frag_text|
+        frag = Frag.new(frag_text.join, previous_frag: @frags.last)
+        @frags << frag
+      end
+      model.classify(self)
+    end
+
+    #
+    # output all the text, split according to predictions
+    #
+    def segments
+      Enumerator.new do |y|
+        io = StringIO.new
+        frags.each do |frag|
+          io << frag.orig
+          if frag.over?(SEGMENT_THRESHOLD)
+            y << io.string
+            io.string = ''
+          end
+        end
+        y << io.string unless io.string.empty?
+      end
+    end
+
+  end
+end

data/lib/splitta/frag.rb

@@ -0,0 +1,101 @@
+#
+# A fragment of text that ends with a possible sentence boundary
+#
+module Splitta
+  class Frag
+
+    include WordTokenizer
+
+    attr_reader :orig, :last_word, :next_word
+    attr_accessor :pred
+
+    def initialize(orig, previous_frag: nil)
+      words = clean(orig).split
+      previous_frag.next_word = words.first if previous_frag
+      @orig = orig
+      @last_word = words.last
+    end
+
+    # ... w1. (sb?) w2 ...
+    # Features, listed roughly in order of importance:
+    #
+    # (1) w1: word that includes a period
+    # (2) w2: the next word, if it exists
+    # (3) w1length: number of alphabetic characters in w1
+    # (4) w2cap: true if w2 is capitalized
+    # (5) both: w1 and w2
+    # (6) w1abbr: log count of w1 in training without a final period
+    # (7) w2lower: log count of w2 in training as lowercased
+    # (8) w1w2upper: w1 and w2 is capitalized
+    def features(model)
+      Enumerator.new do |y|
+        y << [:w1, w1]
+        y << [:w2, w2]
+        y << [:both, w1, w2]
+
+        if alphabetic?(w1)
+          y << [:w1length, w1length]
+          y << [:w1abbr, w1abbr(model)]
+        end
+
+        if alphabetic?(w2)
+          y << [:w2cap, w2cap]
+          y << [:w2lower, w2lower(model)]
+          y << [:w1w2upper, w1, w2cap]
+        end
+      end
+    end
+
+    def over?(threshold)
+      !!pred && pred > threshold
+    end
+
+    protected
+
+    attr_writer :next_word
+
+    private
+
+    # normalize numbers, discard some punctuation that can be ambiguous
+    def clean(text)
+      text = tokenize(text)
+      text.gsub!(/[.,\d]*\d/, '<NUM>')
+      text.gsub!(%r{[^a-zA-Z0-9,.;:<>\-'/?!$% ]}, '')
+      text.gsub!('--', ' ')
+      text
+    end
+
+    def w1
+      @w1 ||= last_word&.sub(/(^.+?-)/, '')
+    end
+
+    def w2
+      @w2 ||= next_word&.sub(/(-.+?)$/, '')
+    end
+
+    def w1length
+      [10, w1.sub(/\W/, '').length].min
+    end
+
+    def w1abbr(model)
+      Math.log(1 + model.non_abbrs.fetch(w1.chop, 0.0)).to_i
+    end
+
+    def w2cap
+      upcase?(w2.chars.first) ? 'True' : 'False'
+    end
+
+    def w2lower(model)
+      Math.log(1 + model.lower_words.fetch(w2.downcase, 0.0)).to_i
+    end
+
+    def alphabetic?(str)
+      !!/[a-zA-Z. ]+/u.match(str)
+    end
+
+    def upcase?(str)
+      str.upcase == str
+    end
+
+  end
+end

data/lib/splitta/model.rb

@@ -0,0 +1,70 @@
+#
+# Naive Bayes model, with a few tweaks:
+# - all feature types are pooled together for normalization (this might help
+#   because the independence assumption is so broken for our features)
+# - smoothing: add 0.1 to all counts
+# - priors are modified for better performance (this is mysterious but works much better)
+#
+module Splitta
+  class Model
+
+    include Singleton
+
+    LABELS = [0, 1]
+
+    attr_reader :feats, :lower_words, :non_abbrs, :prior_probs
+
+    def initialize
+      @feats = model_read(:feats)
+      @lower_words = model_read(:lower_words)
+      @non_abbrs = model_read(:non_abbrs)
+
+      @prior_probs = LABELS.each_with_object({}) do |label, h|
+        h[label] = feats[[label, '<prior>']]**4
+      end
+    end
+
+    def classify(doc)
+      doc.frags.each do |frag|
+        frag.pred = classify_one(frag)
+      end
+    end
+
+    def inspect
+      "#<Splitta::Model:#{object_id}>"
+    end
+
+    private
+
+    def classify_one(frag)
+      probs = prior_probs.dup
+      LABELS.each do |label|
+        frag.features(self).each do |f|
+          key = [label, f.join('_')]
+          next unless feats.include?(key)
+
+          probs[label] *= feats[key]
+        end
+      end
+      normalize(probs).fetch(LABELS.last)
+    end
+
+    def normalize(probs)
+      total = probs.values.reduce(:+).to_f
+      probs.transform_values do |value|
+        value / total
+      end
+    end
+
+    def model_read(name)
+      Zlib::GzipReader.open(File.join(basedir, name.to_s)) do |gz|
+        Marshal.load(gz)
+      end
+    end
+
+    def basedir
+      File.expand_path('../../data', __dir__)
+    end
+
+  end
+end

data/lib/splitta/version.rb

@@ -0,0 +1,6 @@
+module Splitta
+
+  # Current gem version
+  VERSION = '4.2.5'
+
+end

data/lib/splitta/word_tokenizer.rb

@@ -0,0 +1,71 @@
+#
+# A list of (regexp, repl) pairs applied in sequence.
+# The resulting string is split on whitespace.
+# (Adapted from the Punkt Word Tokenizer)
+#
+module Splitta
+  module WordTokenizer
+
+    TOKENIZE_REGEXPS = [
+      # uniform quotes
+      /
+        '' |
+        `` |
+        “  |
+        ”
+      /ux,                          '"',
+
+      # Separate punctuation (except period) from words:
+      /(^|\s)(')/,                  '\1\2 ',
+      /(?<=[("`{\[:;&#*@])(.)/,     ' \1',    # left-hand punctuation
+      /(.)(?=[?!)";}\]*:@'])/,      '\1 ',    # right-hand punctuation
+      /(?<=[)}\]])(.)/,             ' \1',    # left-hand close paren
+      /(.)(?=[({\[])/,              '\1 ',    # right-hand open paren
+      /((^|\s)-)(?=[^-])/,          '\1 ',    # starting hyphen/minus
+
+      # Treat double-hyphen as one token:
+      /([^-])(--+)([^-])/,          '\1 \2 \3',
+
+      # Only separate comma if space follows:
+      /(\s|^)(,)(?=(\S))/u,         '\1\2 ',
+      /(.)(,)(\s|$)/u,              '\1 \2\3',
+
+      # Combine dots separated by whitespace to be a single token:
+      /\.\s\.\s\./u,                '...',
+
+      # Separate "No.6"
+      /([A-Za-z]\.)(\d+)/,          '\1 \2',
+
+      # Separate words from ellipses
+      /([^.]|^)(\.{2,})(.?)/,       '\1 \2 \3',
+      /(^|\s)(\.{2,})([^.\s])/u,    '\1\2 \3',
+      /(^|\s)(\.{2,})([^.\s])/u,    '\1 \2\3',
+
+      # fix %, $, &
+      /(\d)%/,                      '\1 %',
+      /\$(\.?\d)/,                  '$ \1',
+      /(\w)& (\w)/,                 '\1&\2',
+      /(\w\w+)&(\w\w+)/,            '\1 & \2',
+
+      # fix (n 't) --> ( n't)
+      /n 't( |$)/,                  ' n\'t\1',
+      /N 'T( |$)/,                  ' N\'T\1',
+
+      # treebank tokenizer special words
+      /([Cc])annot/,                '\1an not',
+      /\s+/,                        ' ',
+    ]
+
+    #
+    # Tokenize a string using the rules above
+    #
+    def tokenize(text)
+      text = text.dup
+      TOKENIZE_REGEXPS.each_slice(2) do |regexp, repl|
+        text.gsub!(regexp, repl)
+      end
+      text
+    end
+
+  end
+end

data/splitta.gemspec

@@ -0,0 +1,27 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'splitta/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'splitta'
+  spec.version       = Splitta::VERSION
+  spec.authors       = ['David McCullars']
+  spec.email         = ['david.mccullars@gmail.com']
+
+  spec.summary       = 'Implementation of Splitta in Ruby'
+  spec.description   = 'Implementation of Splitta in Ruby.  See https://code.google.com/archive/p/splitta/'
+  spec.homepage      = 'https://github.com/david-mccullars/ruby-splitta'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubypython'
+  spec.add_development_dependency 'simplecov', '~> 0.17.0' # 0.18 not supported by code climate
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: splitta
+version: !ruby/object:Gem::Version
+  version: 4.2.5
+platform: ruby
+authors:
+- David McCullars
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-06-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubypython
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+description: Implementation of Splitta in Ruby.  See https://code.google.com/archive/p/splitta/
+email:
+- david.mccullars@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".codeclimate.yml"
+- ".gitignore"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- data/feats
+- data/lower_words
+- data/non_abbrs
+- data/src/feats
+- data/src/lower_words
+- data/src/non_abbrs
+- lib/splitta.rb
+- lib/splitta/doc.rb
+- lib/splitta/frag.rb
+- lib/splitta/model.rb
+- lib/splitta/version.rb
+- lib/splitta/word_tokenizer.rb
+- splitta.gemspec
+homepage: https://github.com/david-mccullars/ruby-splitta
+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.7.6
+signing_key: 
+specification_version: 4
+summary: Implementation of Splitta in Ruby
+test_files: []