gem_bench 1.0.5 → 2.0.0

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

data/lib/gem_bench/team.rb

@@ -2,14 +2,37 @@ require "forwardable"
 
 module GemBench
   class Team
-    EXCLUDE = [ 'bundler','gem_bench','i18n-airbrake','devise-async','km','vestal_versions','omniauth-facebook',
-                'flag_shih_tzu','pry-remote','koala','simple_form','thumbs_up','memoist','cancan','friendly_id',
-                'faker']
+    EXCLUDE = %w[
+      bundler
+      gem_bench
+      i18n-airbrake
+      devise-async
+      km
+      vestal_versions
+      omniauth-facebook
+      flag_shih_tzu
+      pry-remote
+      koala
+      simple_form
+      thumbs_up
+      memoist
+      cancan
+      friendly_id
+      faker
+    ]
     # A comment preceding the require: false anywhere on the line should not be considered an active require: false
     extend Forwardable
     def_delegators :@scout, :gem_paths, :gemfile_path, :check_gemfile?, :loaded_gems
     attr_reader :scout, :look_for_regex
-    attr_accessor :all, :excluded, :starters, :benchers, :verbose, :gemfile_lines, :trash_lines, :current_gemfile_suggestions, :bad_ideas
+    attr_accessor :all,
+      :excluded,
+      :starters,
+      :benchers,
+      :verbose,
+      :gemfile_lines,
+      :trash_lines,
+      :current_gemfile_suggestions,
+      :bad_ideas
 
     def initialize(options = {})
       @look_for_regex = options[:look_for_regex]
@@ -20,94 +43,104 @@ module GemBench
       @scout = GemBench::Scout.new(check_gemfile: options[:check_gemfile] || benching?)
       @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]) }
-      exclusions = " + #{self.excluded.length} loaded gems which GemBench is configured to ignore.\n" if @excluded.length > 0
+      @excluded, @all = @scout.loaded_gems.partition { |x| EXCLUDE.include?(x[0]) }
+      exclusions = " + #{excluded.length} loaded gems which GemBench is configured to ignore.\n" if @excluded.length > 0
       @starters = []
       @benchers = []
       @current_gemfile_suggestions = []
       @verbose = options[:verbose]
-      self.check_all
+      check_all
       @bad_ideas = if benching?
-                     options[:bad_ideas] ? true : check_gemfile? ? false : options[:bad_ideas] == false ? false : true
-                   else
-                     false
-                   end
-      puts "[GemBench] Will search for gems in #{gem_paths.inspect}\n#{benching? ? @scout.check_gemfile? ? "[GemBench] Will check Gemfile at #{gemfile_path}.\n" : "[GemBench] No Gemfile found.\n" : ""}#{self.bad_ideas ? "[GemBench] Will show bad ideas.  Be Careful.\n" : ''}[GemBench] Detected #{self.all.length} loaded gems#{exclusions}"
-      self.compare_gemfile if benching? && @scout.check_gemfile?
-      self.print if self.verbose
+        if options[:bad_ideas]
+          true
+        else
+          check_gemfile? ? false : !(options[:bad_ideas] == false)
+        end
+      else
+        false
+      end
+      puts "[GemBench] Will search for gems in #{gem_paths.inspect}\n#{if benching?
+                                                                         @scout.check_gemfile? ? "[GemBench] Will check Gemfile at #{gemfile_path}.\n" : "[GemBench] No Gemfile found.\n"
+                                                                       else
+                                                                         ""
+                                                                       end}#{bad_ideas ? "[GemBench] Will show bad ideas.  Be Careful.\n" : ""}[GemBench] Detected #{all.length} loaded gems#{exclusions}"
+      compare_gemfile if benching? && @scout.check_gemfile?
+      self.print if verbose
     end
 
     def list_starters(format: :name)
-      starters.map {|starter| starter.to_s(format)}
+      starters.map { |starter| starter.to_s(format) }
     end
 
     def print
-      string = ''
-      if self.all.empty?
+      string = ""
+      if all.empty?
         string << nothing
-      elsif self.starters.empty?
+      elsif starters.empty?
         string << if benching?
-                    "[GemBench] Found no gems that need to load at boot time.\n"
-                  else
-                    "[GemBench] Found no gems containing #{look_for_regex} in Ruby code.\n"
-                  end
-      else
-        if self.starters.length > 0
-          string << "\n#{GemBench::USAGE}" unless check_gemfile?
-          string << if benching?
-                      "[GemBench] We found a Rails::Railtie or Rails::Engine in the following files. However, it is possible that there are false positives, so you may want to verify that this is the case.\n\n"
-                    else
-                      "[GemBench] We found #{look_for_regex} in the following files.\n\n"
-                    end
-          self.starters.each do |starter|
-            string << "\t#{starter}:\n"
-            starter.stats.each do |stat|
-              string << "\t\t#{stat[0]}:#{stat[1]}\n"
-            end
-          end
-          string << "[GemBench] If you want to check for false positives, the files to check for Railties and Engines are listed above.\n" if benching?
-          string << if benching?
-                      "[GemBench] #{self.starters.length} out of #{self.all.length} evaluated gems actually need to be loaded at boot time. They are:\n"
-                    else
-                      "[GemBench] #{self.starters.length} out of #{self.all.length} evaluated gems contain #{look_for_regex}. They are:\n"
-                    end
-          self.starters.each_with_index do |starter, index|
-            string << "#{starter.info(index + 1)}\n"
-          end
-          if extra_verbose? && !benching? && self.benchers.length > 0
-            string << "[GemBench] #{self.benchers.length} out of #{self.all.length} evaluated gems did not contain #{look_for_regex}. They are:\n"
-            self.benchers.each_with_index do |bencher, index|
-              string << "#{bencher.info(index + 1)}\n"
-            end
+          "[GemBench] Found no gems that need to load at boot time.\n"
+        else
+          "[GemBench] Found no gems containing #{look_for_regex} in Ruby code.\n"
+        end
+      elsif starters.length > 0
+        string << "\n#{GemBench::USAGE}" unless check_gemfile?
+        string << if benching?
+          "[GemBench] We found a Rails::Railtie or Rails::Engine in the following files. However, it is possible that there are false positives, so you may want to verify that this is the case.\n\n"
+        else
+          "[GemBench] We found #{look_for_regex} in the following files.\n\n"
+        end
+        starters.each do |starter|
+          string << "\t#{starter}:\n"
+          starter.stats.each do |stat|
+            string << "\t\t#{stat[0]}:#{stat[1]}\n"
           end
+        end
+        if benching?
+          string << "[GemBench] If you want to check for false positives, the files to check for Railties and Engines are listed above.\n"
+        end
+        string << if benching?
+          "[GemBench] #{starters.length} out of #{all.length} evaluated gems actually need to be loaded at boot time. They are:\n"
         else
-          string << "[GemBench] Congrats! All gems appear clean.\n"
-          string << "\n#{GemBench::USAGE}" unless check_gemfile?
+          "[GemBench] #{starters.length} out of #{all.length} evaluated gems contain #{look_for_regex}. They are:\n"
+        end
+        starters.each_with_index do |starter, index|
+          string << "#{starter.info(index + 1)}\n"
         end
+        if extra_verbose? && !benching? && benchers.length > 0
+          string << "[GemBench] #{benchers.length} out of #{all.length} evaluated gems did not contain #{look_for_regex}. They are:\n"
+          benchers.each_with_index do |bencher, index|
+            string << "#{bencher.info(index + 1)}\n"
+          end
+        end
+      else
+        string << "[GemBench] Congrats! All gems appear clean.\n"
+        string << "\n#{GemBench::USAGE}" unless check_gemfile?
       end
       if check_gemfile? && benching?
-        if self.current_gemfile_suggestions.length > 0
-          string << "[GemBench] Evaluated #{self.all.length} gems and Gemfile at #{gemfile_path}.\n[GemBench] Here are #{self.current_gemfile_suggestions.length} suggestions for improvement:\n"
-          self.current_gemfile_suggestions.each_with_index do |player, index|
+        if current_gemfile_suggestions.length > 0
+          string << "[GemBench] Evaluated #{all.length} gems and Gemfile at #{gemfile_path}.\n[GemBench] Here are #{current_gemfile_suggestions.length} suggestions for improvement:\n"
+          current_gemfile_suggestions.each_with_index do |player, index|
             string << "#{player.suggest(index + 1)}\n"
           end
         else
-          string << self.strike_out
+          string << strike_out
         end
       end
 
-      if benching? && self.bad_ideas
+      if benching? && bad_ideas
         # Only bad ideas if you are evaluating an actual Gemfile. If just evaluating loaded gems, then info is fine.
-        string << self.prepare_bad_ideas
+        string << prepare_bad_ideas
       end
 
       puts string
     end
 
     def strike_out
-      check_gemfile? ?
-        "[GemBench] Evaluated #{self.all.length} gems against your Gemfile but found no primary dependencies which can safely skip require on boot (require: false).\n" :
-        "[GemBench] Evaluated #{self.all.length} gems but found none which can safely skip require on boot (require: false).\n"
+      if check_gemfile?
+        "[GemBench] Evaluated #{all.length} gems against your Gemfile but found no primary dependencies which can safely skip require on boot (require: false).\n"
+      else
+        "[GemBench] Evaluated #{all.length} gems but found none which can safely skip require on boot (require: false).\n"
+      end
     end
 
     def nothing
@@ -115,40 +148,46 @@ module GemBench
     end
 
     def prepare_bad_ideas
-      string = ''
-      if self.benchers.length > 0
-        gemfile_instruction = check_gemfile? ? '' : "To safely evaluate a Gemfile:\n\t1. Make sure you are in the root of a project with a Gemfile\n\t2. Make sure the gem is actually a dependency in the Gemfile\n"
-        string << "[GemBench] Evaluated #{self.all.length} loaded gems and found #{self.benchers.length} which may be able to skip boot loading (require: false).\n*** => WARNING <= ***: Be careful adding non-primary dependencies to your Gemfile as it is generally a bad idea.\n#{gemfile_instruction}"
-        self.benchers.each_with_index do |player, index|
+      string = ""
+      if benchers.length > 0
+        gemfile_instruction = check_gemfile? ? "" : "To safely evaluate a Gemfile:\n\t1. Make sure you are in the root of a project with a Gemfile\n\t2. Make sure the gem is actually a dependency in the Gemfile\n"
+        string << "[GemBench] Evaluated #{all.length} loaded gems and found #{benchers.length} which may be able to skip boot loading (require: false).\n*** => WARNING <= ***: Be careful adding non-primary dependencies to your Gemfile as it is generally a bad idea.\n#{gemfile_instruction}"
+        benchers.each_with_index do |player, index|
           string << "#{player.careful(index + 1)}\n"
         end
       else
-        string << self.strike_out
+        string << strike_out
       end
       string
     end
 
     def compare_gemfile
-      self.benchers.each do |player|
+      benchers.each do |player|
         scout.gemfile_lines.each do |line|
           found = (line =~ player.gemfile_regex)
-          if found
-            # remove the found line from the array, because no sane person has more than one gem dependency per line... right?
-            line = scout.gemfile_lines.delete_at(scout.gemfile_lines.index(line))
-            # does the line already have require: false?
-            self.current_gemfile_suggestions << self.benchers.delete_at(self.benchers.index(player)) unless line =~ GemBench::REQUIRE_FALSE_REGEX
-            break # outside of the inner loop
+          next unless found
+
+          # remove the found line from the array, because no sane person has more than one gem dependency per line... right?
+          line = scout.gemfile_lines.delete_at(scout.gemfile_lines.index(line))
+          # does the line already have require: false?
+          unless line =~ GemBench::REQUIRE_FALSE_REGEX
+            current_gemfile_suggestions << benchers.delete_at(benchers.index(player))
           end
+          break # outside of the inner loop
         end
       end
     end
 
     def check_all
-      self.all.each do |player_data|
+      all.each do |player_data|
         exclude_file_pattern = @exclude_file_pattern_regex_proc.call(player_data[0])
-        player = GemBench::Player.new({name: player_data[0], version: player_data[1], exclude_file_pattern: exclude_file_pattern})
-        self.check(player)
-        self.add_to_roster(player)
+        player = GemBench::Player.new({
+          name: player_data[0],
+          version: player_data[1],
+          exclude_file_pattern: exclude_file_pattern,
+        })
+        check(player)
+        add_to_roster(player)
       end
     end
 
@@ -166,16 +205,16 @@ module GemBench
 
     def add_to_roster(player)
       if player.starter?
-        self.starters << player
+        starters << player
       else
-        self.benchers << player
+        benchers << player
       end
     end
 
     private
 
     def extra_verbose?
-      self.verbose == "extra"
+      verbose == "extra"
     end
 
     def benching?

data/lib/gem_bench/version.rb

@@ -1,3 +1,5 @@
 module GemBench
-  VERSION = "1.0.5"
+  module Version
+    VERSION = "2.0.0"
+  end
 end