gem_bench 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 02d3ad00484d97ad24c15de92b325eb2d867470a
-  data.tar.gz: 0ae6392ec5541c4284254cff708b84f3c7169a4f
+  metadata.gz: 8f89228b4ede08a4d045edb84113a8aa4abe87c5
+  data.tar.gz: 0aed9f1441cd404b78218ddb4569fe40d5e0ba00
 SHA512:
-  metadata.gz: 57f9368e98e27d4da8ea037a830f38f636e6a2ccc9ded026d83a259f376812d7306caff015f6e9947be60dfc5f6dab3020dc3572bc1397d8fea960247d2a9982
-  data.tar.gz: d4a6c72e7fc06eb565c1b37329f4bc2fc2e61a5f7c9a2dd45450ac5f8dcb0e4d33f037c49a641639905d507fc0de8e5ac01e5942e1ecb41e8e596517b1deb077
+  metadata.gz: 260ff8d3d842a12bd4c0cda93e8bc3b08fe2df254dde06d9ac252d50a382a93c4b3ed465a768112e2624975b83039c1744d6e6a6374fcb2ced56e9a47c305e7e
+  data.tar.gz: 0be0973760997ecf07647d741fdeb85207f11afcb8ab5a6e6a86f80c7541d72268cb1a13bce2210b84ff4da5224b033beddb719dad933a09f2d6343fa217e9b7

data/.gitignore

@@ -13,3 +13,4 @@
 
 *.gem
 /.idea/
+.ruby-version

data/CHANGELOG

@@ -1,3 +1,17 @@
+Version 1.0.2 - JUN.02.2017
+* version constraint checking, useful to add a spec enforcing Gemfile version constraints, by Peter Boling
+  - Console use:
+    - GemBench::StrictVersionRequirement.new({verbose: true})
+  - Spec use:
+```ruby
+Rspec.describe "Gemfile" do
+  it("has version constraint on every gem") do
+    requirements = GemBench::StrictVersionRequirement.new({verbose: true}
+    expect(requirements.list_missing_version_constraints).to eq([])
+  end
+end
+```
+
 Version 1.0.1 - MAR.25.2017
 * fixed a typo that prevented Gemfile comparison by mobilutz
 

data/README.md

@@ -5,6 +5,17 @@
 Gem: "Put me in coach!"
 You: ❨╯°□°❩╯︵┻━┻
 
+Version constraints are important.  Give the Gemfile some love in your CI build - New for 1.0.2
+
+```ruby
+Rspec.describe "Gemfile" do
+  it("has version constraint on every gem") do
+    requirements = GemBench::StrictVersionRequirement.new({verbose: true}
+    expect(requirements.list_missing_version_constraints).to eq([])
+  end
+end
+```
+
 The new feature for 1.0.0 release allows you to search the Ruby code of all your gems for a specified regex, to find out which gems have wat DRAGONS.
 
 Gem: "I have no wat DRAGONS!"
@@ -20,10 +31,10 @@ byebug has wat DRAGONS at [["/Users/pboling/.rvm/gems/ruby-2.4.0@foss/gems/byebu
 NOTE: The number (954, above) is not a line number. The file which contains the text `wat` was the 954th file evaluated, i.e. the number doesn't matter.
 NOTE: This is a contrived example.  The occurrence of `wat` in byebug is meaningless: `byebug/commands/frame.rb:34` has `        if there is a front end also watching over things.`.  This is just an example!  You can find anything you want, perhaps even something important!
 
-| Project                 |  GemBench    |
+| Project                 |  GemBench         |
 |------------------------ | ----------------- |
-| gem name                |  gem_bench   |
-| license                 |  MIT              |
+| gem name                |  gem_bench        |
+| license                 |  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) |
 | 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) |
 | download rank           |  [![Download Rank](https://img.shields.io/gem/rt/gem_bench.svg)](https://rubygems.org/gems/gem_bench) |
 | version                 |  [![Gem Version](https://badge.fury.io/rb/gem_bench.png)](http://badge.fury.io/rb/gem_bench) |

data/gem_bench.gemspec

@@ -32,4 +32,5 @@ You: ❨╯°□°❩╯︵┻━┻}
   spec.add_development_dependency "rspec", "~> 3.5"
   spec.add_development_dependency "byebug", "~> 9.0"
   spec.add_development_dependency "gem-release", "~> 0.5"
+  spec.add_development_dependency "awesome_print"
 end

data/lib/gem_bench.rb

@@ -3,6 +3,9 @@ require "bundler" # This gem utilizes bundler as a tool.
 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"
 
 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"
@@ -11,7 +14,7 @@ module GemBench
   REQUIRE_FALSE_REGEX = /^[^#]+require(([:]\s*)|(\s*=>\s*))false.*/
   DEPENDENCY_REGEX_PROC = ->(name) { /^\s*[^#]*\s*gem\s+['"]{1}#{name}['"]{1}/ }
   PATH_GLOB = ->(name) { "#{name}*/lib/**/*.rb" }
-  EXCLUDE_FILE_PATTERN_REGEX_PROC = ->(name) { /#{name}\/test|features|spec/ }
+  EXCLUDE_FILE_PATTERN_REGEX_PROC = ->(name) { /#{name}\/test|features|spec|bin|exe/ }
   DO_NOT_SCAN = []
   PLAYER_STATES = {
     starter:  :starter,
@@ -24,6 +27,16 @@ module GemBench
       @roster = GemBench::Team.new({verbose: verbose})
     end
 
+    def versions_present?(verbose: false)
+      @roster = GemBench::StrictVersionRequirement.new({verbose: verbose})
+      @roster.versions_present?
+    end
+
+    def list_missing_version_constraints(verbose: false)
+      @roster = GemBench::StrictVersionRequirement.new({verbose: verbose})
+      @roster.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({look_for_regex: look_for_regex, exclude_file_pattern_regex_proc: exclude_file_pattern_regex_proc, verbose: verbose})
     end

data/lib/gem_bench/gemfile_line_tokenizer.rb

@@ -0,0 +1,181 @@
+module GemBench
+  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
+    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_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
+    # 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
+        @all_lines = all_lines
+        @index = index
+        @tokens = self.line.split(',')
+        determine_name
+        if self.name
+          determine_relevant_lines
+          determine_version
+          @parse_success = true
+          @valid = VALID_VERSION_TYPES.include?(self.version_type)
+        else
+          noop
+        end
+      else
+        noop
+      end
+    end
+
+    private
+
+    # not a gem line.  noop.
+    def noop
+      @parse_success = false
+      @valid = false
+    end
+
+    def determine_name
+      # uses @tokens[0] because the gem name must be before the first comma
+      match_data = @tokens[0].match(GEM_NAME_REGEX)
+      @name = match_data[:name]
+    end
+
+    def determine_relevant_lines
+      @relevant_lines = [line, *following_non_gem_lines].compact
+    end
+
+    def determine_version
+      version_path ||
+        (
+          version_git && (
+            check_for_version_of_type_git_ref ||
+            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
+    end
+
+    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]
+      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)
+        @version_type = :constraint
+        true
+      else
+        false
+      end
+    end
+
+    def version_path
+      @version = {}
+      line = relevant_lines.detect { |next_line| (next_line.match(VERSION_PATH)) }
+      return false unless line
+      enhance_version(
+          line.match(VERSION_PATH),
+          :path,
+          :path
+      )
+    end
+
+    def version_git
+      @version = {}
+      line = relevant_lines.detect { |next_line| (next_line.match(VERSION_GIT)) }
+      return false unless line
+      enhance_version(
+          line.match(VERSION_GIT),
+          :git,
+          :git
+      )
+    end
+
+    def check_for_version_of_type_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
+      )
+    end
+
+    def check_for_version_of_type_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
+      )
+    end
+
+    def check_for_version_of_type_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
+      )
+    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
+      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]
+        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
+    end
+  end
+end

data/lib/gem_bench/scout.rb

@@ -8,8 +8,6 @@ module GemBench
       @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] }
     end
 
     def check_gemfile?

data/lib/gem_bench/strict_version_gem.rb

@@ -0,0 +1,55 @@
+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
+
+    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
+        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
+        )
+      end
+    end
+
+    def initialize(name, version, version_type, valid, relevant_lines, index, tokenized_line = nil)
+      @name = name
+      @version = version
+      @version_type = version_type ? version_type.to_sym : :unknown
+      @valid = valid
+      @relevant_lines = relevant_lines
+      @index = index
+      @tokenized_line = tokenized_line # for debugging
+    end
+
+    def valid?
+      valid
+    end
+
+    def is_type?(type)
+      version_type == type.to_sym
+    end
+
+    def to_s
+      <<-EOS
+Gem: #{name}
+Line Number: #{index}
+Version: #{version.inspect}
+Relevant Gemfile Lines:
+#{relevant_lines.join("\n")}
+      EOS
+    end
+  end
+end

data/lib/gem_bench/strict_version_requirement.rb

@@ -0,0 +1,66 @@
+module GemBench
+  class StrictVersionRequirement
+    attr_reader :gemfile_path
+    attr_reader :gems
+    attr_reader :starters
+    attr_reader :benchers
+    attr_reader :verbose
+
+    def initialize(options = {})
+      @gemfile_path = "#{Dir.pwd}/Gemfile"
+      file = File.open(gemfile_path)
+      # Get all lines as an array
+      all_lines = file.readlines
+      @gems = []
+      all_lines.each_with_index do |line, index|
+        # will return nil if the line is not a gem line
+        gem = StrictVersionGem.from_line(all_lines, line, index)
+        @gems << gem if gem
+      end
+
+      @starters, @benchers = @gems.partition {|x| x.valid? }
+      # Remove all the commented || blank lines
+      @verbose = options[:verbose]
+      self.print if self.verbose
+    end
+
+    def versions_present?
+      gems.detect {|x| !x.valid? }.nil?
+    end
+
+    def list_missing_version_constraints
+      benchers.map { |x| x.name }
+    end
+
+    def find(name)
+      gems.detect {|x| x.name == name }
+    end
+
+    def gem_at(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
+    end
+  end
+end

data/lib/gem_bench/version.rb

@@ -1,3 +1,3 @@
 module GemBench
-  VERSION = "1.0.1"
+  VERSION = "1.0.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gem_bench
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Peter Boling
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-25 00:00:00.000000000 Z
+date: 2017-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: trim down app load times by keeping your worst players on the bench
 email:
 - peter.boling@gmail.com
@@ -100,8 +114,11 @@ files:
 - bin/setup
 - gem_bench.gemspec
 - lib/gem_bench.rb
+- lib/gem_bench/gemfile_line_tokenizer.rb
 - lib/gem_bench/player.rb
 - lib/gem_bench/scout.rb
+- lib/gem_bench/strict_version_gem.rb
+- lib/gem_bench/strict_version_requirement.rb
 - lib/gem_bench/team.rb
 - lib/gem_bench/version.rb
 homepage: http://github.com/acquaintable/gem_bench
@@ -124,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: 'Gem: "Put me in coach" You: ❨╯°□°❩╯︵┻━┻'