gem_bench 2.0.3 → 2.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba58266e066c47120ecba80dcd81b5aa35cf2e35132e5eb8f8bc62a0cfdcb8b4
-  data.tar.gz: 9b491c517466e244b98f8d01152daa213a5947d9de92970abae6ad64076842ef
+  metadata.gz: 47591b1b5f1880cbb2c40be1199aa7fa65a25d2c32ca52131ba54e0e89d8b6b7
+  data.tar.gz: 93aad6d4e020398b93ffdaa2e8fddfce5b5e5cc4fa08854f22850dcccee9f0ee
 SHA512:
-  metadata.gz: 8eb0b66dc41d9913fad9e88599908cf0e1787e01701e64ade5e065ac4428853b726855345704742a9279dc7dba74fef2eea4c7d4eb84495f7cc46438b07051a5
-  data.tar.gz: 9f8b0b6419d6c8ffeb0999149a4c7bc797723dd3a4e362025644c83813e4cb5e3c065b4b7e0bcd8e55d941d7ad3a395072510a7895bfe910b3eb8fad0b6627a9
+  metadata.gz: 47827b59b13ee527cecfc8db349437c0fc416aa53fa83b4138a6c1884652d857ce9be708ec534e099b8a41f47914b831d8f73e09e430134f4deb050714a1925a
+  data.tar.gz: 9ae3067637e3293209bde40127e55ad42882b075ca71fc65e7b025ec5dd4e160f5669767e6990a8a0db915ff6031f1555e432cc6a110e32b09346a710fd304bf

data/CHANGELOG.md

@@ -11,6 +11,23 @@ and this project adheres to [Semantic Versioning v2](https://semver.org/spec/v2.
 ### Fixed
 ### Removed
 
+## [2.0.4] SEP.20.2024
+- COVERAGE:  98.19% -- 488/497 lines in 9 files
+- BRANCH COVERAGE:  88.95% -- 161/181 branches in 9 files
+- 58.06% documented
+### Added
+- More Documentation
+- Almost 100% test coverage
+- Thread Safety (removed `GemBench.roster`, which was effectively never used internally)
+- Performance improvements
+### Fixed
+- Can now handle more variations of Ruby syntax in the Gemfile analyzer
+- `require_relative` > `require` for internal files (except for `spec` => `lib`)
+- Updated logic for version specified via git with branch, tag, ref (to match fixes to Bundler's behavior)
+- Ambiguous naming of `GemBench::Jersey#primary_namespace` is split to:
+  - `#doffed_primary_namespace`
+  - `#donned_primary_namespace`
+
 ## [2.0.3] SEP.18.2024
 ### Added
 - More documentation
@@ -19,9 +36,9 @@ and this project adheres to [Semantic Versioning v2](https://semver.org/spec/v2.
 - Copyright years
 
 ## [2.0.2] SEP.17.2024
-COVERAGE:  82.15% -- 382/465 lines in 9 files
-BRANCH COVERAGE:  58.79% -- 97/165 branches in 9 files
-51.72% documented
+- COVERAGE:  82.15% -- 382/465 lines in 9 files
+- BRANCH COVERAGE:  58.79% -- 97/165 branches in 9 files
+- 51.72% documented
 ### Added
 - CI for Ancient Rubies
   - Ruby 2.3
@@ -34,9 +51,9 @@ BRANCH COVERAGE:  58.79% -- 97/165 branches in 9 files
 - Gemspec description & Summary
 
 ## [2.0.1] SEP.17.2024
-COVERAGE:  82.15% -- 382/465 lines in 9 files
-BRANCH COVERAGE:  58.08% -- 97/167 branches in 9 files
-51.72% documented
+- COVERAGE:  82.15% -- 382/465 lines in 9 files
+- BRANCH COVERAGE:  58.08% -- 97/167 branches in 9 files
+- 51.72% documented
 ### Added
 - Ability to re-namespace and load copy of a gem alongside vanilla version for benchmarking via `GemBench::Jersey`
   - See: https://github.com/panorama-ed/memo_wise/pull/339

data/README.md

@@ -98,14 +98,13 @@ Regex search through all of a project's source code, including installed Bundler
 
 🛟 Trim down app load times, such as on Heroku, by finding and keeping your worst players on the bench.
 
-| Project        | GemBench                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-|----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| gem name       | [gem_bench](https://rubygems.org/gems/gem_bench)                                                                                                                                                                                                                                                                                                                                                                                                      |
-| code triage    | [![Open Source Helpers](https://www.codetriage.com/pboling/gem_bench/badges/users.svg)](https://www.codetriage.com/pboling/gem_bench)                                                                                                                                                                                                                                                                                                                 |
-| homepage       | [on Github.com][homepage]                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| documentation  | [on Rdoc.info][documentation]                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| expert support | [![Get help on Codementor](https://cdn.codementor.io/badges/get_help_github.svg)](https://www.codementor.io/peterboling?utm_source=github&utm_medium=button&utm_term=peterboling&utm_campaign=github)                                                                                                                                                                                                                                                 |
-| `...` 💖       | [![Liberapay Patrons][⛳liberapay-img]][⛳liberapay] [![Sponsor Me][🖇sponsor-img]][🖇sponsor] [![Follow Me on LinkedIn][🖇linkedin-img]][🖇linkedin] [![Find Me on WellFound:][✌️wellfound-img]][✌️wellfound] [![Find Me on CrunchBase][💲crunchbase-img]][💲crunchbase] [![My LinkTree][🌳linktree-img]][🌳linktree] [![Follow Me on Ruby.Social][🐘ruby-mast-img]][🐘ruby-mast] [![Tweet @ Peter][🐦tweet-img]][🐦tweet] [💻][coderme] [🌏][aboutme] |
+| Primary Namespace | `GemBench`                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+|-------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| gem name          | [gem_bench](https://rubygems.org/gems/gem_bench)                                                                                                                                                                                                                                                                                                                                                                                                      |
+| code triage       | [![Open Source Helpers](https://www.codetriage.com/pboling/gem_bench/badges/users.svg)](https://www.codetriage.com/pboling/gem_bench)                                                                                                                                                                                                                                                                                                                 |
+| documentation     | [on Github.com][homepage], [on Rdoc.info][documentation]                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| expert support    | [![Get help on Codementor](https://cdn.codementor.io/badges/get_help_github.svg)](https://www.codementor.io/peterboling?utm_source=github&utm_medium=button&utm_term=peterboling&utm_campaign=github)                                                                                                                                                                                                                                                 |
+| `...` 💖          | [![Liberapay Patrons][⛳liberapay-img]][⛳liberapay] [![Sponsor Me][🖇sponsor-img]][🖇sponsor] [![Follow Me on LinkedIn][🖇linkedin-img]][🖇linkedin] [![Find Me on WellFound:][✌️wellfound-img]][✌️wellfound] [![Find Me on CrunchBase][💲crunchbase-img]][💲crunchbase] [![My LinkTree][🌳linktree-img]][🌳linktree] [![Follow Me on Ruby.Social][🐘ruby-mast-img]][🐘ruby-mast] [![Tweet @ Peter][🐦tweet-img]][🐦tweet] [💻][coderme] [🌏][aboutme] |
 
 <!-- 7️⃣ spread 💖 -->
 [🐦tweet-img]: https://img.shields.io/twitter/follow/galtzo.svg?style=social&label=Follow%20%40galtzo
@@ -163,8 +162,43 @@ NOTE: It is not required by default, so you do need to require the Jersey if you
 require "gem_bench/jersey"
 ```
 
+#### Usage
+
+If the original gem defines multiple top-level namespaces,
+they can all be renamed by providing more key value pairs in `trades`.
+If the original gem monkey patches other libraries,
+that behavior can't be isolated, so YMMV.
+
+NOTE: Non-top-level namespaces do not need to be renamed,
+as they are isolated within their parent namespace.
+
+#### Example
+
 For a real example, see: https://github.com/panorama-ed/memo_wise/pull/339
 
+#### Naming: Why `doff_and_don`?
+
+> Wouldn't "copy_gem" make sense?
+
+Actually copy is an overloaded term, which creates confusion in this use case.
+This method Generates a temp directory, and creates a copy of a gem within it.
+Re-namespaces the copy according to the `trades` configuration.
+Then requires each file of the "copied gem", resulting
+in a loaded gem that will not have namespace
+collisions when loaded alongside the original-namespaced gem.
+Note that "copied gem" in the previous sentence is ambiguous without the supporting context.
+The "copied gem" can mean either the original, or the "copy", which is why this gem refers to
+a "doffed gem" (the original) and a "donned gem" (the copy).
+
+Also because `Jersey`.  Duh...
+
+#### Advanced Usage
+
+If a block is provided the contents of each file will be yielded to the block,
+after all namespace substitutions from `trades` are complete, but before the contents
+are written to the donned (re-namespaced) gem. The return value of the block will be
+written to the file in this scenario.
+
 ### New for 2.0.0 - Dropped Support for Ruby 2.0, 2.1, 2.2
 
 - Required Ruby is now 2.3+

data/lib/gem_bench/gemfile_line_tokenizer.rb

@@ -1,14 +1,51 @@
 module GemBench
+  # Line by line parser of a Gemfile
+  # Uses regular expressions, which, I know, GROSS, but also meh
+  # You aren't using this as a runtime gem in your app are you?
+  # Let me know how you use it!
   class GemfileLineTokenizer
     GEM_REGEX = /\A\s*gem\s+([^#]*).*\Z/.freeze # run against gem lines like: "gem 'aftership', # Ruby SDK of AfterShip API."
-    GEM_NAME_REGEX = /\A\s*gem\s+['"]{1}(?<name>[^'"]*)['"].*\Z/.freeze # run against gem lines like: "gem 'aftership', # Ruby SDK of AfterShip API."
-    VERSION_CONSTRAINT = /['"]{1}([^'"]*)['"]/.freeze
+    # HEREDOC support? (?<op_heredoc><<[~-]?[A-Z0-9_]+\.?[a-z0-9_]+)
+    OP_QUO_REG_PROC = lambda { |idx = nil| /((?<op_quo#{idx}>['"]{1})|(?<op_pct_q#{idx}>%[Qq]?[\(\[\{]{1})|(?<op_heredoc><<[~-]?[A-Z0-9_]+\.?[a-z0-9_]+))/x }
+    # No close for the heredoc, as it will be on a different line...
+    CL_QUO_REG_PROC = lambda { |idx = nil| /((?<cl_quo#{idx}>['"])|(?<cl_pct_q#{idx}>[\)\]\}]{1}))/x }
+    GEM_NAME_REGEX = /\A\s*gem\s+#{OP_QUO_REG_PROC.call.source}(?<name>[^'")]*)#{CL_QUO_REG_PROC.call.source}?.*\Z/.freeze # run against gem lines like: "gem 'aftership', # Ruby SDK of AfterShip API."
+    VERSION_CONSTRAINT = /#{OP_QUO_REG_PROC.call.source}(?<version>[^'")]*)#{CL_QUO_REG_PROC.call.source}/.freeze
     GEMFILE_HASH_CONFIG_KEY_REGEX_PROC = lambda { |key|
-      /\A\s*[^#]*(?<key1>#{key}: *)['"]{1}(?<value1>[^'"]*)['"]|(?<key2>['"]#{key}['"] *=> *)['"]{1}(?<value2>[^'"]*)['"]|(?<key3>:#{key} *=> *)['"]{1}(?<value3>[^'"]*)['"]/
+      /
+        \A\s*[^#]*
+        (
+          # when key is "branch" will find: `branch: "main"`
+          (?<key1>#{key}:\s*)
+          #{OP_QUO_REG_PROC.call("k1").source}(?<value1>[^'")]*)?#{CL_QUO_REG_PROC.call("k1").source}
+        )
+        |
+        (
+          # when key is "branch" will find: `"branch" => "main"`
+          (?<key2>#{OP_QUO_REG_PROC.call("k2a").source}#{key}#{CL_QUO_REG_PROC.call("k2a").source}\s*=>\s*)
+          #{OP_QUO_REG_PROC.call("k2b").source}(?<value2>[^'")]*)?#{CL_QUO_REG_PROC.call("k2b").source}
+        )
+        |
+        (
+          # when key is "branch" will find: `:branch => "main"`
+          (?<key3>:#{key}\s*=>\s*)
+          #{OP_QUO_REG_PROC.call("k3").source}(?<value3>[^'")]*)?#{CL_QUO_REG_PROC.call("k3").source}
+        )
+        |
+        (
+          # when key is "branch" will find: `"branch": "main"`
+          (?<key4>#{OP_QUO_REG_PROC.call("k4a").source}#{key}#{CL_QUO_REG_PROC.call("k4a").source}:\s*)
+          #{OP_QUO_REG_PROC.call("k4b").source}(?<value4>[^'")]*)?#{CL_QUO_REG_PROC.call("k4b").source}
+        )
+      /x
     }
     VERSION_PATH = GEMFILE_HASH_CONFIG_KEY_REGEX_PROC.call("path").freeze
     VERSION_GIT = GEMFILE_HASH_CONFIG_KEY_REGEX_PROC.call("git").freeze
     VERSION_GITHUB = GEMFILE_HASH_CONFIG_KEY_REGEX_PROC.call("github").freeze
+    VERSION_GITLAB = GEMFILE_HASH_CONFIG_KEY_REGEX_PROC.call("gitlab").freeze
+    VERSION_BITBUCKET = GEMFILE_HASH_CONFIG_KEY_REGEX_PROC.call("bitbucket").freeze
+    VERSION_CODEBERG = GEMFILE_HASH_CONFIG_KEY_REGEX_PROC.call("codeberg").freeze
+    VERSION_SRCHUT = GEMFILE_HASH_CONFIG_KEY_REGEX_PROC.call("srchut").freeze
     VERSION_GIT_REF = GEMFILE_HASH_CONFIG_KEY_REGEX_PROC.call("ref").freeze
     VERSION_GIT_TAG = GEMFILE_HASH_CONFIG_KEY_REGEX_PROC.call("tag").freeze
     VERSION_GIT_BRANCH = GEMFILE_HASH_CONFIG_KEY_REGEX_PROC.call("branch").freeze
@@ -17,13 +54,19 @@ module GemBench
       git_ref
       git_tag
     ]
-    # branch is only valid if the branch is not master
+    STR_SYNTAX_TYPES = {
+      quoted: true,
+      pct_q: true,
+      # We could try to support HEREDOC via parsing the lines following in all_lines, but... ugh.
+      heredoc: false,
+      unknown: false,
+    }.freeze
     attr_reader :line
     attr_reader :relevant_lines, :is_gem, :all_lines, :index, :tokens, :version_type, :name, :parse_success, :valid
     # version will be a string if it is a normal constraint like '~> 1.2.3'
     # version will be a hash if it is an alternative constraint like:
     # git: "blah/blah", ref: "shasha"
-    attr_reader :version
+    attr_reader :version, :str_syntax_type
 
     def initialize(all_lines, line, index)
       @line = line.strip
@@ -31,9 +74,9 @@ module GemBench
       if is_gem
         @all_lines = all_lines
         @index = index
-        @tokens = self.line.split(",")
+        @tokens = self.line.split(",").map(&:strip)
         determine_name
-        if name
+        if name && STR_SYNTAX_TYPES[str_syntax_type]
           determine_relevant_lines
           determine_version
           @parse_success = true
@@ -49,35 +92,61 @@ module GemBench
     private
 
     # not a gem line.  noop.
+    #
+    # @return void
     def noop
       @parse_success = false
       @valid = false
+
+      nil
     end
 
+    # @return void
     def determine_name
       # uses @tokens[0] because the gem name must be before the first comma
       match_data = @tokens[0].match(GEM_NAME_REGEX)
+      @str_syntax_type =
+        if match_data[:op_quo] && match_data[:cl_quo]
+          :quoted
+        elsif match_data[:op_pct_q] && match_data[:cl_pct_q]
+          :pct_q
+        # Not handling heredoc, aside from not exploding, as it isn't a reasonable use case.
+        # elsif match_data[:op_heredoc]
+        #   :heredoc
+        else
+          :unknown
+        end
       @name = match_data[:name]
+
+      nil
     end
 
+    # @return void
     def determine_relevant_lines
       @relevant_lines = [line, *following_non_gem_lines].compact
+
+      nil
     end
 
+    # @return void
     def determine_version
-      version_path ||
-        (
-          (version_git || version_github) && (
-            check_for_version_of_type_git_ref ||
-            check_for_version_of_type_git_tag ||
-            check_for_version_of_type_git_branch
-          )
-        ) ||
+      @version = {}
+      return if version_path
+
+      (
+        (version_git || version_provider) && (
+          check_for_version_of_type_git_tag ||
+          check_for_version_of_type_git_branch
+        )
+      ) ||
         # Needs to be the last check because it can only check for a quoted string,
         #   and quoted strings are part of the other types, so they have to be checked first with higher specificity
         check_for_version_of_type_constraint
+
+      nil
     end
 
+    # @return [true, false]
     def check_for_version_of_type_constraint
       # index 1 of the comma-split tokens will usually be the version constraint, if there is one
       possible_constraint = @tokens[1]
@@ -85,7 +154,7 @@ module GemBench
 
       match_data = possible_constraint.strip.match(VERSION_CONSTRAINT)
       # the version constraint is in a regex capture group
-      if match_data && (@version = match_data[1].strip)
+      if match_data && (@version = match_data[:version].strip)
         @version_type = :constraint
         true
       else
@@ -93,8 +162,8 @@ module GemBench
       end
     end
 
+    # @return [true, false]
     def version_path
-      @version = {}
       line = relevant_lines.detect { |next_line| next_line.match(VERSION_PATH) }
       return false unless line
 
@@ -105,8 +174,8 @@ module GemBench
       )
     end
 
+    # @return [true, false]
     def version_git
-      @version = {}
       line = relevant_lines.detect { |next_line| next_line.match(VERSION_GIT) }
       return false unless line
 
@@ -117,21 +186,40 @@ module GemBench
       )
     end
 
-    def version_github
-      @version = {}
-      line = relevant_lines.detect { |next_line| next_line.match(VERSION_GITHUB) }
-      return false unless line
+    # @return [true, false]
+    def version_provider
+      matcher = nil
+      line = relevant_lines.detect do |next_line|
+        matcher =
+          case next_line
+          when VERSION_GITHUB
+            VERSION_GITHUB
+          when VERSION_GITLAB
+            VERSION_GITLAB
+          when VERSION_BITBUCKET
+            VERSION_BITBUCKET
+          when VERSION_CODEBERG
+            VERSION_CODEBERG
+          when VERSION_SRCHUT
+            VERSION_SRCHUT
+          end
+      end
+      return false unless line && matcher
 
       enhance_version(
-        line.match(VERSION_GITHUB),
+        line.match(matcher),
         :github,
         :github,
       )
     end
 
-    def check_for_version_of_type_git_ref
+    # @return [true, false]
+    def check_for_version_of_type_git_branch
+      return false unless _check_for_version_of_type_git_branch
+
       line = relevant_lines.detect { |next_line| next_line.match(VERSION_GIT_REF) }
-      return false unless line
+      # At this point we at least have a branch, though perhaps not a ref.
+      return true unless line
 
       enhance_version(
         line.match(VERSION_GIT_REF),
@@ -140,6 +228,7 @@ module GemBench
       )
     end
 
+    # @return [true, false]
     def check_for_version_of_type_git_tag
       line = relevant_lines.detect { |next_line| next_line.match(VERSION_GIT_TAG) }
       return false unless line
@@ -151,7 +240,8 @@ module GemBench
       )
     end
 
-    def check_for_version_of_type_git_branch
+    # @return [true, false]
+    def _check_for_version_of_type_git_branch
       line = relevant_lines.detect { |next_line| next_line.match(VERSION_GIT_BRANCH) }
       return false unless line
 
@@ -162,7 +252,7 @@ module GemBench
       )
     end
 
-    # returns an array with each line following the current line, which is not a gem line
+    # @return [Array[String]] - each line following the current line, which is not a gem line
     def following_non_gem_lines
       all_lines[(index + 1)..-1]
         .reject { |x| x.strip.empty? || x.match(GemBench::TRASH_REGEX) }
@@ -174,23 +264,25 @@ module GemBench
       end
     end
 
-    # returns a hash like:
-    #   {"key" => ":git => ", "value" => "https://github.com/cte/aftership-sdk-ruby.git"}
-    def normalize_match_data_captures(match_data)
-      match_data.names.each_with_object({}) do |capture, mem|
-        mem[capture.gsub(/\d/, "")] = match_data[capture]
-        break mem if mem.keys.length >= 2
-      end
+    # @return [String] the name of the named capture which has a value (one of: value1, value2, value3, etc.)
+    def determine_named_capture(match_data)
+      match_data.names
+        .select { |name| name.start_with?("value") }
+        .detect { |capture| !match_data[capture]&.empty? }
     end
 
+    # @return [true]
     def enhance_version(match_data, version_key, type)
-      return false unless match_data
-
-      normalized_capture = normalize_match_data_captures(match_data) if match_data
-      return false unless normalized_capture
+      named_capture = determine_named_capture(match_data)
+      value = match_data[named_capture]
+      if value
+        @version[version_key] = value
+        @version_type = type
+      else
+        @version[version_key] = ""
+        @version_type = :invalid
+      end
 
-      @version.merge!({version_key => normalized_capture["value"]})
-      @version_type = type
       true
     end
   end

data/lib/gem_bench/jersey.rb

@@ -1,29 +1,32 @@
 # Std Libs Dependencies
 require "tmpdir"
 
-# Re-write a gem to a temp directory, re-namespace the primary namespace of that gem module, and load it.
-# If the original gem defines multiple top-level namespaces, they can all be renamed by providing more key value pairs.
-# If the original gem monkey patches other libraries, that behavior can't be isolated, so YMMV.
-#
-# NOTE: Non-top-level namespaces do not need to be renamed, as they are isolated within their parent namespace.
-#
-# Usage
-#
-#   jersey = GemBench::Jersey.new(
-#     gem_name: "alt_memery"
-#     trades: {
-#       "Memery" => "AltMemery"
-#     },
-#     metadata: {
-#       something: "a value here",
-#       something_else: :obviously,
-#     },
-#   )
-#   jersey.doff_and_don
-#   # The re-namespaced constant is now available!
-#   AltMemery # => AltMemery
-#
 module GemBench
+  # Re-write a gem to a temp directory, re-namespace the primary namespace of that gem module, and load it.
+  # If the original gem defines multiple top-level namespaces, they can all be renamed by providing more key value pairs.
+  # If the original gem monkey patches other libraries, that behavior can't be isolated, so YMMV.
+  #
+  # NOTE: Non-top-level namespaces do not need to be renamed, as they are isolated within their parent namespace.
+  #
+  # Usage
+  #
+  #   jersey = GemBench::Jersey.new(
+  #     gem_name: "alt_memery"
+  #     trades: {
+  #       "Memery" => "AltMemery"
+  #     },
+  #     metadata: {
+  #       something: "a value here",
+  #       something_else: :obviously,
+  #     },
+  #   )
+  #   jersey.doff_and_don
+  #   # The re-namespaced constant is now available!
+  #   AltMemery # => AltMemery
+  #
+  # Benchmarking Example
+  #
+  #   See: https://github.com/panorama-ed/memo_wise/blob/main/benchmarks/benchmarks.rb
   class Jersey
     attr_reader :gem_name
     attr_reader :gem_path
@@ -41,110 +44,141 @@ module GemBench
       @verbose = verbose
     end
 
+    # return [true, false] proxy for whether the copied, re-namespaced gem has been successfully loaded
     def required?
       gem_path && trades.values.all? { |new_namespace| Object.const_defined?(new_namespace) }
     end
 
-    # Generates tempfiles and requires them, resulting
+    # Generates a temp directory, and creates a copy of a gem within it.
+    # Re-namespaces the copy according to the `trades` configuration.
+    # Then requires each file of the "copied gem", resulting
     #   in a loaded gem that will not have namespace
-    #   collisions when alongside the original-namespaced gem.
+    #   collisions when loaded alongside the original-namespaced gem.
+    # Note that "copied gem" in the previous sentence is ambiguous without the supporting context.
+    # The "copied gem" can mean either the original, or the "copy", which is why this gem refers to
+    #   a "doffed gem" (the original) and a "donned gem" (the copy).
     # If a block is provided the contents of each file will be yielded to the block,
-    #   after all namespace substitutions are complete, but before the contents
+    #   after all namespace substitutions from `trades` are complete, but before the contents
     #   are written to the re-namespaced gem. The return value of the block will be
     #   written to the file in this scenario.
     #
     # @return void
     def doff_and_don(&block)
-      return puts "Skipping #{gem_name} (not loaded on #{RUBY_VERSION})" unless gem_path
+      return puts "[#{gem_name}] Skipped (not loaded on #{RUBY_VERSION})" unless gem_path
 
-      puts "Doffing #{gem_path}" if verbose
-      Dir.mktmpdir do |directory|
+      puts "[#{gem_name}] Doffing #{gem_path}" if verbose
+      Dir.mktmpdir do |tmp_dir|
         files = []
         Dir[File.join(gem_path, "lib", "**", "*.rb")].map do |file|
           if verbose
-            puts file
-            puts File.basename(file)
-            puts "--------------------------------"
+            puts "[#{gem_name}] --------------------------------"
+            puts "[#{gem_name}] Doffing file #{file}"
+            puts "[#{gem_name}] --------------------------------"
           end
+          basename = File.basename(file)
           dirname = File.dirname(file)
-          puts "dirname: #{dirname}" if verbose
+          puts "[#{gem_name}][#{basename}] dirname: #{dirname}" if verbose
           is_at_gem_root = dirname[(-4)..(-1)] == "/lib"
-          puts "is_at_gem_root: #{is_at_gem_root}" if verbose
+          puts "[#{gem_name}][#{basename}] is_at_gem_root: #{is_at_gem_root}" if verbose
           lib_split = dirname.split("/lib/")[-1]
-          puts "lib_split: #{lib_split}" if verbose
+          puts "[#{gem_name}][#{basename}] lib_split: #{lib_split}" if verbose
           # lib_split could be like:
           #   - "ruby/gems/3.2.0/gems/method_source-1.1.0/lib"
           #   - "method_source"
           # Se we check to make sure it is actually a subdir of the gem's lib directory
           full_path = File.join(gem_path, "lib", lib_split)
           relative_path = !is_at_gem_root && Dir.exist?(full_path) && lib_split
-          puts "relative_path: #{relative_path}" if verbose
-          filename = File.basename(file)[0..-4]
-          puts "filename: #{filename}" if verbose
+          puts "[#{gem_name}][#{basename}] relative_path: #{relative_path}" if verbose
 
           if relative_path
-            dir_path = File.join(directory, relative_path)
+            dir_path = File.join(tmp_dir, relative_path)
             Dir.mkdir(dir_path) unless Dir.exist?(dir_path)
-            puts "creating #{filename} in #{dir_path}" if verbose
-            files << create_tempfile_copy(file, filename, dir_path, :dd1, &block)
+            puts "[#{gem_name}][#{basename}] copying file to #{dir_path}" if verbose
+            files << create_tempfile_copy(file, dir_path, basename, :dd1, &block)
           else
-            puts "directory not relative (#{directory}) for file #{filename}" if verbose
-            files << create_tempfile_copy(file, filename, directory, :dd2, &block)
+            puts "[#{gem_name}][#{basename}] directory not relative (#{tmp_dir})" if verbose
+            files << create_tempfile_copy(file, tmp_dir, basename, :dd2, &block)
           end
         end
-        load_gem_copy(files)
+        load_gem_copy(tmp_dir, files)
       end
 
       nil
     end
 
-    def primary_namespace
+    # @return [String] Namespace of the doffed (original) gem
+    def doffed_primary_namespace
+      trades.keys.first
+    end
+
+    # @return [String] Namespace of the donned gem
+    def donned_primary_namespace
       trades.values.first
     end
 
     # Will raise NameError if called before #doff_and_don
+    # @return [Class, nil]
     def as_klass
-      Object.const_get(primary_namespace) if gem_path
+      Object.const_get(donned_primary_namespace) if gem_path
     end
 
     private
 
-    def load_gem_copy(files)
+    # @param tmp_dir [String] absolute file path of the tmp directory
+    # @param files [Array[String]] absolute file path of each file in the donned gem
+    # @return void
+    def load_gem_copy(tmp_dir, files)
+      if verbose
+        puts "[#{gem_name}] Doffed gem located at #{gem_path}"
+        puts "[#{gem_name}] Donned gem located at #{tmp_dir}"
+        puts "[#{gem_name}] Primary namespace updated: #{doffed_primary_namespace} => #{donned_primary_namespace}"
+        puts "[#{gem_name}] Donned files:\n\t#{files.join("\n\t")}"
+      end
       files.each do |filepath|
-        # begin
+        # But files required here may not load their own internal files properly if they are still using `require`.
+        # Since Ruby 2.2, best practice for ruby libraries is to use require_relative for internal files,
+        #   and require for external files and dependencies.
+        # Ref: https://github.com/panorama-ed/memo_wise/issues/349
+        # We *can* use `require` *here*, because filepath here is an absolute paths
         require filepath
-        # rescue LoadError => e
-        #   puts file.to_s
-        #   puts tempfile.path
-        #   puts e.class
-        #   puts e.message
-        # end
       end
+
+      nil
     end
 
+    # @param orig_file_path [String] absolute file path of the original file
+    # @param tmp_dir [String] absolute file path of the tmp directory
+    # @param basename [String] the basename of the file being copied
+    # @param debug_info [Symbol] for debugging purposes
     # @return [String] the file path of the new copy of the original file
-    def create_tempfile_copy(file, filename, directory, from, &block)
-      # Value of block is returned from File.open
-      File.open(File.join(directory, "#{filename}.rb"), "w") do |file_copy|
-        new_jersey(file, file_copy, from, &block)
+    def create_tempfile_copy(orig_file_path, tmp_dir, basename, debug_info, &block)
+      File.open(File.join(tmp_dir, basename), "w") do |donned_file|
+        # Value of block is returned from File.open, and thus from this method
+        new_jersey(orig_file_path, donned_file, basename, debug_info, &block)
       end
     end
 
-    # @return [String] the file path of the new copy of the original file
-    def new_jersey(file, file_copy, from)
-      nj = File.read(file)
+    # New Jersey is not Ohio. Writes donned files to disk.
+    #
+    # @param doffed_file_path [String] absolute file path of the original file
+    # @param donned_file [File] the file which needs to be written to disk
+    # @param basename [String] the basename of the file for verbose logging
+    # @param debug_info [Symbol] for debugging purposes
+    # @return [String] the file path of the donned file
+    def new_jersey(doffed_file_path, donned_file, basename, debug_info = nil)
+      nj = File.read(doffed_file_path)
       trades.each do |old_namespace, new_namespace|
         nj.gsub!(old_namespace, new_namespace)
       end
       if verbose
-        puts "new_jersey has from: #{from}"
-        puts "new_jersey has file: #{file}"
-        puts "new_jersey file_copy path: #{file_copy.path}"
+        puts "[#{gem_name}][#{basename}] new_jersey doffed_file_path: #{doffed_file_path}"
+        puts "[#{gem_name}][#{basename}] new_jersey donned_file path: #{donned_file.path}"
+        puts "[#{gem_name}][#{basename}] new_jersey debug_info: #{debug_info}"
       end
       nj = yield nj if block_given?
-      file_copy.write(nj)
-      file_copy.close
-      file_copy.path
+      donned_file.write(nj)
+      donned_file.close
+      donned_file.path
     end
   end
 end

data/lib/gem_bench/player.rb

@@ -1,4 +1,6 @@
 module GemBench
+  # Each gem either needs to be required at boot time or not.
+  # Player helps determine which gems can use `require: false` in the Gemfile to cut down load times.
   class Player
     # MAJOR.MINOR split on point length == 2
     # MAJOR.MINOR.PATCH split on point length == 3

data/lib/gem_bench/scout.rb

@@ -1,12 +1,13 @@
 # Scout's job is to figure out where gems are hiding
 #
 module GemBench
+  # Looks through loaded gems' (RubyGems & Bundler) source code searching for stuff
   class Scout
     attr_reader :gem_paths, :gemfile_path, :gemfile_lines, :gemfile_trash, :loaded_gems
 
-    def initialize(check_gemfile: nil)
+    def initialize(check_gemfile: nil, **options)
       @check_gemfile = check_gemfile.nil? ? true : check_gemfile
-      @gemfile_path = "#{Dir.pwd}/Gemfile"
+      @gemfile_path = options.fetch(:gemfile_path, "#{Dir.pwd}/Gemfile")
       gem_lookup_paths_from_bundler
       gem_lines_from_gemfile
       # Gem.loaded_specs are the gems that have been loaded / required.
@@ -27,10 +28,10 @@ module GemBench
         .map { |x| x.to_s }
         .reject { |p| p.empty? }
         .map { |x| "#{x}/gems" }
-      @gem_paths << "#{Bundler.install_path}"
+      @gem_paths << Bundler.install_path.to_s # Pathname => String
       @gem_paths << "#{Bundler.bundle_path}/gems"
       @gem_paths.uniq!
-    rescue Bundler::GemfileNotFound => e
+    rescue Bundler::GemfileNotFound => _e
       # Don't fail here, but also don't check the Gemfile.
       @check_gemfile = false
     ensure
@@ -42,6 +43,7 @@ module GemBench
         file = File.open(gemfile_path)
         # Get all lines as an array
         all_lines = file.readlines
+        file.close
         # Remove all the commented || blank lines
         @gemfile_trash, @gemfile_lines = all_lines.partition { |x| x =~ GemBench::TRASH_REGEX }
         @gemfile_trash.reject! { |x| x == "\n" } # remove blank lines

data/lib/gem_bench/strict_version_gem.rb

@@ -1,11 +1,13 @@
 module GemBench
+  # Helps determine if a gem dependency is "valid" according to the strict rules of:
+  #   - every gem must have a version requirement of some sort
   class StrictVersionGem
     attr_reader :name, :version, :version_type, :valid, :relevant_lines, :index, :tokenized_line
 
     class << self
       def from_line(all_lines, line, index, opts = {})
         tokenized_line = GemfileLineTokenizer.new(all_lines, line, index)
-        return unless tokenized_line.is_gem
+        return unless tokenized_line.parse_success
 
         new(
           tokenized_line.name,

data/lib/gem_bench/strict_version_requirement.rb

@@ -1,9 +1,10 @@
 module GemBench
+  # Helps enforce a version requirement for every dependency in a Gemfile
   class StrictVersionRequirement
     attr_reader :gemfile_path, :gems, :starters, :benchers, :verbose
 
     def initialize(options = {})
-      @gemfile_path = "#{Dir.pwd}/Gemfile"
+      @gemfile_path = options.fetch(:gemfile_path, "#{Dir.pwd}/Gemfile")
       file = File.open(gemfile_path)
       # Get all lines as an array
       all_lines = file.readlines

data/lib/gem_bench/team.rb

@@ -1,6 +1,11 @@
 require "forwardable"
 
 module GemBench
+  # It doesn't make sense to use Team unless the Gemfile you want to evaluate is currently loaded.
+  # For example:
+  #   - if you are in a rails console, and want to evaluate the Gemfile of the Rails app, that's great!
+  #   - if you are in a context with no Gemfile loaded, or a different Gemfile loaded than the one you want to evaluate,
+  #     this class may not give sensible results. This is because it checks loaded gems via RubyGems and Bundler.
   class Team
     EXCLUDE = %w[
       bundler
@@ -19,6 +24,8 @@ module GemBench
       cancan
       friendly_id
       faker
+      capistrano3-puma
+      wkhtmltopdf-binary
     ]
     # A comment preceding the require: false anywhere on the line should not be considered an active require: false
     extend Forwardable
@@ -34,13 +41,16 @@ module GemBench
       :current_gemfile_suggestions,
       :bad_ideas
 
-    def initialize(options = {})
+    def initialize(**options)
       @look_for_regex = options[:look_for_regex]
       # find: Find gems containing specific strings in code
       # bench: Find gems that can probably be benched (require: false) in the Gemfile
       @check_type = @look_for_regex ? :find : :bench
       @benching = @check_type == :bench
-      @scout = GemBench::Scout.new(check_gemfile: options[:check_gemfile] || benching?)
+      @scout = GemBench::Scout.new(
+        check_gemfile: options.fetch(:check_gemfile, benching?),
+        gemfile_path: options.fetch(:gemfile_path, "#{Dir.pwd}/Gemfile"),
+      )
       @exclude_file_pattern_regex_proc = options[:exclude_file_pattern_regex_proc].respond_to?(:call) ? options[:exclude_file_pattern_regex_proc] : GemBench::EXCLUDE_FILE_PATTERN_REGEX_PROC
       # Among the loaded gems there may be some that did not need to be.
       @excluded, @all = @scout.loaded_gems.partition { |x| EXCLUDE.include?(x[0]) }
@@ -192,13 +202,13 @@ module GemBench
     end
 
     def check(player)
-      gem_paths.each do |path|
+      gem_paths.detect do |path|
         glob_path = "#{path}/#{player.file_path_glob}"
-        file_paths = Dir.glob("#{glob_path}")
+        file_paths = Dir.glob(glob_path)
         puts "[GemBench] checking #{player} at #{glob_path} (#{file_paths.length} files)" if extra_verbose?
-        file_paths.each do |file_path|
+        file_paths.detect do |file_path|
           player.set_starter(file_path, line_match: look_for_regex)
-          return if player.starter?
+          player.starter?
         end
       end
     end

data/lib/gem_bench/version.rb

@@ -1,5 +1,6 @@
 module GemBench
+  # Version is enhanced by VersionGem::Basic once the gem is loaded.
   module Version
-    VERSION = "2.0.3"
+    VERSION = "2.0.4"
   end
 end

data/lib/gem_bench.rb

@@ -2,13 +2,14 @@
 require "version_gem"
 require "bundler" # This gem utilizes bundler as a tool.
 
-require "gem_bench/version"
-require "gem_bench/scout"
-require "gem_bench/player"
-require "gem_bench/team"
-require "gem_bench/gemfile_line_tokenizer"
-require "gem_bench/strict_version_gem"
-require "gem_bench/strict_version_requirement"
+# this library
+require_relative "gem_bench/version"
+require_relative "gem_bench/scout"
+require_relative "gem_bench/player"
+require_relative "gem_bench/team"
+require_relative "gem_bench/gemfile_line_tokenizer"
+require_relative "gem_bench/strict_version_gem"
+require_relative "gem_bench/strict_version_requirement"
 
 module GemBench
   USAGE = "[GemBench] Usage: Require another gem in this session to evaluate it.\n\tExample:\n\t\trequire 'rails'\n\t\tGemBench.check({verbose: true})\n"
@@ -25,29 +26,41 @@ module GemBench
   }
 
   class << self
-    attr_accessor :roster
-
-    def check(verbose: false)
-      @roster = GemBench::Team.new({verbose: verbose})
+    def check(verbose: false, gemfile_path: nil)
+      options = {
+        verbose: verbose,
+      }
+      options[:gemfile_path] = gemfile_path if gemfile_path
+      GemBench::Team.new(**options)
     end
 
-    def versions_present?(verbose: false)
-      @roster = GemBench::StrictVersionRequirement.new({verbose: verbose})
-      @roster.versions_present?
+    def versions_present?(verbose: false, gemfile_path: nil)
+      options = {
+        verbose: verbose,
+      }
+      options[:gemfile_path] = gemfile_path if gemfile_path
+      GemBench::StrictVersionRequirement.new(**options).versions_present?
     end
 
-    def list_missing_version_constraints(verbose: false)
-      @roster = GemBench::StrictVersionRequirement.new({verbose: verbose})
-      @roster.list_missing_version_constraints
+    def list_missing_version_constraints(verbose: false, gemfile_path: nil)
+      options = {
+        verbose: verbose,
+      }
+      options[:gemfile_path] = gemfile_path if gemfile_path
+      GemBench::StrictVersionRequirement.new(**options).list_missing_version_constraints
     end
 
     def find(look_for_regex: GemBench::RAILTIE_REGEX,
-      exclude_file_pattern_regex_proc: GemBench::EXCLUDE_FILE_PATTERN_REGEX_PROC, verbose: false)
-      @roster = GemBench::Team.new({
+      exclude_file_pattern_regex_proc: GemBench::EXCLUDE_FILE_PATTERN_REGEX_PROC,
+      verbose: false,
+      gemfile_path: nil)
+      options = {
+        verbose: verbose,
         look_for_regex: look_for_regex,
         exclude_file_pattern_regex_proc: exclude_file_pattern_regex_proc,
-        verbose: verbose,
-      })
+      }
+      options[:gemfile_path] = gemfile_path if gemfile_path
+      GemBench::Team.new(**options)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gem_bench
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.0.4
 platform: ruby
 authors:
 - Peter Boling
@@ -12,31 +12,31 @@ cert_chain:
   -----BEGIN CERTIFICATE-----
   MIIEgDCCAuigAwIBAgIBATANBgkqhkiG9w0BAQsFADBDMRUwEwYDVQQDDAxwZXRl
   ci5ib2xpbmcxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixkARkW
-  A2NvbTAeFw0yMzA5MjAxNzMwMjhaFw0yNDA5MTkxNzMwMjhaMEMxFTATBgNVBAMM
+  A2NvbTAeFw0yNDA5MjAwODU4NDJaFw0yNTA5MjAwODU4NDJaMEMxFTATBgNVBAMM
   DHBldGVyLmJvbGluZzEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPy
-  LGQBGRYDY29tMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEA+a9UvHo3
-  84k96WgU5Kk5HB+cLZs/modjorsTfqY67MJF5nNvAoqcKTUBW4uG+Zpfnm3jaDO5
-  GxhJEIZWfndYzycHT2KMVQ1uTP82ba8ZaKrPlPIafkbui3mdds47qsmqHiblKERg
-  U532lkwfqHDlJwE7OBZQ59EwWWLynlT/yAUHpOBbqIuHKUxdpmBI+sIjrZcD1e05
-  WmjkO6fwIdC5oM757aoPxIgXD587VOViH11Vkm2doskj4T8yONtwVHlcrrhJ9Bzd
-  /zdp6vEn7GZQrABvpOlqwWxQ72ZnFhJe/RJZf6CXOPOh69Ai0QKYl2a1sYuCJKS3
-  nsBnxXJINEEznjR7rZjNUmYD+CZqfjzgPqedRxTlASe7iA4w7xZOqMDzcuhNwcUQ
-  tMEH6BTktxKP3jXZPXRfHCf6s+HRVb6vezAonTBVyydf5Xp5VwWkd6cwm+2BzHl5
-  7kc/3lLxKMcsyEUprAsk8LdHohwZdC267l+RS++AP6Cz6x+nB3oGob19AgMBAAGj
-  fzB9MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBQCSSas60GqqMjt
-  xR7LoY1gucEvtzAhBgNVHREEGjAYgRZwZXRlci5ib2xpbmdAZ21haWwuY29tMCEG
+  LGQBGRYDY29tMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAjrxsKObI
+  rFQjBpzvVfqnT6JlF8/pkpgEEjFh7ex3zIerfuHzZvSrx+sRDGxQ8koWWG0Wjx8s
+  wkBZ5dIqvl0g3sWP5asa28u/09opxkQTC1Ao77iYxcBcwoCe/Dpf1m4Q/m6oH0kL
+  2AZVNJQL3UkqAcLS0tsj/s/jAKnVlsaZZE5gQiIIi8HtkvSsajtx+Cq2AxDvcWvV
+  /CliD+pmzYkTjvjwGm8yeyFGGGgrisJMryiZdZlkTwrQSjCzudIKbLeuG8Se4JTD
+  TAcT+rPubr27v1jwmtIjtiot3rf4nof7LHLb122a/0VR7cC7xPLnXw0Cq1BShvoq
+  /GKRdSwMNinTOGkFTK1gKnjN+3iD4zyXU3XO3CXoTr+Ju8fXPN1x4tpOMgbv8dme
+  WbcQMOH9ZjmA5w0bSVRL1c3NhRRpUzrKTNXBEvqOyWjUnintxWKj+cRXx+z+dUgI
+  dL3kj68fcsiTgl75In3C485pnCMmq1eLuVoiy3jkLNOn2lHeLt9ZK63LAgMBAAGj
+  fzB9MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBRhfc+2UaVYd74p
+  yJ1JclGiUYN8+jAhBgNVHREEGjAYgRZwZXRlci5ib2xpbmdAZ21haWwuY29tMCEG
   A1UdEgQaMBiBFnBldGVyLmJvbGluZ0BnbWFpbC5jb20wDQYJKoZIhvcNAQELBQAD
-  ggGBAMl9ifcw5p+PdvB7dCPoNKoVdp/2LbC9ztETHuYL2gUMJB6UoS3o9c/piSuR
-  V3ZMQaijmNu6ms1bWAtJ66LjmYrVflJtf9yp31Kierr9LpisMSUx2qbMOHGa8d2Z
-  vCUWPF8E9Cg0mP3GAyZ6qql8jDh/anUKeksPXqJvNxNPDu2DVYsa/IWdl96whzS4
-  Bl7SwB1E7agps40UcshCSKaVDOU0M+XN6SrnJMElnBic+KSAkBkVFbzS0BE4ODZM
-  BgE6nYzQ05qhuvbE+oGdACTlemNtDDWCh0uw+7x0q2PocGIDU5zsPn/WNTkCXPmB
-  CHGvqDNWq4M7ncTKAaS2XExgyb7uPdq9fKiOW8nmH+zCiGzJXzBWwZlKf7L4Ht9E
-  a3f0e5C+zvee9Z5Ng9ciyfav9/fcXgYt5MjoBv27THr5XfBhgOCIHSYW2tqJmWKi
-  KuxrfYrN+9HvMdm+nZ6TypmKftHY3Gj+/uu+g8Icm/zrvTWAEE0mcJOkfrIoNPJb
-  pF8dMA==
+  ggGBAA4fLU2+mQ++jBhVM2IeyvQdw1nm+0thkH4Ldv8ZOBm5ZxCPGIMoYliDDzg4
+  4JDFxZR1wR4sdrz/K5tWtEkN23SKzopwbNb1NIQRSLQ7nOoc+4bkuz9xwKinmIvF
+  D+5qsl2S27WLKFreMDtGoh0CREIMBUxU4rGTh0gtzmweGR+fnOShg4Jo0kxrjU5h
+  uYk/uVE+bn/jOEGs43GvKXZLyshpBrZjQ+ArbvxDht5t35zbSxerbUxUPZUbXUCW
+  tTyh38a9UYjAAHvnh6Y4Fi9wd4/pGNsektrzB3z/zlVj4YF2TMLX9XfNJWEGRGpO
+  sSkLYdtEX1WQAmuZtActVW2cL3HdQaRbiv7VbfpA0eSk0ZdZHvBCl516ZZu10uX6
+  82W1mg6fuezdpeBOiXwrEbZSt/oGiF4V511F6nd55p0okwHc/6nS10F/3aKJ4gwC
+  I5o+DRfXQHqKucx1ldFHvI2rE/kSCWqGTHN2eyu1sqCPeOoIMxrltJhaejKPkxqj
+  zaF9Og==
   -----END CERTIFICATE-----
-date: 2024-09-18 00:00:00.000000000 Z
+date: 2024-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -130,16 +130,16 @@ dependencies:
   name: awesome_print
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.9'
 - !ruby/object:Gem::Dependency
   name: method_source
   requirement: !ruby/object:Gem::Requirement
@@ -160,42 +160,48 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.13'
 - !ruby/object:Gem::Dependency
   name: rspec-block_is_expected
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.6
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.6
 - !ruby/object:Gem::Dependency
   name: rubocop-lts
   requirement: !ruby/object:Gem::Requirement
@@ -234,28 +240,28 @@ dependencies:
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: standard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.40'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.40'
 description: |-
@@ -290,10 +296,10 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://railsbling.com/tags/gem_bench/
-  source_code_uri: http://github.com/pboling/gem_bench/tree/v2.0.3
-  changelog_uri: http://github.com/pboling/gem_bench/blob/v2.0.3/CHANGELOG.md
+  source_code_uri: http://github.com/pboling/gem_bench/tree/v2.0.4
+  changelog_uri: http://github.com/pboling/gem_bench/blob/v2.0.4/CHANGELOG.md
   bug_tracker_uri: http://github.com/pboling/gem_bench/issues
-  documentation_uri: https://www.rubydoc.info/gems/gem_bench/2.0.3
+  documentation_uri: https://www.rubydoc.info/gems/gem_bench/2.0.4
   wiki_uri: http://github.com/pboling/gem_bench/wiki
   funding_uri: https://liberapay.com/pboling
   rubygems_mfa_required: 'true'