gem_bench 1.0.5 → 2.0.1

data/lib/gem_bench/gemfile_line_tokenizer.rb

@@ -3,46 +3,41 @@ module GemBench
     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
-    GEMFILE_HASH_CONFIG_KEY_REGEX_PROC = ->(key) { /\A\s*[^#]*(?<key1>#{key}: *)['"]{1}(?<value1>[^'"]*)['"]|(?<key2>['"]#{key}['"] *=> *)['"]{1}(?<value2>[^'"]*)['"]|(?<key3>:#{key} *=> *)['"]{1}(?<value3>[^'"]*)['"]/ }
-    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_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
-    VALID_VERSION_TYPES = %i(
+    GEMFILE_HASH_CONFIG_KEY_REGEX_PROC = lambda { |key|
+      /\A\s*[^#]*(?<key1>#{key}: *)['"]{1}(?<value1>[^'"]*)['"]|(?<key2>['"]#{key}['"] *=> *)['"]{1}(?<value2>[^'"]*)['"]|(?<key3>:#{key} *=> *)['"]{1}(?<value3>[^'"]*)['"]/
+    }
+    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_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
+    VALID_VERSION_TYPES = %i[
       constraint
       git_ref
       git_tag
-    )
+    ]
     # branch is only valid if the branch is not master
     attr_reader :line
-    attr_reader :relevant_lines
-    attr_reader :is_gem
-    attr_reader :all_lines
-    attr_reader :index
-    attr_reader :tokens
+    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_type
-    attr_reader :name
-    attr_reader :parse_success
-    attr_reader :valid
+
     def initialize(all_lines, line, index)
       @line = line.strip
       @is_gem = self.line.match(GEM_REGEX)
-      if self.is_gem
+      if is_gem
         @all_lines = all_lines
         @index = index
-        @tokens = self.line.split(',')
+        @tokens = self.line.split(",")
         determine_name
-        if self.name
+        if name
           determine_relevant_lines
           determine_version
           @parse_success = true
-          @valid = VALID_VERSION_TYPES.include?(self.version_type)
+          @valid = VALID_VERSION_TYPES.include?(version_type)
         else
           noop
         end
@@ -87,6 +82,7 @@ module GemBench
       # index 1 of the comma-split tokens will usually be the version constraint, if there is one
       possible_constraint = @tokens[1]
       return false unless possible_constraint
+
       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)
@@ -99,92 +95,100 @@ module GemBench
 
     def version_path
       @version = {}
-      line = relevant_lines.detect { |next_line| (next_line.match(VERSION_PATH)) }
+      line = relevant_lines.detect { |next_line| next_line.match(VERSION_PATH) }
       return false unless line
+
       enhance_version(
-          line.match(VERSION_PATH),
-          :path,
-          :path
+        line.match(VERSION_PATH),
+        :path,
+        :path,
       )
     end
 
     def version_git
       @version = {}
-      line = relevant_lines.detect { |next_line| (next_line.match(VERSION_GIT)) }
+      line = relevant_lines.detect { |next_line| next_line.match(VERSION_GIT) }
       return false unless line
+
       enhance_version(
-          line.match(VERSION_GIT),
-          :git,
-          :git
+        line.match(VERSION_GIT),
+        :git,
+        :git,
       )
     end
 
     def version_github
       @version = {}
-      line = relevant_lines.detect { |next_line| (next_line.match(VERSION_GITHUB)) }
+      line = relevant_lines.detect { |next_line| next_line.match(VERSION_GITHUB) }
       return false unless line
+
       enhance_version(
-          line.match(VERSION_GITHUB),
-          :github,
-          :github
+        line.match(VERSION_GITHUB),
+        :github,
+        :github,
       )
     end
 
     def check_for_version_of_type_git_ref
-      line = relevant_lines.detect { |next_line| (next_line.match(VERSION_GIT_REF)) }
+      line = relevant_lines.detect { |next_line| next_line.match(VERSION_GIT_REF) }
       return false unless line
+
       enhance_version(
-          line.match(VERSION_GIT_REF),
-          :ref,
-          :git_ref
+        line.match(VERSION_GIT_REF),
+        :ref,
+        :git_ref,
       )
     end
 
     def check_for_version_of_type_git_tag
-      line = relevant_lines.detect { |next_line| (next_line.match(VERSION_GIT_TAG)) }
+      line = relevant_lines.detect { |next_line| next_line.match(VERSION_GIT_TAG) }
       return false unless line
+
       enhance_version(
-          line.match(VERSION_GIT_TAG),
-          :tag,
-          :git_tag
+        line.match(VERSION_GIT_TAG),
+        :tag,
+        :git_tag,
       )
     end
 
     def check_for_version_of_type_git_branch
-      line = relevant_lines.detect { |next_line| (next_line.match(VERSION_GIT_BRANCH)) }
+      line = relevant_lines.detect { |next_line| next_line.match(VERSION_GIT_BRANCH) }
       return false unless line
+
       enhance_version(
-          line.match(VERSION_GIT_BRANCH),
-          :branch,
-          :git_branch
+        line.match(VERSION_GIT_BRANCH),
+        :branch,
+        :git_branch,
       )
     end
 
     # returns an array with 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) }.
-          map(&:strip).
-          inject([]) do |following_lines, next_line|
-            break following_lines if next_line.match(GEM_REGEX)
-            following_lines << next_line
+      all_lines[(index + 1)..-1]
+        .reject { |x| x.strip.empty? || x.match(GemBench::TRASH_REGEX) }
+        .map(&:strip)
+        .inject([]) do |following_lines, next_line|
+        break following_lines if next_line.match(GEM_REGEX)
+
+        following_lines << next_line
       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.inject({}) do |mem, capture|
-        mem[capture.gsub(/\d/,'')] = match_data[capture]
+      match_data.names.each_with_object({}) do |capture, mem|
+        mem[capture.gsub(/\d/, "")] = match_data[capture]
         break mem if mem.keys.length >= 2
-        mem
       end
     end
 
     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
+
       @version.merge!({version_key => normalized_capture["value"]})
       @version_type = type
       true

data/lib/gem_bench/jersey.rb

@@ -0,0 +1,150 @@
+# 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
+  class Jersey
+    attr_reader :gem_name
+    attr_reader :gem_path
+    attr_reader :trades
+    attr_reader :metadata
+    attr_reader :files
+    attr_reader :verbose
+
+    def initialize(gem_name:, trades:, metadata: {}, verbose: false)
+      @gem_name = gem_name
+      @gem_path = Gem.loaded_specs[gem_name]&.full_gem_path
+      @gem_lib_dir = Gem
+      @trades = trades
+      @metadata = metadata
+      @verbose = verbose
+    end
+
+    def required?
+      gem_path && trades.values.all? { |new_namespace| Object.const_defined?(new_namespace) }
+    end
+
+    # Generates tempfiles and requires them, resulting
+    #   in a loaded gem that will not have namespace
+    #   collisions when alongside the original-namespaced gem.
+    # 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
+    #   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
+
+      puts "Doffing #{gem_path}" if verbose
+      Dir.mktmpdir do |directory|
+        files = []
+        Dir[File.join(gem_path, "lib", "**", "*.rb")].map do |file|
+          if verbose
+            puts file
+            puts File.basename(file)
+            puts "--------------------------------"
+          end
+          dirname = File.dirname(file)
+          puts "dirname: #{dirname}" if verbose
+          is_at_gem_root = dirname[(-4)..(-1)] == "/lib"
+          puts "is_at_gem_root: #{is_at_gem_root}" if verbose
+          lib_split = dirname.split("/lib/")[-1]
+          puts "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
+
+          if relative_path
+            dir_path = File.join(directory, 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)
+          else
+            puts "directory not relative (#{directory}) for file #{filename}" if verbose
+            files << create_tempfile_copy(file, filename, directory, :dd2, &block)
+          end
+        end
+        load_gem_copy(files)
+      end
+
+      nil
+    end
+
+    def primary_namespace
+      trades.values.first
+    end
+
+    # Will raise NameError if called before #doff_and_don
+    def as_klass
+      Object.const_get(primary_namespace) if gem_path
+    end
+
+    private
+
+    def load_gem_copy(files)
+      files.each do |filepath|
+        # begin
+        require filepath
+        # rescue LoadError => e
+        #   puts file.to_s
+        #   puts tempfile.path
+        #   puts e.class
+        #   puts e.message
+        # end
+      end
+    end
+
+    # @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)
+      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)
+      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}"
+      end
+      nj = yield nj if block_given?
+      file_copy.write(nj)
+      file_copy.close
+      file_copy.path
+    end
+  end
+end

data/lib/gem_bench/player.rb

@@ -21,49 +21,58 @@ module GemBench
 
     def set_starter(file_path, line_match: nil)
       return false if file_path =~ exclude_file_pattern
+
       # Some gems may have zero files to check, as they may be using gem as a
       #   delivery system for shell scripts!  As such we need to check which
       #   gems got checked, and which had nothing to check
       @checked = true
       line_match ||= GemBench::RAILTIE_REGEX
-      scan = begin
-        if GemBench::DO_NOT_SCAN.include?(name)
-          false
-        else
-          begin
-            File.read(file_path).encode('utf-8', :invalid => :replace, :undef => :replace, :replace => '_') =~ line_match
-          rescue ArgumentError => e
-            if e.message =~ /invalid byte sequence/
-              puts "[GemBench] checking #{file_path} failed due to unparseable file content"
-              false # Assume the likelihood of files with encoding issues that also contain railtie to be low, so: false.
-            end
-          end
-        end
-      end
-      self.stats << [file_path,scan] if scan
-      self.state = !!scan ?
-        GemBench::PLAYER_STATES[:starter] :
+      scan = !GemBench::DO_NOT_SCAN.include?(name) && check_line(file_path, line_match)
+      stats << [file_path, scan] if scan
+      self.state = if !!scan
+        GemBench::PLAYER_STATES[:starter]
+      else
         GemBench::PLAYER_STATES[:bench]
+      end
+    end
+
+    def check_line(file_path, line_match)
+      File.read(file_path).encode(
+        "utf-8",
+        invalid: :replace,
+        undef: :replace,
+        replace: "_",
+      ) =~ line_match
+    rescue ArgumentError => e
+      if e.message =~ /invalid byte sequence/
+        puts "[GemBench] checking #{file_path} failed due to unparseable file content"
+        false # Assume the likelihood of files with encoding issues that also contain railtie to be low, so: false.
+      else
+        puts "[GemBench] checking #{file_path} failed. Please report a bug to https://github.com/pboling/gembench/issues"
+        raise e
+      end
     end
 
     def starter?
-      self.state == GemBench::PLAYER_STATES[:starter]
+      state == GemBench::PLAYER_STATES[:starter]
     end
 
     def to_s(format = :name)
       case format
-        when :name then
-          name
-        when :v then
-          "#{name} v#{version}"
-        when :semver
-          "gem '#{name}', '~> #{semver}'"
-        when :locked
-          "gem '#{name}', '#{version}'"
-        when :legacy # when depending on legacy gems, you specifically want to not upgrade, except patches.
-          "gem '#{name}', '~> #{version}'"
-        when :upgrade # when upgrading, and testing gem compatibility you want to try anything newer
-          "gem '#{name}', '>= #{version}'"
+      when :name
+        name
+      when :v
+        "#{name} v#{version}"
+      when :semver
+        "gem '#{name}', '~> #{semver}'"
+      when :locked
+        "gem '#{name}', '#{version}'"
+      when :legacy # when depending on legacy gems, you specifically want to not upgrade, except patches.
+        "gem '#{name}', '~> #{version}'"
+      when :upgrade # when upgrading, and testing gem compatibility you want to try anything newer
+        "gem '#{name}', '>= #{version}'"
+      else
+        raise ArgumentError, "Unknown format for #{self.class.name}#to_s"
       end
     end
 
@@ -73,17 +82,15 @@ module GemBench
 
     def semver
       ver = version
-      until ver.split(".").length <= SEMVER_SPLIT_ON_POINT_LENGTH do
-        ver = ver[0..(ver.rindex(".")-1)]
-      end
+      ver = ver[0..(ver.rindex(".") - 1)] until ver.split(".").length <= SEMVER_SPLIT_ON_POINT_LENGTH
       ver
     end
 
     def how
-      case self.state
-      when GemBench::PLAYER_STATES[:starter] then
+      case state
+      when GemBench::PLAYER_STATES[:starter]
         to_s(:semver)
-      when GemBench::PLAYER_STATES[:bench] then
+      when GemBench::PLAYER_STATES[:bench]
         "#{to_s(:semver)}, require: false"
       else
         if checked

data/lib/gem_bench/scout.rb

@@ -3,13 +3,14 @@
 module GemBench
   class Scout
     attr_reader :gem_paths, :gemfile_path, :gemfile_lines, :gemfile_trash, :loaded_gems
+
     def initialize(check_gemfile: nil)
       @check_gemfile = check_gemfile.nil? ? true : check_gemfile
       @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.
-      @loaded_gems = Gem.loaded_specs.values.map {|x| [x.name, x.version.to_s] }
+      @loaded_gems = Gem.loaded_specs.values.map { |x| [x.name, x.version.to_s] }
     end
 
     def check_gemfile?
@@ -19,23 +20,21 @@ module GemBench
     private
 
     def gem_lookup_paths_from_bundler
-      begin
-        @gem_paths = [Bundler.rubygems.gem_dir, Bundler.rubygems.gem_path].
-            flatten.
-            compact.
-            uniq.
-            map {|x| x.to_s }.
-            reject { |p| p.empty? }.
-            map {|x| "#{x}/gems" }
-        @gem_paths << "#{Bundler.install_path}"
-        @gem_paths << "#{Bundler.bundle_path}/gems"
-        @gem_paths.uniq!
-      rescue Bundler::GemfileNotFound => e
-        # Don't fail here, but also don't check the Gemfile.
-        @check_gemfile = false
-      ensure
-        @gem_paths = [] unless @gem_paths.is_a?(Array)
-      end
+      @gem_paths = [Bundler.rubygems.gem_dir, Bundler.rubygems.gem_path]
+        .flatten
+        .compact
+        .uniq
+        .map { |x| x.to_s }
+        .reject { |p| p.empty? }
+        .map { |x| "#{x}/gems" }
+      @gem_paths << "#{Bundler.install_path}"
+      @gem_paths << "#{Bundler.bundle_path}/gems"
+      @gem_paths.uniq!
+    rescue Bundler::GemfileNotFound => e
+      # Don't fail here, but also don't check the Gemfile.
+      @check_gemfile = false
+    ensure
+      @gem_paths = [] unless @gem_paths.is_a?(Array)
     end
 
     def gem_lines_from_gemfile
@@ -44,8 +43,8 @@ module GemBench
         # Get all lines as an array
         all_lines = file.readlines
         # 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
+        @gemfile_trash, @gemfile_lines = all_lines.partition { |x| x =~ GemBench::TRASH_REGEX }
+        @gemfile_trash.reject! { |x| x == "\n" } # remove blank lines
       else
         @gemfile_trash = []
         @gemfile_lines = []

data/lib/gem_bench/strict_version_gem.rb

@@ -1,25 +1,20 @@
 module GemBench
   class StrictVersionGem
-    attr_reader :name
-    attr_reader :version
-    attr_reader :version_type
-    attr_reader :valid
-    attr_reader :relevant_lines
-    attr_reader :index
-    attr_reader :tokenized_line
+    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 nil unless tokenized_line.is_gem
+        return unless tokenized_line.is_gem
+
         new(
-            tokenized_line.name,
-            tokenized_line.version,
-            tokenized_line.version_type,
-            tokenized_line.valid,
-            tokenized_line.relevant_lines,
-            tokenized_line.index,
-            opts[:debug] == true ? tokenized_line : nil
+          tokenized_line.name,
+          tokenized_line.version,
+          tokenized_line.version_type,
+          tokenized_line.valid,
+          tokenized_line.relevant_lines,
+          tokenized_line.index,
+          (opts[:debug] == true) ? tokenized_line : nil,
         )
       end
     end
@@ -43,12 +38,12 @@ module GemBench
     end
 
     def to_s
-      <<-EOS
-Gem: #{name}
-Line Number: #{index}
-Version: #{version.inspect}
-Relevant Gemfile Lines:
-#{relevant_lines.join("\n")}
+      <<~EOS
+        Gem: #{name}
+        Line Number: #{index}
+        Version: #{version.inspect}
+        Relevant Gemfile Lines:
+        #{relevant_lines.join("\n")}
       EOS
     end
   end

data/lib/gem_bench/strict_version_requirement.rb

@@ -1,10 +1,6 @@
 module GemBench
   class StrictVersionRequirement
-    attr_reader :gemfile_path
-    attr_reader :gems
-    attr_reader :starters
-    attr_reader :benchers
-    attr_reader :verbose
+    attr_reader :gemfile_path, :gems, :starters, :benchers, :verbose
 
     def initialize(options = {})
       @gemfile_path = "#{Dir.pwd}/Gemfile"
@@ -18,14 +14,14 @@ module GemBench
         @gems << gem if gem
       end
 
-      @starters, @benchers = @gems.partition {|x| x.valid? }
+      @starters, @benchers = @gems.partition { |x| x.valid? }
       # Remove all the commented || blank lines
       @verbose = options[:verbose]
-      self.print if self.verbose
+      self.print if verbose
     end
 
     def versions_present?
-      gems.detect {|x| !x.valid? }.nil?
+      gems.detect { |x| !x.valid? }.nil?
     end
 
     def list_missing_version_constraints
@@ -33,34 +29,34 @@ module GemBench
     end
 
     def find(name)
-      gems.detect {|x| x.name == name }
+      gems.detect { |x| x.name == name }
     end
 
     def gem_at(index)
-      gems.detect {|x| x.index == index }
+      gems.detect { |x| x.index == index }
     end
 
     def print
-      using_path = benchers.count {|x| x.is_type?(:path) }
-      puts <<-EOS
-      
-The gems that need to be improved are:
-
-#{benchers.map(&:to_s).join("\n")}
-
-There are #{starters.length} gems that have valid strict version constraints.
-Of those:
-  #{starters.count {|x| x.is_type?(:constraint) }} use primary constraints (e.g. '~> 1.2.3').
-  #{starters.count {|x| x.is_type?(:git_ref) }} use git ref constraints.
-  #{starters.count {|x| x.is_type?(:git_tag) }} use git tag constraints.
-
-There are #{benchers.length} gems that do not have strict version constraints.
-Of those:
-  #{benchers.count {|x| x.is_type?(:git_branch) }} use git branch constraints.
-  #{benchers.count {|x| x.is_type?(:git) }} use some other form of git constraint considered not strict enough.
-  #{benchers.count {|x| x.is_type?(:unknown) }} gems seem to not have any constraint at all.
-  #{using_path} gems are using a local path. #{'WARNING!!!' if using_path > 0}
-EOS
+      using_path = benchers.count { |x| x.is_type?(:path) }
+      puts <<~EOS
+        #{"      "}
+        The gems that need to be improved are:
+
+        #{benchers.map(&:to_s).join("\n")}
+
+        There are #{starters.length} gems that have valid strict version constraints.
+        Of those:
+          #{starters.count { |x| x.is_type?(:constraint) }} use primary constraints (e.g. '~> 1.2.3').
+          #{starters.count { |x| x.is_type?(:git_ref) }} use git ref constraints.
+          #{starters.count { |x| x.is_type?(:git_tag) }} use git tag constraints.
+
+        There are #{benchers.length} gems that do not have strict version constraints.
+        Of those:
+          #{benchers.count { |x| x.is_type?(:git_branch) }} use git branch constraints.
+          #{benchers.count { |x| x.is_type?(:git) }} use some other form of git constraint considered not strict enough.
+          #{benchers.count { |x| x.is_type?(:unknown) }} gems seem to not have any constraint at all.
+          #{using_path} gems are using a local path. #{"WARNING!!!" if using_path > 0}
+      EOS
     end
   end
 end