gem_bench 1.0.4 → 2.0.0

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/player.rb

@@ -21,49 +21,56 @@ 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
+      scan = 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
-      self.stats << [file_path,scan] if scan
-      self.state = !!scan ?
-        GemBench::PLAYER_STATES[:starter] :
+
+      stats << [file_path, scan] if scan
+      self.state = if !!scan
+        GemBench::PLAYER_STATES[:starter]
+      else
         GemBench::PLAYER_STATES[:bench]
+      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}'"
       end
     end
 
@@ -73,17 +80,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