rambling-trie 2.4.0 → 2.5.1

data/lib/rambling/trie/version.rb

@@ -3,6 +3,6 @@
 module Rambling
   module Trie
     # Current version of the rambling-trie.
-    VERSION = '2.4.0'
+    VERSION = '2.5.1'
   end
 end

data/lib/rambling/trie.rb

@@ -1,18 +1,17 @@
 # frozen_string_literal: true
 
+path = File.join 'rambling', 'trie'
 %w(
   comparable compressible compressor configuration container enumerable inspectable invalid_operation
   readers serializers stringifyable nodes version
-).each do |file|
-  require File.join('rambling', 'trie', file)
-end
+).each { |file| require File.join(path, file) }
 
 # General namespace for all Rambling gems.
 module Rambling
-  # Entry point for +rambling-trie+ API.
+  # Entry point for `rambling-trie` API.
   module Trie
     class << self
-      # Creates a new +Rambling::Trie+. Entry point for the +rambling-trie+ API.
+      # Creates a new `Rambling::Trie`. Entry point for the `rambling-trie` API.
       # @param [String, nil] filepath the file to load the words from.
       # @param [Readers::Reader, nil] reader the file parser to get each word.
       # @return [Container] the trie just created.
@@ -26,9 +25,7 @@ module Rambling
           if filepath
             reader ||= readers.resolve filepath
             # noinspection RubyMismatchedArgumentType,RubyNilAnalysis
-            reader.each_word filepath do |word|
-              container << word
-            end
+            (reader || raise).each_word(filepath) { |word| container << word }
           end
 
           yield container if block_given?
@@ -37,18 +34,18 @@ module Rambling
 
       # Loads an existing trie from disk into memory. By default, it will
       # deduce the correct way to deserialize based on the file extension.
-      # Available formats are +yml+, +marshal+, and +zip+ versions of all the
+      # Available formats are `yml`, `marshal`, and `zip` versions of all the
       # previous formats. You can also define your own.
       # @param [String] filepath the file to load the words from.
       # @param [Serializer, nil] serializer the object responsible of loading the trie from disk.
       # @return [Container] the trie just loaded.
       # @yield [Container] the trie just loaded.
       # @see Rambling::Trie::Serializers Serializers.
-      # @note Use of #   {https://ruby-doc.org/core-2.7.0/Marshal.html#method-c-load Marshal.load} is generally
-      #   discouraged. Only use the +.marshal+ format with trusted input.
+      # @note Use of #   {https://ruby-doc.org/3.3.0/Marshal.html#method-c-load Marshal.load} is generally
+      #   discouraged. Only use the `.marshal` format with trusted input.
       def load filepath, serializer = nil
         serializer ||= serializers.resolve filepath
-        root = serializer.load filepath
+        root = (serializer || raise).load filepath
         Rambling::Trie::Container.new root, compressor do |container|
           yield container if block_given?
         end
@@ -56,7 +53,7 @@ module Rambling
 
       # Dumps an existing trie from memory into disk. By default, it will
       # deduce the correct way to serialize based on the file extension.
-      # Available formats are +yml+, +marshal+, and +zip+ versions of all the
+      # Available formats are `yml`, `marshal`, and `zip` versions of all the
       # previous formats. You can also define your own.
       # @param [Container] trie the trie to dump into disk.
       # @param [String] filepath the file to dump to serialized trie into.
@@ -66,10 +63,10 @@ module Rambling
       def dump trie, filepath, serializer = nil
         serializer ||= serializers.resolve filepath
         # noinspection RubyNilAnalysis
-        serializer.dump trie.root, filepath
+        (serializer || raise).dump trie.root, filepath
       end
 
-      # Provides configuration properties for the +Rambling::Trie+ gem.
+      # Provides configuration properties for the `Rambling::Trie` gem.
       # @return [Configuration::Properties] the configured properties of the gem.
       # @yield [Configuration::Properties] the configured properties of the gem.
       def config

data/rambling-trie.gemspec

@@ -14,28 +14,22 @@ Gem::Specification.new do |gem|
 
   gem.summary = 'A Ruby implementation of the trie data structure.'
   gem.homepage = 'https://github.com/gonzedge/rambling-trie'
-  gem.date = Time.now.strftime '%Y-%m-%d'
   gem.metadata = {
-    'changelog_uri' => 'https://github.com/gonzedge/rambling-trie/blob/master/CHANGELOG.md',
+    'changelog_uri' => 'https://github.com/gonzedge/rambling-trie/blob/main/CHANGELOG.md',
     'documentation_uri' => 'https://www.rubydoc.info/gems/rambling-trie',
+    'rubygems_mfa_required' => 'true',
   }
 
   executables = `git ls-files -- bin/*`.split "\n"
-  files = `git ls-files -- {lib,*file,*.gemspec,LICENSE*,README*}`.split "\n"
-  test_files = `git ls-files -- {test,spec,features}/*`.split "\n"
+  files = `git ls-files -- {lib,sig,*file,*.gemspec,LICENSE*,README*}`.split "\n"
 
   gem.executables = executables.map { |f| File.basename f }
   gem.files = files
-  gem.test_files = test_files
   gem.require_paths = %w(lib)
 
   gem.name = 'rambling-trie'
   gem.license = 'MIT'
   gem.version = Rambling::Trie::VERSION
   gem.platform = Gem::Platform::RUBY
-  gem.required_ruby_version = '>= 2.7', '< 4'
-
-  gem.add_development_dependency 'rake', '~> 13.1'
-  gem.add_development_dependency 'rspec', '~> 3.12'
-  gem.add_development_dependency 'yard', '~> 0.9.34'
+  gem.required_ruby_version = '>= 3.1', '< 4'
 end

data/sig/lib/rambling/trie/comparable.rbs

@@ -0,0 +1,17 @@
+module Rambling
+  module Trie
+    module Comparable
+      def ==: (Nodes::Node) -> bool
+
+      private
+
+      # abstract methods
+
+      def letter: -> Symbol
+
+      def terminal?: -> bool
+
+      def children_tree: -> Hash[Symbol, Nodes::Node]
+    end
+  end
+end

data/sig/lib/rambling/trie/compressible.rbs

@@ -0,0 +1,17 @@
+module Rambling
+  module Trie
+    module Compressible
+      def compressible?: -> bool
+
+      private
+
+      # abstract methods
+
+      def root?: -> bool
+
+      def terminal?: -> bool
+
+      def children_tree: -> Hash[Symbol, Nodes::Node]
+    end
+  end
+end

data/sig/lib/rambling/trie/compressor.rbs

@@ -0,0 +1,17 @@
+module Rambling
+  module Trie
+    class Compressor
+      def compress: (Nodes::Node?) -> Nodes::Compressed?
+
+      private
+
+      def compress_only_child_and_merge: (Nodes::Node) -> Nodes::Compressed
+
+      def merge: (Nodes::Node, Nodes::Node) -> Nodes::Compressed
+
+      def compress_children_and_copy: (Nodes::Node) -> Nodes::Compressed
+
+      def compress_children: (Hash[Symbol, Nodes::Node]) -> Hash[Symbol, Nodes::Node]
+    end
+  end
+end

data/sig/lib/rambling/trie/configuration/properties.rbs

@@ -0,0 +1,28 @@
+module Rambling
+  module Trie
+    module Configuration
+      class Properties
+        attr_reader readers: ProviderCollection[Readers::Reader]
+        attr_reader serializers: ProviderCollection[Serializers::Serializer[Nodes::Node]]
+        attr_accessor compressor: Compressor
+        attr_accessor root_builder: ^() -> Nodes::Node
+        attr_accessor tmp_path: String
+
+        def initialize: -> void
+
+        def reset: -> void
+
+        private
+
+        attr_writer readers: ProviderCollection[Readers::Reader]
+        attr_writer serializers: ProviderCollection[Serializers::Serializer[Nodes::Node]]
+
+        def reset_readers: -> void
+
+        def default_reader_providers: -> Hash[Symbol, Readers::Reader]
+
+        def reset_serializers: -> void
+      end
+    end
+  end
+end

data/sig/lib/rambling/trie/configuration/provider_collection.rbs

@@ -0,0 +1,47 @@
+module Rambling
+  module Trie
+    module Configuration
+      class ProviderCollection[TProvider < _Nilable]
+        interface _Nilable
+          def nil?: -> bool
+        end
+
+        @providers: Hash[Symbol, TProvider]
+
+        attr_reader name: Symbol
+        attr_reader default: TProvider?
+
+        def initialize: (Symbol, Hash[Symbol, TProvider], ?TProvider?) -> void
+
+        def []: (Symbol) -> TProvider
+
+        def add: (Symbol, TProvider) -> TProvider
+
+        def default=: (TProvider?) -> TProvider?
+
+        def formats: -> Array[Symbol]
+
+        def providers: -> Hash[Symbol, TProvider]
+
+        def reset: -> void
+
+        def resolve: (String) -> TProvider?
+
+        private
+
+        attr_reader configured_default: TProvider?
+        attr_reader configured_providers: Hash[Symbol, TProvider]
+
+        def []=: (Symbol, TProvider) -> TProvider
+
+        def values: -> Array[TProvider]
+
+        def file_format: (String) -> Symbol
+
+        def contains?: (TProvider?) -> bool
+
+        alias provider_instances values
+      end
+    end
+  end
+end

data/sig/lib/rambling/trie/container.rbs

@@ -0,0 +1,69 @@
+module Rambling
+  module Trie
+    class Container
+      include ::Enumerable[String]
+
+      @compressor: Compressor
+
+      attr_reader root: Nodes::Node
+
+      def initialize: (Nodes::Node, Compressor) ?{ (Container) -> void } -> void
+
+      def add: (String) -> Nodes::Node
+
+      def concat: (Array[String]) -> Array[Nodes::Node]
+
+      def compress!: -> Container
+
+      def compress: -> Container
+
+      def each: { (String) -> void } -> (Enumerator[String, void] | Enumerable)
+
+      def partial_word?: (String) -> bool
+
+      def push: (*String) -> Array[Nodes::Node]
+
+      def word?: (String) -> bool
+
+      def scan: (String) -> Array[String]
+
+      def words_within: (String) -> Array[String]
+
+      def words_within?: (String) -> bool
+
+      def ==: (Container) -> bool
+
+      def []: (Symbol) -> Nodes::Node
+
+      def children: -> Array[Nodes::Node]
+
+      def children_tree: -> Hash[Symbol, Nodes::Node]
+
+      def compressed?: -> bool
+
+      def to_a: -> Array[String]
+
+      def key?: (Symbol) -> bool
+
+      def size: -> Numeric
+
+      alias include? word?
+      alias match? partial_word?
+      alias words? scan
+      alias << add
+      alias has_key? key?
+      alias has_letter? key?
+
+      private
+
+      attr_reader compressor: Compressor
+      attr_writer root: Nodes::Node
+
+      def words_within_root: (String) ?{ (String) -> void } -> Enumerator[String, void]
+
+      def compress_root: -> Nodes::Compressed
+
+      def reversed_char_symbols: (String) -> Array[Symbol]
+    end
+  end
+end

data/sig/lib/rambling/trie/enumerable.rbs

@@ -0,0 +1,23 @@
+module Rambling
+  module Trie
+    module Enumerable
+      include ::Enumerable[String]
+
+      EMPTY_ENUMERATOR: Enumerator[String, void]
+
+      alias size count
+
+      def each: { (String) -> void } -> (Enumerator[String, void] | Enumerable)
+
+      private
+
+      # abstract methods
+
+      def as_word: -> String
+
+      def terminal?: -> bool
+
+      def children_tree: -> Hash[Symbol, Nodes::Node]
+    end
+  end
+end

data/sig/lib/rambling/trie/inspectable.rbs

@@ -0,0 +1,27 @@
+module Rambling
+  module Trie
+    module Inspectable
+      def inspect: -> String
+
+      private
+
+      def class_name: -> String?
+
+      def attributes: -> String
+
+      def letter_inspect: -> String
+
+      def terminal_inspect: -> String
+
+      def children_inspect: -> String
+
+      # abstract methods
+
+      def letter: -> Symbol
+
+      def terminal: -> bool?
+
+      def children_tree: -> Hash[Symbol, Nodes::Node]
+    end
+  end
+end

data/sig/lib/rambling/trie/invalid_operation.rbs

@@ -0,0 +1,7 @@
+module Rambling
+  module Trie
+    class InvalidOperation < RuntimeError
+      def initialize: (String? message) -> void
+    end
+  end
+end

data/sig/lib/rambling/trie/nodes/compressed.rbs

@@ -0,0 +1,25 @@
+module Rambling
+  module Trie
+    module Nodes
+      class Compressed < Node
+        def initialize: (?Symbol?, ?Node?, ?Hash[Symbol, Node]) -> void
+
+        def add: (Array[Symbol]) -> Node
+
+        def compressed?: -> bool
+
+        private
+
+        # overrides
+
+        def children_match_prefix: (Array[String]) { (String) -> void } -> Enumerator[String, void]
+
+        def partial_word_chars?: (Array[String]) -> bool
+
+        def word_chars?: (Array[String]) -> bool
+
+        def closest_node: (Array[String]) -> Node
+      end
+    end
+  end
+end

data/sig/lib/rambling/trie/nodes/missing.rbs

@@ -0,0 +1,9 @@
+module Rambling
+  module Trie
+    module Nodes
+      class Missing < Node
+        def initialize: -> void
+      end
+    end
+  end
+end

data/sig/lib/rambling/trie/nodes/node.rbs

@@ -0,0 +1,69 @@
+module Rambling
+  module Trie
+    module Nodes
+      class Node
+        include Compressible
+        include Enumerable
+        include Comparable
+        include Stringifyable
+        include Inspectable
+
+        attr_reader letter: Symbol?
+        attr_accessor children_tree: Hash[Symbol, Node]
+        attr_accessor parent: Node?
+
+        def initialize: (?Symbol?, ?Node?, ?Hash[Symbol, Node]) -> void
+
+        def add: (Array[Symbol]) -> Node
+
+        def children: -> Array[Node]
+
+        def first_child: -> Node?
+
+        def match_prefix: (Array[String]) { (String) -> void } -> Enumerator[String, void]
+
+        def root?: -> bool
+
+        def scan: (Array[String]) -> Node
+
+        def terminal?: -> bool
+
+        def terminal!: -> Node
+
+        def letter=: (String | Symbol?) -> Symbol?
+
+        def compressed?: -> bool
+
+        def partial_word?: (Array[String]) -> bool
+
+        def word?: (Array[String]) -> bool
+
+        def []: (Symbol) -> Node
+
+        def []=: (Symbol, Node) -> Node
+
+        def key?: (Symbol) -> bool
+
+        def delete: (Symbol) -> Node?
+
+        alias has_key? key?
+
+        private
+
+        attr_accessor terminal: bool?
+
+        def missing: -> Node
+
+        # abstract methods
+
+        def children_match_prefix: (Array[String]) { (String) -> void } -> Enumerator[String, void]
+
+        def partial_word_chars?: (Array[String]) -> bool
+
+        def word_chars?: (Array[String]) -> bool
+
+        def closest_node: (Array[String]) -> Node
+      end
+    end
+  end
+end

data/sig/lib/rambling/trie/nodes/raw.rbs

@@ -0,0 +1,27 @@
+module Rambling
+  module Trie
+    module Nodes
+      class Raw < Node
+        def add: (Array[Symbol]) -> Node
+
+        def compressed?: -> bool
+
+        private
+
+        def add_to_children_tree: (Array[Symbol]) -> Node
+
+        def new_node: (Symbol) -> Node
+
+        # overrides
+
+        def children_match_prefix: (Array[String]) { (String) -> void } -> Enumerator[String, void]
+
+        def partial_word_chars?: (Array[String]) -> bool
+
+        def word_chars?: (Array[String]) -> bool
+
+        def closest_node: (Array[String]) -> Node
+      end
+    end
+  end
+end

data/sig/lib/rambling/trie/readers/plain_text.rbs

@@ -0,0 +1,9 @@
+module Rambling
+  module Trie
+    module Readers
+      class PlainText < Reader
+        def each_word: (String) { (String?) -> void } -> (Enumerator[String?, void] | PlainText)
+      end
+    end
+  end
+end

data/sig/lib/rambling/trie/readers/reader.rbs

@@ -0,0 +1,9 @@
+module Rambling
+  module Trie
+    module Readers
+      class Reader
+        def each_word: (String) { (String) -> void } -> (Enumerator[String, void] | Reader)
+      end
+    end
+  end
+end

data/sig/lib/rambling/trie/serializers/file.rbs

@@ -0,0 +1,8 @@
+module Rambling
+  module Trie
+    module Serializers
+      class File < Serializer[String]
+      end
+    end
+  end
+end

data/sig/lib/rambling/trie/serializers/marshal.rbs

@@ -0,0 +1,13 @@
+module Rambling
+  module Trie
+    module Serializers
+      class Marshal < Serializer[Nodes::Node]
+        @serializer: Serializer[String]
+
+        private
+
+        attr_reader serializer: Serializer[String]
+      end
+    end
+  end
+end

data/sig/lib/rambling/trie/serializers/serializer.rbs

@@ -0,0 +1,10 @@
+module Rambling
+  module Trie
+    module Serializers
+      class Serializer[TContents]
+        def load: (String) -> TContents
+        def dump: (TContents, String) -> Numeric
+      end
+    end
+  end
+end

data/sig/lib/rambling/trie/serializers/yaml.rbs

@@ -0,0 +1,13 @@
+module Rambling
+  module Trie
+    module Serializers
+      class Yaml < Serializer[Nodes::Node]
+        @serializer: Serializer[String]
+
+        private
+
+        attr_reader serializer: Serializer[String]
+      end
+    end
+  end
+end

data/sig/lib/rambling/trie/serializers/zip.rbs

@@ -0,0 +1,21 @@
+module Rambling
+  module Trie
+    module Serializers
+      class Zip < Serializer[Nodes::Node]
+        @properties: Configuration::Properties
+
+        def initialize: (Configuration::Properties) -> void
+
+        private
+
+        attr_reader properties: Configuration::Properties
+
+        def serializers: -> Configuration::ProviderCollection[Serializer[Nodes::Node]]
+
+        def tmp_path: -> String
+
+        def path: (String) -> String
+      end
+    end
+  end
+end

data/sig/lib/rambling/trie/stringifyable.rbs

@@ -0,0 +1,21 @@
+module Rambling
+  module Trie
+    module Stringifyable
+      def as_word: -> String
+
+      def to_s: -> String
+
+      private
+
+      # abstract methods
+
+      def letter: -> Symbol
+
+      def terminal?: -> bool
+
+      def parent: -> Nodes::Node?
+
+      def children_tree: -> Hash[Symbol, Nodes::Node]
+    end
+  end
+end

data/sig/lib/rambling/trie.rbs

@@ -0,0 +1,27 @@
+module Rambling
+  module Trie
+    VERSION: String
+
+    @properties: Configuration::Properties
+
+    def self.create: (?String?, ?Readers::Reader?) ?{ (Container) -> void } -> Container
+
+    def self.load: (String, ?Serializers::Serializer[Nodes::Node]?) ?{ (Container) -> void } -> Container
+
+    def self.dump: (Container, String, ?Serializers::Serializer[Nodes::Node]?) -> void
+
+    def self.config: ?{ (Configuration::Properties) -> void } -> Configuration::Properties
+
+    private
+
+    def self.properties: -> Configuration::Properties
+
+    def self.readers: -> Configuration::ProviderCollection[Readers::Reader]
+
+    def self.serializers: -> Configuration::ProviderCollection[Serializers::Serializer[Nodes::Node]]
+
+    def self.compressor: -> Compressor
+
+    def self.root_builder: -> ^() -> Nodes::Node
+  end
+end

data/sig/lib/zip/entry.rbs

@@ -0,0 +1,11 @@
+module Zip
+  class Entry
+    include Enumerable[Entry]
+
+    def name: -> String
+
+    def extract: (String) -> void
+
+    def each: ?{ (Entry) -> void } -> (Enumerator[Entry, void])
+  end
+end