rambling-trie 2.5.0 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a489fbd736614f76449e3f4254d798e759e120985a1b141fbae17ec12330c2f
-  data.tar.gz: e92201410e743a5660fcbbb9703f68ee4e41366b9c4ee987a65f8fd78ea46d0f
+  metadata.gz: 52fe8e610cf15d433a18cbb24cdd4b72c48a4ab50398868ab68cce58ea0a8de6
+  data.tar.gz: a106639989c7ad33230c252d470a9c7924fd65204ab633743bd813d4f69fa4d4
 SHA512:
-  metadata.gz: a0c8f6af0ce43902f5292829e48dfa86e3ca1b623a0742ac129af57bc10209249879f5bdf7ecb4feb65f03da6986748e8cc77f1c458816b8e1aa96063372fc5b
-  data.tar.gz: 1cc6eb48bf18cdace40358e3ed9371f012f164d5fb6f37e7ff99ce01a4ed0a71d18b21821c3cfef324ebf0ae59c18c2a4fe11e2c8a12044de649c75772221fcb
+  metadata.gz: 6d4659cf7e712e4fbed4e6054d6f27f7db0ecbf4dca13fcad6cab34c3050b78cb63cee7993ccda2146868b8d7203932bea08667bb510d0afdcada8cb403c3418
+  data.tar.gz: a36621b0ee84dbb8905ca8af25b8fc1b2b08a23ce171fb83c3ec632f39ffc1e7108828330eb93c4285948e5c32a1a6c6d116ad74d9da5a28aa9bd428110dafe5

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,40 @@ 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', require: false
+  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 'irb', 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

@@ -9,9 +9,6 @@
 [![Documentation Status][inch_ci_badge]][rubydoc]
 [![CodeQL Status][github_action_codeql_badge]][github_action_codeql_link]
 
-[![Code Climate Grade][code_climate_grade_badge]][code_climate_link]
-[![Code Climate Issue Count][code_climate_issues_badge]][code_climate_link]
-
 The Rambling Trie is a Ruby implementation of the [trie data structure][trie_wiki], which includes compression abilities
 and is designed to be very fast to traverse.
 
@@ -21,22 +18,22 @@ and is designed to be very fast to traverse.
 
 You will need:
 
-* Ruby 3.1.0 or up
+* Ruby 3.2.0 or up
 * RubyGems
 
-See [RVM][rvm], [rbenv][rbenv] or [chruby][chruby] for more information on how to manage Ruby versions.
+See [asdf][asdf], [RVM][rvm], [rbenv][rbenv] or [chruby][chruby] for more information on how to manage Ruby versions.
 
 ### Installation
 
 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 +43,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 +58,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
@@ -77,22 +74,21 @@ trie
 ```
 
 If you want to use a custom file format, you will need to provide a custom `Reader` that defines an `#each_word` method
-that yields each word contained in the file. Look at the [`PlainText` reader][rambling_trie_plain_text_reader] class for
-an example, and at the [Configuration section][rambling_trie_configuration] to see how to add your own custom file
-readers.
+that yields each word contained in the file. Look at the [`PlainText` reader](./lib/rambling/trie/readers/plain_text.rb)
+class for an example, and at the [Configuration section](#configuration) to see how to add your own custom file readers.
 
 ### Operations
 
 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 +100,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 +108,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 +130,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 +140,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 +153,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 +169,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' }
@@ -182,21 +178,21 @@ trie.all? { |word| word.include? 'x' }
 
 ### Serialization
 
-Starting from version 1.0.0, you can store a full trie instance on disk and retrieve/use it later on. Loading a trie
+Starting from version `1.0.0`, you can store a full trie instance on disk and retrieve/use it later on. Loading a trie
 from disk takes less time, less cpu and less memory than loading every word into the trie every time. This is
 particularly useful for production applications, when you have word lists that you know are going to be static, or that
 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'
 ```
 
@@ -206,27 +202,34 @@ Currently, these formats are supported to store tries on disk:
 
 * Ruby's [binary (Marshal)][marshal] format
 * [YAML][yaml]
+* Zip version of any other format ([optional `rubyzip` dependency](#optional-rubyzip-dependency))
 
-> When dumping into or loading from disk, the format is determined
-> automatically based on the file extension, so `.yml` or `.yaml` files will be
-> handled through `YAML` and `.marshal` files through `Marshal`.
+> When dumping into or loading from disk, the format is determined automatically based on the file extension, so `.yml`
+> or `.yaml` files will be handled through `YAML` and `.marshal` files through `Marshal`.
 
-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:
+##### Optional `rubyzip` dependency
 
-``` bash
+Compressed versions of all other [supported formats](#supported-formats) are available via the [`rubyzip`][rubyzip] gem.
+This is an optional dependency.
+
+> ⚠️ Rambling Trie `2.6.0` and above support `rubyzip` `3.x` only.
+> For `rubyzip` `2.x` support, use Rambling Trie `2.5.1` and below.
+
+```shell
 gem install rubyzip
+# or gem install rubyzip --version '<3` for 2.x
 ```
 
 Or, include it in your `Gemfile` and bundle it:
 
-``` ruby
+```ruby
 gem 'rubyzip'
+# or gem 'rubyzip', '<3' for 2.x
 ```
 
 Then, you can load contents form a `.zip` file like this:
 
-``` ruby
+```ruby
 require 'zip'
 trie = Rambling::Trie.load '/path/to/file.zip'
 ```
@@ -274,12 +277,14 @@ want edge documentation, you can go the [GitHub project RubyDoc.info page][rubyd
 
 The Rambling Trie has been tested with the following Ruby versions:
 
+* 4.0.x
+* 3.4.x
 * 3.3.x
 * 3.2.x
-* 3.1.x
 
 **No longer supported**:
 
+* 3.1.x (EOL'ed)
 * 3.0.x (EOL'ed)
 * 2.7.x (EOL'ed)
 * 2.6.x (EOL'ed)
@@ -292,9 +297,14 @@ The Rambling Trie has been tested with the following Ruby versions:
 * 1.9.x (EOL'ed)
 * 1.8.x (EOL'ed)
 
+## Compatible RBS and Steep versions
+
+Type signatures for `Rambling::Trie` are included in the [`sig` directory](./sig)! The current version (`2.6.0`) was
+checked with RBS `3.10.4` and Steep `1.10.0`.
+
 ## Contributing to Rambling Trie
 
-Take a look at the [contributing guide][rambling_trie_contributing_guide] to get started, or fire a question
+Take a look at the [contributing guide](./CONTRIBUTING.md) to get started, or fire a question
 to [@gonzedge][github_user_gonzedge].
 
 ## License and copyright
@@ -316,7 +326,8 @@ 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
+[asdf]: https://asdf-vm.com/
+[badge_fury_badge]: https://badge.fury.io/rb/rambling-trie.svg?version=2.6.0
 [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
@@ -337,9 +348,6 @@ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 [license_badge]: https://img.shields.io/badge/license-MIT-blue.svg
 [license_link]: https://opensource.org/licenses/mit-license.php
 [marshal]: https://ruby-doc.org/3.3.0/Marshal.html
-[rambling_trie_configuration]: https://github.com/gonzedge/rambling-trie#configuration
-[rambling_trie_contributing_guide]: https://github.com/gonzedge/rambling-trie/blob/main/CONTRIBUTING.md
-[rambling_trie_plain_text_reader]: https://github.com/gonzedge/rambling-trie/blob/main/lib/rambling/trie/readers/plain_text.rb
 [rbenv]: https://github.com/sstephenson/rbenv
 [rubydoc]: http://rubydoc.info/gems/rambling-trie
 [rubydoc_github]: http://rubydoc.info/github/gonzedge/rambling-trie

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,51 @@ 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) || raise(InvalidOperation, 'got nil while compressing only child')
+        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
+        if other.terminal?
+          compressed.terminal!
+          value = other.value
+          compressed.value = value if value
+        end
+        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
+        if node.terminal?
+          compressed.terminal!
+          value = node.value
+          compressed.value = value if value
+        end
+        compressed
       end
 
       def compress_children tree
+        # @type var new_tree: Hash[Symbol, Nodes::Node]
         new_tree = {}
 
         tree.each do |letter, child|
-          compressed_child = compress child
+          compressed_child = compress(child) || raise(InvalidOperation, "got nil while compressing #{letter}")
           new_tree[letter] = compressed_child
         end
 
         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