mormor 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2293b20144e224eff386a73bc985a03e360dcd9a73afcde01af33ec0b0bc9d32
+  data.tar.gz: 2e0e577ee7925c5cdc453870152b8d30698371b9c31f65dc1aa0bff3c0475e4a
+SHA512:
+  metadata.gz: 63f3bb8643b13a296a8fc3dfecab97dd88f948660b9aed395d9264066edd666137c321a35efeeeda2640099d98641784064495039fa9e3a3339102a2ea6f04ed
+  data.tar.gz: 3c42a83dfcfbfe52348559d8171ea7d10a5bb5fa4087d90824b9e82d07057cfb9748e5f55e9a586561726106c6e37a25b8ec46d67cd4bf1872118a5704c54beb

data/LICENSE.txt

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2019, Victor Shepelev
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,77 @@
+# MorMor
+
+[![Gem Version](https://badge.fury.io/rb/mormor.svg)](http://badge.fury.io/rb/mormor)
+
+**MorMor** is pure Ruby [morfologik](https://github.com/morfologik/morfologik-stemming) dictionary client that could be used for POS (part of speech) tagging and simplistic spellchecking. _Morfologik_ format's distinguishing feature is it is primary dictionary format for [LanguageTool](https://github.com/languagetool-org/languagetool), therefore a lot of ready high-quality dictionaries exist.
+
+## Features/Problems
+
+* **No dependencies¹, pure Ruby**
+* **Fast**: I don't have any detailed numbers, but naive test on my laptop shows 3 mln lookups/second on a very large dictionary (Polish, several million word forms).
+* Relatively **memory-efficient**: Typical dictionary file size is 1-3 Mb, mormor just loads it into memory as bytes (e.g. each byte => Ruby Integer) and that's all memory it needs.
+* **Dictionaries** for a lot of languages already exist: unlike your typical POS tagger, usage instructions does not start with "First, take your corpora and train the tagger as you please" (see "Dictionaries" section).
+* To the moment, it is just a **naive** port of original Morfologik Java code, but it works with all the dictionaries I could find:
+  * Of possible dictionary formats, only FSA5 and CFSA2 are implemented (not CFSA);
+  * Of possible dictionary "encoders", only "SUFFIX" and "PREFIX" are implemented;
+* No tests/specs, but it works (and checked thoroughly with existing dictionaries); TBH, original Morfologik doesn't have much, either;
+* Morfologik's spellchecker suggestions/candidates are **not** ported, so mormor can be used only for "sanity" spellchecking ("this word is/is not in the dictionary")
+
+<small>¹The only runtime dependency is [backports](https://github.com/marcandre/backports) and that's only because I am too fond of modern Ruby features to sacrifice them to "no-dependencies" god.</small>
+
+## Usage
+
+0. Install `mormor` gem (via bundler or just `[sudo] gem install mormor`)
+1. Take a dictionary for your language (see "Dictionaries" section below)
+2. Now...
+
+```ruby
+require 'mormor'
+
+dictionary = MorMor::Dictionary.new('path/to/english')
+dictionary.lookup('meowing')
+# => [#<struct MorMor::Dictionary::Word stem="meow", tags="VBG">]
+dictionary.lookup('barks')
+# => [#<struct MorMor::Dictionary::Word stem="bark", tags="NNS">,
+#     #<struct MorMor::Dictionary::Word stem="bark", tags="VBZ">]
+dictionary.lookup('borogoves')
+# = nil
+
+dictionary = MorMor::Dictionary.new('path/to/ukrainian')
+dictionary.lookup("солов'їна")
+# => [#<struct MorMor::Dictionary::Word stem="солов'їний", tags="adj:f:v_kly">,
+#     #<struct MorMor::Dictionary::Word stem="солов'їний", tags="adj:f:v_naz">]
+```
+
+`Dictionary#lookup` returns an array of structs which describe all possible base forms + part of speech /word form tags. (For example, "barks" could be a third person form of the verb "to bark", or plural form of noun "bark".)
+
+Tags are dependent on the particular dictionary used and typically documented in a free form alongside the dictionaries.
+
+## Dictionaries
+
+A lot of dictionaries in Morfologik format could be found at [LanguageTool's repo](https://github.com/languagetool-org/languagetool). For example, for Polish language, [dictionary is at](https://github.com/languagetool-org/languagetool/tree/master/languagetool-language-modules/pl/src/main/resources/org/languagetool/resource/pl) `languagetool-language-modules/pl/src/main/resources/org/languagetool/resource/pl/`.
+
+What you need there, are:
+* `polish.dict` is a dictionary (binary finite-state-automata) itself
+* `polish.info` is dictionary metadata
+
+In order to use Polish dictionary with mormor, you need to place both files at the same folder, and then
+```ruby
+pl = MorMor::Dictionary.new('path/to/that/folder/polish') # without extension
+pl.lookup('świetnie')
+```
+
+You may also be interested in `tagset.txt` file of the same folder, which has an explanation for all POS/forms tags in natural language (Polish language, for that case).
+
+Sometimes (for example, in case of German and Ukrainian), LanguageTool repo contains not the dictionary itself, but a link to other repo/site where it can be downloaded.
+
+Please **carefully consider** dictionary licenses when using them!
+
+> **Note:** mormor repo contains copies of dictionary files from LanguageTool and referred projects, but they are **not** a part of the gem distribution and only used for testing the parser/lookup correctness, and demonstration purposes.
+
+## License and credits
+
+Most of the credit for algorithms and original code belong to original [Morfologik's](https://github.com/morfologik/morfologik-stemming) authors, and author of paper's they based their work on.
+
+Ruby version is done by [Victor Shepelev](https://zverok.github.io).
+
+The license is BSD, the same as the original Morfologik.

data/exe/mormor-dump

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+require_relative '../lib/mormor'
+
+path = ARGV.shift or abort "Usage: mormor-dump <dictionary>.dict"
+File.exist?(path) or abort "#{path} does not exist"
+
+MorMor::FSA.new(path).each_sequence(&method(:puts))

data/lib/mormor.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'backports/2.6.0/kernel/then'
+require 'backports/2.5.0/integer' # allbits? / anybits? / nobits?
+
+# Morfologik dictionary client
+# See {Dictionary}.
+module MorMor
+end
+
+require_relative 'mormor/dictionary'

data/lib/mormor/dictionary.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative 'fsa'
+
+module MorMor
+  # Morfologik dictionary client.
+  #
+  # @example
+  #   dictionary = MorMor::Dictionary.new('path/to/english')
+  #   dictionary.lookup('meowing')
+  #   # => [#<struct MorMor::Dictionary::Word stem="meow", tags="VBG">]
+  #
+  class Dictionary
+    # This class is simplified port of all `Dictionary*.java` classes (Dictionary, DictionaryMetadata,
+    # DictionaryLookup etc) of `morfologik-stemming` package.
+    # See original package to understand details and stuff:
+    # https://github.com/morfologik/morfologik-stemming/tree/master/morfologik-stemming/src/main/java/morfologik/stemming
+
+    # Result of {Dictionary#lookup}
+    #
+    # `stem` is base form of the looked up word, `tags` is dictionary-depended part of speech / word
+    # form tags.
+    Word = Struct.new(:stem, :tags)
+
+    # @private
+    DECODERS = {'SUFFIX' => :suffix, 'PREFIX' => :prefix_suffix}.freeze
+
+    # @private
+    attr_reader :fsa
+    # @return [Hash]
+    attr_reader :info
+
+    # @param path [String] Path to dictionary files. It is expected that `path + ".info"` and
+    #   `path + ".dict"` files are existing and contain Morfologik dictionary
+    def initialize(path)
+      @path = path # Just for inspect
+
+      read_info(path + '.info')
+
+      @fsa = FSA.read(path + '.dict')
+    end
+
+    # @return [String]
+    def inspect
+      '#<%s %s>' % [self.class, @path]
+    end
+
+    # Finds all forms and POS tags of words in the dictionary.
+    #
+    # @param word [String] a word to lookup
+    # @return [Array<Word>, nil]
+    def lookup(word) # rubocop:disable Metrics/AbcSize
+      # Method is left unsplit to leave original algorithm (DictionaryLookup.java#lookup) recognizable,
+      # hence rubocop:disable
+
+      bword = word.encode(@encoding).force_encoding('ASCII-8BIT')
+
+      # TODO: there could be "input conversion pairs"
+
+      # Note: not bword.bytes, because morfologik expects signed bytes, while String#bytes
+      # is analog of unpack('C*'), returning unsigned
+      m = fsa.match(bword.unpack('c*'))
+
+      # OC: this case is somewhat confusing: we should have hit the separator
+      # first... I don't really know how to deal with it at the time
+      # being.
+      return unless m.kind == :sequence_is_a_prefix
+
+      # OC: The entire sequence exists in the dictionary. A separator should
+      # be the next symbol.
+      arc = fsa.find_arc(m.node, @sepbyte)
+
+      # OC: The situation when the arc points to a final node should NEVER
+      # happen. After all, we want the word to have SOME base form.
+      return if arc.zero? || fsa.final_arc?(arc)
+
+      # OC: There is such a word in the dictionary. Return its base forms.
+      fsa.each_sequence(from: fsa.end_node(arc)).map do |encoded|
+        # TODO: there could be "output conversion pairs"
+
+        decoded = @decoder.call(bword, encoded).force_encoding(@encoding).encode('UTF-8')
+
+        Word.new(*decoded.split(@separator, 2))
+      end
+    end
+
+    private
+
+    def read_info(path)
+      @info = read_values(path)
+
+      # NB: All possible values described in DictionaryAttribute.java
+
+      # Cache it to be quickly accessible
+      @encoding = @info.fetch('fsa.dict.encoding')
+      @separator = @info.fetch('fsa.dict.separator')
+      @sepbyte = @separator.bytes.first
+
+      @decoder = choose_decoder(@info.fetch('fsa.dict.encoder'))
+    end
+
+    def read_values(path)
+      File.exist?(path) or fail ArgumentError, "#{path} does not exist"
+      File.read(path).split("\n")
+          .map { |ln| ln.sub(/\#.*$/, '').strip }.reject(&:empty?)
+          .map { |ln| ln.split('=', 2) }
+          .to_h
+    end
+
+    def choose_decoder(name)
+      DECODERS.fetch(name.upcase) { fail ArgumentError, "Encoder #{name} is not supported yet" }
+              .then(&method(:method))
+    end
+
+    def suffix(source, encoded)
+      truncate_suf = encoded[0...1].bytes.first.-(65) & 0xff # 65 is 'A'
+      # TODO: If remove == 255, means "remove all"
+      source[0...source.size - truncate_suf] + encoded[1..-1]
+    end
+
+    def prefix_suffix(source, encoded)
+      truncate_pref, truncate_suf = encoded[0...2].bytes.first(2).map { |b| (b - 65) & 0xff } # 65 is 'A'
+      # TODO: If remove == 255, means "remove all"
+
+      source[truncate_pref...source.size - truncate_suf] + encoded[2..-1]
+    end
+  end
+end

data/lib/mormor/fsa.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative 'fsa/enumerator'
+require_relative 'fsa/fsa5'
+require_relative 'fsa/cfsa2'
+
+module MorMor
+  # @private
+  #
+  # This class and its subclasses contains a loose simplified port of the whole `morfologik-fsa`
+  # package.
+  # Original source at: https://github.com/morfologik/morfologik-stemming/tree/master/morfologik-fsa/src/main/java/morfologik/fsa
+  #
+  # NB: TBH, I don't always understand deeply what am I doing here. Just ported Java algorithms
+  # statement-by-statement, then rubyfied a bit and debugged in parallel with original package to
+  # make sure it produces the same result.
+  #
+  # Code contains some of my comments, original implementations referred where appropriate.
+  # Also, in more straightforwardly ported code, original comments are left and marked with "OC:".
+  #
+  class FSA
+    # LanguageTool seems to use CFSA2 and FSA5, so CFSA is not implemented.
+    VERSIONS = {
+      5 => 'FSA5',
+      0xC5 => 'CFSA',
+      0xc6 => 'CFSA2'
+    }.freeze
+
+    Match = Struct.new(:kind, :position, :node)
+
+    class << self
+      def read(path)
+        io = File.open(path, 'rb')
+        io.read(4) == '\\fsa' or fail ArgumentError, 'Invalid file header, probably not an FSA.'
+        choose_impl(io.getbyte).new(io)
+      end
+
+      private
+
+      def choose_impl(version_byte)
+        VERSIONS
+          .fetch(version_byte) { fail ArgumentError 'Unsupported version byte, probably not FSA' }
+          .tap { |name|
+            constants.include?(name.to_sym) or
+              fail ArgumentError "Unsupported version: #{name}"
+          }
+          .then(&method(:const_get))
+      end
+    end
+
+    def each_sequence(from: root_node, &block)
+      Enumerator.new(self, from).then { |e| block ? e.each(&block) : e }
+    end
+
+    def next_arc(arc)
+      last_arc?(arc) ? 0 : skip_arc(arc)
+    end
+
+    def each_arc(from:)
+      return to_enum(__method__, from: from) unless block_given?
+
+      arc = first_arc(from)
+      until arc.zero?
+        yield arc
+        arc = next_arc(arc)
+      end
+    end
+
+    def find_arc(node, label)
+      each_arc(from: node).detect { |a| arc_label(a) == label } || 0
+    end
+
+    # Port of FSATraversal.java
+    # Method is left unsplit to leave original algorithm recognizable, hence rubocop:disable's
+    def match(sequence, node = root_node) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
+      return Match.new(:no) if node.zero?
+
+      sequence.each_with_index do |byte, i|
+        a = find_arc(node, byte)
+
+        case
+        when a.zero?
+          return i.zero? ? Match.new(:no, i, node) : Match.new(:automaton_has_prefix, i, node)
+        when i + 1 == sequence.size && final_arc?(a)
+          return Match.new(:exact, i, node)
+        when terminal_arc?(a)
+          return Match.new(:automaton_has_prefix, i + 1, node)
+        else
+          node = end_node(a)
+        end
+      end
+
+      Match.new(:sequence_is_a_prefix, 0, node)
+    end
+  end
+end

data/lib/mormor/fsa/cfsa2.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module MorMor
+  class FSA
+    # Port of CFSA2.java
+    #
+    # See constant description and other docs there:
+    # https://github.com/morfologik/morfologik-stemming/blob/master/morfologik-fsa/src/main/java/morfologik/fsa/CFSA2.java
+    class CFSA2 < FSA
+      NUMBERS = 1 << 8
+      BIT_TARGET_NEXT = 1 << 7
+      LABEL_INDEX_BITS = 5
+      LABEL_INDEX_MASK = (1 << LABEL_INDEX_BITS) - 1
+      BIT_LAST_ARC = 1 << 6
+      BIT_FINAL_ARC = 1 << 5
+
+      def initialize(io)
+        # Java's short = "network (big-endian)"
+        flag_bits = io.read(2).unpack('n').first # rubocop:disable Style/UnpackFirst -- doesn't work under 2.3
+        @numbers = flag_bits.allbits?(NUMBERS)
+
+        mapping_size = io.getbyte & 0xff
+        @mapping = io.read(mapping_size).unpack('c*')
+
+        @arcs = io.read.unpack('c*')
+      end
+
+      def root_node
+        destination_node_offset(first_arc(0))
+      end
+
+      # Navigating through arcs
+      def first_arc(node)
+        numbers? ? skip_v_int(node) : node
+      end
+
+      def end_node(arc)
+        destination_node_offset(arc)
+      end
+
+      # Examining arcs
+      def arc_label(arc)
+        index = arcs[arc] & LABEL_INDEX_MASK
+        index.positive? ? mapping[index] : arcs[arc + 1]
+      end
+
+      def terminal_arc?(arc)
+        destination_node_offset(arc).zero?
+      end
+
+      def last_arc?(arc)
+        arcs[arc].allbits?(BIT_LAST_ARC)
+      end
+
+      def final_arc?(arc)
+        arcs[arc].allbits?(BIT_FINAL_ARC)
+      end
+
+      private
+
+      attr_reader :arcs, :mapping
+
+      def numbers?
+        @numbers
+      end
+
+      def skip_v_int(offset)
+        offset += 1 while arcs[offset].negative?
+        offset + 1
+      end
+
+      def read_v_int(array, offset)
+        b = array[offset]
+        value = b & 0x7F
+        shift = 7
+        while b.negative?
+          offset += 1
+          b = array[offset]
+          value |= (b & 0x7F) << shift
+          shift += 7
+        end
+
+        value
+      end
+
+      def destination_node_offset(arc)
+        if next_set?(arc)
+          # OC: Follow until the last arc of this state.
+          arc = next_arc(arc) until last_arc?(arc)
+
+          # OC: And return the byte right after it.
+          skip_arc(arc)
+        else
+          # OC: The destination node address is v-coded. v-code starts either
+          # at the next byte (label indexed) or after the next byte (label explicit).
+          read_v_int(arcs, arc + (arcs[arc].anybits?(LABEL_INDEX_MASK) ? 1 : 2))
+        end
+      end
+
+      def next_set?(arc)
+        arcs[arc].allbits?(BIT_TARGET_NEXT)
+      end
+
+      def skip_arc(offset)
+        flag = arcs[offset]
+        offset += 1
+
+        # OC: Explicit label?
+        offset += 1 if flag.nobits?(LABEL_INDEX_MASK)
+
+        # OC: Explicit goto?
+        offset = skip_v_int(offset) if flag.nobits?(BIT_TARGET_NEXT)
+
+        offset
+      end
+    end
+  end
+end

data/lib/mormor/fsa/enumerator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module MorMor
+  class FSA
+    # Rubyfied port of ByteSequenceIterator.java
+    #
+    # See: https://github.com/morfologik/morfologik-stemming/blob/master/morfologik-fsa/src/main/java/morfologik/fsa/ByteSequenceIterator.java
+    #
+    # From some node of automaton, it iterates through all paths starting at that node to their end,
+    # and yields each full path packed into original dictionary bytes string.
+    class Enumerator
+      def initialize(fsa, node)
+        @fsa = fsa
+        @arcs_stack = []
+        @sequence = []
+
+        unless (first = fsa.first_arc(node)).zero? # rubocop:disable Style/GuardClause
+          arcs_stack << first
+        end
+      end
+
+      def each
+        return to_enum(__method__) unless block_given?
+
+        while (el = advance)
+          yield el.pack('C*')
+        end
+      end
+
+      include Enumerable
+
+      private
+
+      attr_reader :fsa, :arcs_stack, :sequence
+
+      # Method is left unsplit to leave original algorithm recognizable, hence rubocop:disable
+      def advance # rubocop:disable Metrics/AbcSize
+        until arcs_stack.empty?
+          arc = arcs_stack.last
+
+          if arc.zero?
+            # OC: Remove the current node from the queue.
+            arcs_stack.pop
+            next
+          end
+
+          # OC: Go to the next arc, but leave it on the stack
+          # so that we keep the recursion depth level accurate.
+          arcs_stack[-1] = fsa.next_arc(arc)
+
+          sequence[arcs_stack.count - 1] = fsa.arc_label(arc)
+
+          # OC: Recursively descend into the arc's node.
+          arcs_stack.push(fsa.end_node(arc)) unless fsa.terminal_arc?(arc)
+
+          if fsa.final_arc?(arc)
+            sequence.slice!(arcs_stack.count)
+            return sequence
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/mormor/fsa/fsa5.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module MorMor
+  class FSA
+    # Port of FSA5.java
+    #
+    # See constant description and other docs there:
+    # https://github.com/morfologik/morfologik-stemming/blob/master/morfologik-fsa/src/main/java/morfologik/fsa/FSA5.java
+    class FSA5 < FSA
+      BIT_FINAL_ARC = 1 << 0
+      BIT_LAST_ARC = 1 << 1
+      BIT_TARGET_NEXT = 1 << 2
+      ADDRESS_OFFSET = 1
+
+      def initialize(io)
+        @filler = io.getbyte
+        @annotation = io.getbyte
+        hgtl = io.getbyte
+
+        # OC: Determine if the automaton was compiled with NUMBERS. If so, modify
+        # ctl and goto fields accordingly.
+
+        # zverok: ???? This variables/flags doesn't used at all
+        # flags = [FLEXIBLE, STOPBIT, NEXTBIT]
+        # flags << NUMBERS if hgtl.anybits?(0xf0)
+
+        @node_data_length = (hgtl >> 4) & 0x0f
+        @gtl = hgtl & 0x0f
+
+        @arcs = io.read.unpack('c*')
+      end
+
+      def root_node
+        # OC: Skip dummy node marking terminating state.
+        epsilon_node = skip_arc(first_arc(0))
+
+        # OC: And follow the epsilon node's first (and only) arc.
+        destination_node_offset(first_arc(epsilon_node))
+      end
+
+      # Navigating through arcs
+      def first_arc(node)
+        @node_data_length + node
+      end
+
+      def end_node(arc)
+        destination_node_offset(arc)
+      end
+
+      # Examining arcs
+      def arc_label(arc)
+        arcs[arc]
+      end
+
+      def final_arc?(arc)
+        arcs[arc + ADDRESS_OFFSET].allbits?(BIT_FINAL_ARC)
+      end
+
+      def last_arc?(arc)
+        arcs[arc + ADDRESS_OFFSET].allbits?(BIT_LAST_ARC)
+      end
+
+      def terminal_arc?(arc)
+        destination_node_offset(arc).zero?
+      end
+
+      private
+
+      attr_reader :arcs, :gtl
+
+      def decode_from_bytes(arcs, start, n)
+        (n - 1).downto(0).inject(0) { |r, i| r << 8 | (arcs[start + i] & 0xff) }
+      end
+
+      def destination_node_offset(arc)
+        if next_set?(arc)
+          # OC: The destination node follows this arc in the array.
+          skip_arc(arc)
+        else
+          # OC: The destination node address has to be extracted from the arc's
+          # goto field.
+          decode_from_bytes(arcs, arc + ADDRESS_OFFSET, gtl) >> 3
+        end
+      end
+
+      def next_set?(arc)
+        arcs[arc + ADDRESS_OFFSET].allbits?(BIT_TARGET_NEXT)
+      end
+
+      # OC: Read the arc's layout and skip as many bytes, as needed.
+      def skip_arc(offset)
+        offset + if next_set?(offset)
+                   1 + 1   # OC: label + flags
+                 else
+                   1 + gtl # OC: label + flags/address
+                 end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: mormor
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Victor Shepelev
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-06-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: backports
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.15.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.15.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: rubygems-tasks
+  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: yard
+  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: forspell
+  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'
+description: 
+email: zverok.offline@gmail.com
+executables:
+- mormor-dump
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- exe/mormor-dump
+- lib/mormor.rb
+- lib/mormor/dictionary.rb
+- lib/mormor/fsa.rb
+- lib/mormor/fsa/cfsa2.rb
+- lib/mormor/fsa/enumerator.rb
+- lib/mormor/fsa/fsa5.rb
+homepage: https://github.com/molybdenum-99/mormor
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: 'Morfologik dictionaries client in pure Ruby: POS tagging & spellcheck'
+test_files: []