gem_bench 2.0.2 → 2.0.4

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