rambling-trie 2.5.0 → 2.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a489fbd736614f76449e3f4254d798e759e120985a1b141fbae17ec12330c2f
-  data.tar.gz: e92201410e743a5660fcbbb9703f68ee4e41366b9c4ee987a65f8fd78ea46d0f
+  metadata.gz: 4c38f152f6ffdb5b7c3f5abde873ae3024651a52a7697fa4e706d01e28fe504e
+  data.tar.gz: 8cdec337b99995019a24d702b48dce2ee3e9a9e6acde298cd5cfef8086e93bc9
 SHA512:
-  metadata.gz: a0c8f6af0ce43902f5292829e48dfa86e3ca1b623a0742ac129af57bc10209249879f5bdf7ecb4feb65f03da6986748e8cc77f1c458816b8e1aa96063372fc5b
-  data.tar.gz: 1cc6eb48bf18cdace40358e3ed9371f012f164d5fb6f37e7ff99ce01a4ed0a71d18b21821c3cfef324ebf0ae59c18c2a4fe11e2c8a12044de649c75772221fcb
+  metadata.gz: 6bbadda2f93e7efdae19f0db8749e304be56b288d62095a269904c4d6e3b6e2f7723acba618fd4e8e8de416108ca9e6249c7a6c9ce5a70e70036e6ad287cb7e2
+  data.tar.gz: b60a49628ba61bca14d5a92573df83203feb0346d306adbc628ab7dfad54da82574902ee1f4985a365582a6c5a285b788a108ee7e7d2c22b0ce3f06dc5eccf78

data/Dockerfile

@@ -0,0 +1,28 @@
+FROM ruby:3.3.6
+
+RUN bundle config --global frozen 1
+
+WORKDIR /usr/rambling-trie
+RUN git init
+
+# Copy strictly what is necessary to install dependencies
+COPY Gemfile Gemfile.lock rambling-trie.gemspec ./
+COPY lib ./lib
+
+# Install dependencies
+RUN bundle install
+
+# Copy rest of Ruby and Markdown files
+COPY Rakefile ./
+COPY *.md ./
+COPY assets ./assets
+COPY sig ./sig
+COPY spec ./spec
+COPY tasks ./tasks
+COPY scripts ./scripts
+
+# Copy rest of configuration files
+COPY *file ./
+COPY *.yml ./
+COPY .mdl* ./
+COPY .yardopts ./

data/Gemfile

@@ -7,29 +7,38 @@ gemspec
 gem 'rubyzip'
 
 group :development do
-  gem 'benchmark-ips'
-  gem 'flamegraph'
-  gem 'memory_profiler'
-  gem 'pry'
   gem 'rake'
   gem 'rspec'
-  gem 'ruby-prof'
-  gem 'stackprof'
-  gem 'yard'
 end
 
 group :test do
-  gem 'coveralls_reborn', '~> 0.27.0', require: false
+  gem 'coveralls_reborn', require: false
   gem 'rspec_junit_formatter'
   gem 'simplecov', require: false
 end
 
 group :local do
+  gem 'benchmark-ips', require: false
+  gem 'flamegraph', require: false
   gem 'flog', require: false
-  gem 'guard-rspec'
+  gem 'guard', require: false
+  gem 'guard-reek', require: false
+  gem 'guard-rspec', require: false
+  gem 'guard-rubocop', require: false
+  gem 'guard-yard', require: false
   gem 'mdl', require: false
+  gem 'memory_profiler', require: false
+  gem 'pry', require: false
+  gem 'racc', require: false
+  gem 'rbs', require: false
+  gem 'redcarpet', require: false
+  gem 'reek', require: false
   gem 'rubocop', require: false
   gem 'rubocop-performance', require: false
   gem 'rubocop-rake', require: false
   gem 'rubocop-rspec', require: false
+  gem 'ruby-prof', require: false
+  gem 'stackprof', require: false
+  gem 'steep', require: false
+  gem 'yard', require: false
 end

data/Guardfile

@@ -1,10 +1,21 @@
 # frozen_string_literal: true
 
-# A sample Guardfile
-# More info at https://github.com/guard/guard#readme
+LIB_REGEX = %r{^lib/(.+)\.rb$}
 
-guard 'rspec', cmd: 'rspec', all_on_start: true, all_after_pass: false do
+guard :reek, all_on_start: true, run_all: true do
+  watch(LIB_REGEX)
+end
+
+guard :rspec, cmd: 'rspec', all_on_start: true, all_after_pass: false do
   watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
-  watch('spec/spec_helper.rb')  { 'spec' }
+  watch(LIB_REGEX) { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb') { 'spec' }
+end
+
+guard :rubocop, all_on_start: true do
+  watch(LIB_REGEX)
+end
+
+guard :yard, server: false do
+  watch(LIB_REGEX)
 end

data/README.md

@@ -30,13 +30,13 @@ See [RVM][rvm], [rbenv][rbenv] or [chruby][chruby] for more information on how t
 
 You can either install it manually with:
 
-``` bash
+```shell
 gem install rambling-trie
 ```
 
 Or, include it in your `Gemfile` and bundle it:
 
-``` ruby
+```ruby
 gem 'rambling-trie'
 ```
 
@@ -46,13 +46,13 @@ gem 'rambling-trie'
 
 To create a new trie, initialize it like this:
 
-``` ruby
+```ruby
 trie = Rambling::Trie.create
 ```
 
 You can also provide a block and the created trie instance will be yielded for you to perform any operation on it:
 
-``` ruby
+```ruby
 Rambling::Trie.create do |trie|
   trie << 'word'
 end
@@ -61,13 +61,13 @@ end
 Additionally, you can provide the path to a file that contains all the words to be added to the trie, and it will read
 the file and create the complete structure for you, like this:
 
-``` ruby
+```ruby
 trie = Rambling::Trie.create '/path/to/file'
 ```
 
 By default, a plain text file with the following format will be expected:
 
-``` text
+```text
 some
 words
 to
@@ -85,14 +85,14 @@ readers.
 
 To add new words to the trie, use `#add` or its alias `#<<`:
 
-``` ruby
+```ruby
 trie.add 'word'
 trie << 'word'
 ```
 
 Or if you have multiple words to add, you can use `#concat` or `#push`:
 
-``` ruby
+```ruby
 trie.concat %w(a collection of words)
 trie.push 'a', 'collection', 'of', 'words'
 
@@ -104,7 +104,7 @@ trie.push *words
 
 And to find out if a word already exists in the trie, use `#word?` or its alias `#include?`:
 
-``` ruby
+```ruby
 trie.word? 'word'
 trie.include? 'word'
 ```
@@ -112,21 +112,21 @@ trie.include? 'word'
 If you wish to find if part of a word exists in the trie instance, you should call `#partial_word?` or its
 alias `#match?`:
 
-``` ruby
+```ruby
 trie.partial_word? 'partial_word'
 trie.match? 'partial_word'
 ```
 
 To get all the words that start with a particular string, you can use `#scan` or its alias `#words`:
 
-``` ruby
+```ruby
 trie.scan 'hi' # => ['hi', 'high', 'highlight', ...]
 trie.words 'hi' # => ['hi', 'high', 'highlight', ...]
 ```
 
 To get all the words within a given string, you can use `#words_within`:
 
-``` ruby
+```ruby
 trie.words_within 'ifdxawesome45someword3' # => ['if', 'aw', 'awe', ...]
 trie.words_within 'tktktktk' # => []
 ```
@@ -134,7 +134,7 @@ trie.words_within 'tktktktk' # => []
 Or, if you're just interested in knowing whether a given string contains any valid words or not, you can
 use `#words_within?`:
 
-``` ruby
+```ruby
 trie.words_within? 'ifdxawesome45someword3' # => true
 trie.words_within? 'tktktktk' # => false
 ```
@@ -144,7 +144,7 @@ trie.words_within? 'tktktktk' # => false
 By default, the Rambling Trie works as a standard trie. Starting from version 0.1.0, you can obtain a compressed trie
 from the standard one, by using the compression feature. Just call the `#compress!` method on the trie instance:
 
-``` ruby
+```ruby
 trie.compress!
 ```
 
@@ -157,13 +157,13 @@ non-terminal nodes).
 
 If you want, you can also create a new compressed trie and leave the existing one intact. Just use `#compress` instead:
 
-``` ruby
+```ruby
 compressed_trie = trie.compress
 ```
 
 You can find out if a trie instance is compressed by calling the `#compressed?` method. From the `#compress` example:
 
-``` ruby
+```ruby
 trie.compressed? # => false
 compressed_trie.compressed? # => true
 ```
@@ -173,7 +173,7 @@ compressed_trie.compressed? # => true
 Starting from version 0.4.2, you can use any `Enumerable` method over a trie instance, and it will iterate over each
 word contained in the trie. You can now do things like:
 
-``` ruby
+```ruby
 trie.each { |word| puts word }
 trie.any? { |word| word.include? 'x' }
 trie.all? { |word| word.include? 'x' }
@@ -189,14 +189,14 @@ change with little frequency.
 
 To store a trie on disk, you can use `.dump` like this:
 
-``` ruby
+```ruby
 Rambling::Trie.dump trie, '/path/to/file'
 ```
 
 Then, when you need to use a trie next time, you don't have to create a new one with all the necessary words. Rather,
 you can retrieve a previously stored one with `.load` like this:
 
-``` ruby
+```ruby
 trie = Rambling::Trie.load '/path/to/file'
 ```
 
@@ -214,19 +214,19 @@ Currently, these formats are supported to store tries on disk:
 Optionally, you can use a `.zip` version of the supported formats. In order to do so, you'll have to install
 the [`rubyzip`][rubyzip] gem:
 
-``` bash
+```shell
 gem install rubyzip
 ```
 
 Or, include it in your `Gemfile` and bundle it:
 
-``` ruby
+```ruby
 gem 'rubyzip'
 ```
 
 Then, you can load contents form a `.zip` file like this:
 
-``` ruby
+```ruby
 require 'zip'
 trie = Rambling::Trie.load '/path/to/file.zip'
 ```
@@ -316,7 +316,7 @@ WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEM
 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.
 
-[badge_fury_badge]: https://badge.fury.io/rb/rambling-trie.svg?version=2.5.0
+[badge_fury_badge]: https://badge.fury.io/rb/rambling-trie.svg?version=2.5.1
 [badge_fury_link]: https://badge.fury.io/rb/rambling-trie
 [chruby]: https://github.com/postmodern/chruby
 [code_climate_grade_badge]: https://codeclimate.com/github/gonzedge/rambling-trie/badges/gpa.svg

data/Rakefile

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
 require 'bundler/gem_tasks'
+require 'reek/rake/task'
 require 'rspec/core/rake_task'
 require 'rubocop/rake_task'
+require 'steep/rake_task'
+require 'yard'
 
 require 'rambling-trie'
 require_relative 'tasks/performance'
@@ -10,6 +13,9 @@ require_relative 'tasks/serialization'
 require_relative 'tasks/ips'
 
 RSpec::Core::RakeTask.new :spec
+Reek::Rake::Task.new :reek
 RuboCop::RakeTask.new :rubocop
+Steep::RakeTask.new :steep
+YARD::Rake::YardocTask.new :yard
 
 task default: :spec

data/Steepfile

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# D = Steep::Diagnostic
+#
+target :lib do
+  signature 'sig'
+
+  check 'lib'
+  # check 'tasks'
+
+  # check 'Gemfile'
+  # check 'Guardfile'
+  # check 'Rakefile'
+  # check 'Steepfile'
+
+  # library 'rubyzip'
+  library 'yaml'
+  library 'securerandom'
+
+  # configure_code_diagnostics(D::Ruby.default)      # `default` diagnostics setting (applies by default)
+  # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
+  # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
+  # configure_code_diagnostics(D::Ruby.silent)       # `silent` diagnostics setting
+  # configure_code_diagnostics do |hash|             # You can setup everything yourself
+  #   hash[D::Ruby::NoMethod] = :information
+  # end
+end
+
+# target :test do
+#   signature 'sig', 'sig-private'
+#
+#   check 'test'
+#
+#   # library 'pathname'              # Standard libraries
+# end

data/lib/rambling/trie/comparable.rb

@@ -6,8 +6,8 @@ module Rambling
     module Comparable
       # Compares two nodes.
       # @param [Nodes::Node] other the node to compare against.
-      # @return [Boolean] +true+ if the nodes' {Nodes::Node#letter #letter} and
-      #   {Nodes::Node#children_tree #children_tree} are equal, +false+ otherwise.
+      # @return [Boolean] `true` if the nodes' {Nodes::Node#letter #letter} and
+      #   {Nodes::Node#children_tree #children_tree} are equal, `false` otherwise.
       def == other
         letter == other.letter &&
           terminal? == other.terminal? &&

data/lib/rambling/trie/compressible.rb

@@ -5,7 +5,7 @@ module Rambling
     # Provides the compressible behavior for the trie data structure.
     module Compressible
       # Indicates if the current {Rambling::Trie::Nodes::Node Node} can be compressed or not.
-      # @return [Boolean] +true+ for non-{Nodes::Node#terminal? terminal} nodes with one child, +false+ otherwise.
+      # @return [Boolean] `true` for non-{Nodes::Node#terminal? terminal} nodes with one child, `false` otherwise.
       def compressible?
         !(root? || terminal?) && 1 == children_tree.size
       end

data/lib/rambling/trie/compressor.rb

@@ -5,11 +5,13 @@ module Rambling
     # Responsible for the compression process of a trie data structure.
     class Compressor
       # Compresses a {Nodes::Node Node} from a trie data structure.
-      # @param [Nodes::Raw] node the node to compress.
-      # @return [Nodes::Compressed] node the compressed version of the node.
+      # @param [Nodes::Node, nil] node the node to compress.
+      # @return [Nodes::Compressed, nil] node the compressed version of the node.
       def compress node
+        return unless node
+
         if node.compressible?
-          compress_child_and_merge node
+          compress_only_child_and_merge node
         else
           compress_children_and_copy node
         end
@@ -17,40 +19,39 @@ module Rambling
 
       private
 
-      def compress_child_and_merge node
-        merge node, compress(node.first_child)
+      # Compresses a {Nodes::Node Node} with an only child from a trie data structure.
+      # By this point we already know the node is not nil and that it has an only child,
+      # so we use the type annotation because compressed_child will always have a value.
+      # @see Rambling::Trie::Compressible#compressible? Compressible#compressible?
+      # @param [Nodes::Node] node the node to compress.
+      # @return [Nodes::Compressed] node the compressed version of the node.
+      def compress_only_child_and_merge node
+        compressed_child = compress(node.first_child) # : Nodes::Compressed
+        merge node, compressed_child
       end
 
       def merge node, other
-        return new_compressed_node node.letter, node.parent, node.children_tree, node.terminal? if other.nil?
-
         letter = node.letter.to_s << other.letter.to_s
 
-        new_compressed_node letter.to_sym, node.parent, other.children_tree, other.terminal?
+        compressed = Rambling::Trie::Nodes::Compressed.new letter.to_sym, node.parent, other.children_tree
+        compressed.terminal! if other.terminal?
+        compressed
       end
 
       def compress_children_and_copy node
-        new_compressed_node node.letter, node.parent, compress_children(node.children_tree), node.terminal?
+        children_tree = compress_children(node.children_tree)
+        compressed = Rambling::Trie::Nodes::Compressed.new node.letter, node.parent, children_tree
+        compressed.terminal! if node.terminal?
+        compressed
       end
 
       def compress_children tree
         new_tree = {}
 
-        tree.each do |letter, child|
-          compressed_child = compress child
-          new_tree[letter] = compressed_child
-        end
+        tree.each { |letter, child| new_tree[letter] = compress child }
 
         new_tree
       end
-
-      def new_compressed_node letter, parent, tree, terminal
-        node = Rambling::Trie::Nodes::Compressed.new letter, parent, tree
-        node.terminal! if terminal
-
-        tree.each_value { |child| child.parent = node }
-        node
-      end
     end
   end
 end

data/lib/rambling/trie/configuration/properties.rb

@@ -4,6 +4,7 @@ module Rambling
   module Trie
     module Configuration
       # Provides configurable properties for Rambling::Trie.
+      # :reek:TooManyInstanceVariables { max_instance_variables: 5 }
       class Properties
         # The configured {Readers Readers}.
         # @return [ProviderCollection<Readers::Reader>] the mapping of configured {Readers Readers}.
@@ -17,12 +18,12 @@ module Rambling
         # @return [Compressor] the configured compressor.
         attr_accessor :compressor
 
-        # The configured +root_builder+, which returns a {Nodes::Node Node} when called.
-        # @return [Proc<Nodes::Node>] the configured +root_builder+.
+        # The configured `root_builder`, which returns a {Nodes::Node Node} when called.
+        # @return [Proc<Nodes::Node>] the configured `root_builder`.
         attr_accessor :root_builder
 
-        # The configured +tmp_path+, which will be used for throwaway files.
-        # @return [String] the configured +tmp_path+.
+        # The configured `tmp_path`, which will be used for throwaway files.
+        # @return [String] the configured `tmp_path`.
         attr_accessor :tmp_path
 
         # Returns a new properties instance.

data/lib/rambling/trie/configuration/provider_collection.rb

@@ -17,7 +17,7 @@ module Rambling
         #   providers.
         #   @param [TProvider] provider the provider to use as default.
         #   @raise [ArgumentError] when the given provider is not in the provider collection.
-        #   @note If no providers have been configured, +nil+ will be assigned.
+        #   @note If no providers have been configured, `nil` will be assigned.
         # @return [TProvider, nil] the default provider to use when a provider cannot be resolved in
         #   {ProviderCollection#resolve #resolve}.
         attr_reader :default
@@ -58,14 +58,19 @@ module Rambling
         # @param [String] filepath the filepath to resolve into a provider.
         # @return [TProvider, nil] the provider for the given file's extension. {#default} if not found.
         def resolve filepath
-          providers[file_format filepath] || default
+          extension = file_format filepath
+          if providers.key? extension
+            providers[extension]
+          else
+            default
+          end
         end
 
         # Resets the provider collection to the initial values.
         # @return [void]
         def reset
           providers.clear
-          configured_providers.each { |k, v| self[k] = v }
+          configured_providers.each { |extension, provider| self[extension] = provider }
           self.default = configured_default
         end
 
@@ -98,13 +103,13 @@ module Rambling
         end
 
         def file_format filepath
-          format = File.extname filepath
-          format.slice! 0
-          format.to_sym
+          File.extname(filepath).sub(%r{^\.}, '').to_sym
         end
 
         def contains? provider
-          provider.nil? || (providers.any? && provider_instances.include?(provider))
+          return true if provider.nil?
+
+          providers.any? && provider_instances.include?(provider || raise)
         end
 
         alias_method :provider_instances, :values

data/lib/rambling/trie/configuration.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
-%w(properties provider_collection).each do |file|
-  require File.join('rambling', 'trie', 'configuration', file)
-end
+path = File.join 'rambling', 'trie', 'configuration'
+%w(properties provider_collection).each { |file| require File.join(path, file) }
 
 module Rambling
   module Trie

data/lib/rambling/trie/container.rb

@@ -28,7 +28,7 @@ module Rambling
       # @see Nodes::Raw#add
       # @see Nodes::Compressed#add
       def add word
-        root.add char_symbols word
+        root.add reversed_char_symbols word
       end
 
       # Adds all provided words to the trie.
@@ -62,7 +62,7 @@ module Rambling
 
       # Checks if a path for a word or partial word exists in the trie.
       # @param [String] word the word or partial word to look for in the trie.
-      # @return [Boolean] +true+ if the word or partial word is found, +false+ otherwise.
+      # @return [Boolean] `true` if the word or partial word is found, `false` otherwise.
       # @see Nodes::Node#partial_word?
       def partial_word? word = ''
         root.partial_word? word.chars
@@ -81,8 +81,8 @@ module Rambling
 
       # Checks if a whole word exists in the trie.
       # @param [String] word the word to look for in the trie.
-      # @return [Boolean] +true+ only if the word is found and the last character corresponds to a terminal node,
-      #   +false+ otherwise.
+      # @return [Boolean] `true` only if the word is found and the last character corresponds to a terminal node,
+      #   `false` otherwise.
       # @see Nodes::Node#word?
       def word? word = ''
         root.word? word.chars
@@ -98,7 +98,7 @@ module Rambling
 
       # Returns all words within a string that match a word contained in the trie.
       # @param [String] phrase the string to look for matching words in.
-      # @return [Enumerator<String>] all the words in the given string that match a word in the trie.
+      # @return [Array<String>] all the words in the given string that match a word in the trie.
       # @yield [String] each word found in phrase.
       def words_within phrase
         words_within_root(phrase).to_a
@@ -106,7 +106,7 @@ module Rambling
 
       # Checks if there are any valid words in a given string.
       # @param [String] phrase the string to look for matching words in.
-      # @return [Boolean] +true+ if any word within phrase is contained in the trie, +false+ otherwise.
+      # @return [Boolean] `true` if any word within phrase is contained in the trie, `false` otherwise.
       # @see Container#words_within
       def words_within? phrase
         words_within_root(phrase).any?
@@ -114,7 +114,7 @@ module Rambling
 
       # Compares two trie data structures.
       # @param [Container] other the trie to compare against.
-      # @return [Boolean] +true+ if the tries are equal, +false+ otherwise.
+      # @return [Boolean] `true` if the tries are equal, `false` otherwise.
       def == other
         root == other.root
       end
@@ -125,9 +125,7 @@ module Rambling
       def each
         return enum_for :each unless block_given?
 
-        root.each do |word|
-          yield word
-        end
+        root.each { |word| yield word }
       end
 
       # @return [String] a string representation of the container.
@@ -152,14 +150,14 @@ module Rambling
 
       # Root node's children tree.
       # @return [Hash<Symbol, Nodes::Node>] the children tree hash contained in the root node, consisting of
-      #   +:letter => node+.
+      #   `:letter => node`.
       # @see Nodes::Node#children_tree
       def children_tree
         root.children_tree
       end
 
       # Indicates if the root {Nodes::Node Node} can be compressed or not.
-      # @return [Boolean] +true+ for non-{Nodes::Node#terminal? terminal} nodes with one child, +false+ otherwise.
+      # @return [Boolean] `true` for non-{Nodes::Node#terminal? terminal} nodes with one child, `false` otherwise.
       def compressed?
         root.compressed?
       end
@@ -201,22 +199,21 @@ module Rambling
         return enum_for :words_within_root, phrase unless block_given?
 
         chars = phrase.chars
-        0.upto(chars.length - 1).each do |starting_index|
-          new_phrase = chars.slice starting_index..(chars.length - 1)
-          root.match_prefix new_phrase do |word|
-            yield word
-          end
-        end
+        size = chars.length
+        # rubocop:disable Style/CommentedKeyword
+        0.upto(size - 1).each do |starting_index|
+          new_phrase = chars.slice starting_index, size # : Array[String]
+          root.match_prefix(new_phrase) { |word| yield word }
+        end # : Enumerator[String, void]
+        # rubocop:enable Style/CommentedKeyword
       end
 
       def compress_root
-        compressor.compress root
+        compressor.compress root # : Nodes::Compressed
       end
 
-      def char_symbols word
-        symbols = []
-        word.reverse.each_char { |c| symbols << c.to_sym }
-        symbols
+      def reversed_char_symbols word
+        word.reverse.chars.map(&:to_sym).to_a
       end
     end
   end