10955133417

Committed 20 Sep 2024 07:32AM UTC coverage: 95.723%. Remained the same

Build # 10955133417

Build Type

push

github

Committed by

pboling

Commit Message

♻️ Major Refactor

- Performance improvements
- Thread Safety
- More specs
- More documentation
- Support for alternative ruby string syntaxes
- Updated logic for version specified via git with branch, tag, ref

Run Details

161 of 181 branches covered (88.95%)

Branch coverage included in aggregate %.

75 of 75 new or added lines in 6 files covered. (100.0%)

9 existing lines in 1 file now uncovered.

488 of 497 relevant lines covered (98.19%)

1701.62 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.95

/lib/gem_bench/team.rb

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
      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

    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.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]) }
      exclusions = " + #{excluded.length} loaded gems which GemBench is configured to ignore.\n" if @excluded.length > 0
      @starters = []
      @benchers = []
      @current_gemfile_suggestions = []
      @verbose = options[:verbose]
      check_all
      @bad_ideas = if benching?
        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) }
    end

    def print
      string = ""
      if all.empty?
        string << nothing
      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
      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
          "[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 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 << strike_out
        end
      end

      if benching? && bad_ideas
        # Only bad ideas if you are evaluating an actual Gemfile. If just evaluating loaded gems, then info is fine.
        string << prepare_bad_ideas
      end

      puts string
    end

    def strike_out
      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
      "[GemBench] No gems were evaluated by GemBench.\n#{GemBench::USAGE}"
    end

    def prepare_bad_ideas
      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 << strike_out
      end
      string
    end

    def compare_gemfile
      benchers.each do |player|
        scout.gemfile_lines.each do |line|
          found = (line =~ player.gemfile_regex)
          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
      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,
        })
        check(player)
        add_to_roster(player)
      end
    end

    def check(player)
      gem_paths.detect do |path|
        glob_path = "#{path}/#{player.file_path_glob}"
        file_paths = Dir.glob(glob_path)
        puts "[GemBench] checking #{player} at #{glob_path} (#{file_paths.length} files)" if extra_verbose?
        file_paths.detect do |file_path|
          player.set_starter(file_path, line_match: look_for_regex)
          player.starter?
        end
      end
    end

    def add_to_roster(player)
      if player.starter?
        starters << player
      else
        benchers << player
      end
    end

    private

    def extra_verbose?
      verbose == "extra"
    end

    def benching?
      @benching
    end
  end
end

1	require "forwardable"	1✔
2
3	module GemBench	1✔
4	# It doesn't make sense to use Team unless the Gemfile you want to evaluate is currently loaded.
5	# For example:
6	# - if you are in a rails console, and want to evaluate the Gemfile of the Rails app, that's great!
7	# - if you are in a context with no Gemfile loaded, or a different Gemfile loaded than the one you want to evaluate,
8	# this class may not give sensible results. This is because it checks loaded gems via RubyGems and Bundler.
9	class Team	1✔
10	EXCLUDE = %w[
11	bundler	1✔
12	gem_bench
13	i18n-airbrake
14	devise-async
15	km
16	vestal_versions
17	omniauth-facebook
18	flag_shih_tzu
19	pry-remote
20	koala
21	simple_form
22	thumbs_up
23	memoist
24	cancan
25	friendly_id
26	faker
27	]
28	# A comment preceding the require: false anywhere on the line should not be considered an active require: false
29	extend Forwardable	1✔
30	def_delegators :@scout, :gem_paths, :gemfile_path, :check_gemfile?, :loaded_gems	1✔
31	attr_reader :scout, :look_for_regex	1✔
32	attr_accessor :all,	1✔
33	:excluded,
34	:starters,
35	:benchers,
36	:verbose,
37	:gemfile_lines,
38	:trash_lines,
39	:current_gemfile_suggestions,
40	:bad_ideas
41
42	def initialize(**options)	1✔
43	@look_for_regex = options[:look_for_regex]	21✔
44	# find: Find gems containing specific strings in code
45	# bench: Find gems that can probably be benched (require: false) in the Gemfile
46	@check_type = @look_for_regex ? :find : :bench	21✔
47	@benching = @check_type == :bench	21✔
48	@scout = GemBench::Scout.new(	21✔
49	check_gemfile: options.fetch(:check_gemfile, benching?),
50	gemfile_path: options.fetch(:gemfile_path, "#{Dir.pwd}/Gemfile"),
51	)
52	@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	21✔
53	# Among the loaded gems there may be some that did not need to be.
54	@excluded, @all = @scout.loaded_gems.partition { \|x\| EXCLUDE.include?(x[0]) }	1,302✔
55	exclusions = " + #{excluded.length} loaded gems which GemBench is configured to ignore.\n" if @excluded.length > 0	21!
56	@starters = []	21✔
57	@benchers = []	21✔
58	@current_gemfile_suggestions = []	21✔
59	@verbose = options[:verbose]	21✔
60	check_all	21✔
61	@bad_ideas = if benching?	21✔
62	if options[:bad_ideas]	18✔
63	true	1✔
64	else	17✔
65	check_gemfile? ? false : !(options[:bad_ideas] == false)	17✔
66	end
67	else	3✔
68	false	3✔
69	end
70	puts "[GemBench] Will search for gems in #{gem_paths.inspect}\n#{if benching?	21✔
71	@scout.check_gemfile? ? "[GemBench] Will check Gemfile at #{gemfile_path}.\n" : "[GemBench] No Gemfile found.\n"	18✔
72	else	3✔
73	""	3✔
74	end}#{bad_ideas ? "[GemBench] Will show bad ideas. Be Careful.\n" : ""}[GemBench] Detected #{all.length} loaded gems#{exclusions}"	21✔
75	compare_gemfile if benching? && @scout.check_gemfile?	21✔
76	self.print if verbose	21✔
77	end
78
79	def list_starters(format: :name)	1✔
80	starters.map { \|starter\| starter.to_s(format) }	6✔
81	end
82
83	def print	1✔
84	string = ""	25✔
85	if all.empty?	25!
UNCOV 86	string << nothing	✔
87	elsif starters.empty?	25!
UNCOV 88	string << if benching?	×
UNCOV 89	"[GemBench] Found no gems that need to load at boot time.\n"	×
90	else	×
UNCOV 91	"[GemBench] Found no gems containing #{look_for_regex} in Ruby code.\n"	×
92	end	25✔
93	elsif starters.length > 0	25✔
94	string << "\n#{GemBench::USAGE}" unless check_gemfile?	25✔
95	string << if benching?	25✔
96	"[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"	21✔
97	else	4✔
98	"[GemBench] We found #{look_for_regex} in the following files.\n\n"	4✔
99	end
100	starters.each do \|starter\|	25✔
101	string << "\t#{starter}:\n"	67✔
102	starter.stats.each do \|stat\|	67✔
103	string << "\t\t#{stat[0]}:#{stat[1]}\n"	67✔
104	end
105	end
106	if benching?	25✔
107	string << "[GemBench] If you want to check for false positives, the files to check for Railties and Engines are listed above.\n"	21✔
108	end
109	string << if benching?	25✔
110	"[GemBench] #{starters.length} out of #{all.length} evaluated gems actually need to be loaded at boot time. They are:\n"	21✔
111	else	4✔
112	"[GemBench] #{starters.length} out of #{all.length} evaluated gems contain #{look_for_regex}. They are:\n"	4✔
113	end
114	starters.each_with_index do \|starter, index\|	25✔
115	string << "#{starter.info(index + 1)}\n"	67✔
116	end
117	if extra_verbose? && !benching? && benchers.length > 0	25✔
118	string << "[GemBench] #{benchers.length} out of #{all.length} evaluated gems did not contain #{look_for_regex}. They are:\n"	4✔
119	benchers.each_with_index do \|bencher, index\|	4✔
120	string << "#{bencher.info(index + 1)}\n"	232✔
121	end
122	end
123	else	×
UNCOV 124	string << "[GemBench] Congrats! All gems appear clean.\n"	×
UNCOV 125	string << "\n#{GemBench::USAGE}" unless check_gemfile?	×
126	end
127	if check_gemfile? && benching?	25✔
128	if current_gemfile_suggestions.length > 0	19✔
129	string << "[GemBench] Evaluated #{all.length} gems and Gemfile at #{gemfile_path}.\n[GemBench] Here are #{current_gemfile_suggestions.length} suggestions for improvement:\n"	17✔
130	current_gemfile_suggestions.each_with_index do \|player, index\|	17✔
131	string << "#{player.suggest(index + 1)}\n"	17✔
132	end
133	else	2✔
134	string << strike_out	2✔
135	end
136	end
137
138	if benching? && bad_ideas	25✔
139	# Only bad ideas if you are evaluating an actual Gemfile. If just evaluating loaded gems, then info is fine.	4✔
140	string << prepare_bad_ideas	4✔
141	end
142
143	puts string	25✔
144	end
145
146	def strike_out	1✔
147	if check_gemfile?	2✔
148	"[GemBench] Evaluated #{all.length} gems against your Gemfile but found no primary dependencies which can safely skip require on boot (require: false).\n"	2✔
149	else	×
UNCOV 150	"[GemBench] Evaluated #{all.length} gems but found none which can safely skip require on boot (require: false).\n"	×
151	end
152	end
153
154	def nothing	1✔
UNCOV 155	"[GemBench] No gems were evaluated by GemBench.\n#{GemBench::USAGE}"	×
156	end
157
158	def prepare_bad_ideas	1✔
159	string = ""	4✔
160	if benchers.length > 0	4✔
161	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"	4✔
162	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}"	4✔
163	benchers.each_with_index do \|player, index\|	4✔
164	string << "#{player.careful(index + 1)}\n"	222✔
165	end
166	else	×
UNCOV 167	string << strike_out	×
168	end
169	string	4✔
170	end
171
172	def compare_gemfile	1✔
173	benchers.each do \|player\|	17✔
174	scout.gemfile_lines.each do \|line\|	941✔
175	found = (line =~ player.gemfile_regex)	13,538✔
176	next unless found	13,538✔
177
178	# remove the found line from the array, because no sane person has more than one gem dependency per line... right?
179	line = scout.gemfile_lines.delete_at(scout.gemfile_lines.index(line))	11✔
180	# does the line already have require: false?
181	unless line =~ GemBench::REQUIRE_FALSE_REGEX	11!
182	current_gemfile_suggestions << benchers.delete_at(benchers.index(player))	11✔
183	end
184	break # outside of the inner loop	11✔
185	end
186	end
187	end
188
189	def check_all	1✔
190	all.each do \|player_data\|	21✔
191	exclude_file_pattern = @exclude_file_pattern_regex_proc.call(player_data[0])	1,239✔
192	player = GemBench::Player.new({	1,239✔
193	name: player_data[0],
194	version: player_data[1],
195	exclude_file_pattern: exclude_file_pattern,
196	})
197	check(player)	1,239✔
198	add_to_roster(player)	1,239✔
199	end
200	end
201
202	def check(player)	1✔
203	gem_paths.detect do \|path\|	1,239✔
204	glob_path = "#{path}/#{player.file_path_glob}"	2,419✔
205	file_paths = Dir.glob(glob_path)	2,419✔
206	puts "[GemBench] checking #{player} at #{glob_path} (#{file_paths.length} files)" if extra_verbose?	2,419✔
207	file_paths.detect do \|file_path\|	2,419✔
208	player.set_starter(file_path, line_match: look_for_regex)	77,654✔
209	player.starter?	77,654✔
210	end
211	end
212	end
213
214	def add_to_roster(player)	1✔
215	if player.starter?	1,239✔
216	starters << player	59✔
217	else	1,180✔
218	benchers << player	1,180✔
219	end
220	end
221
222	private	1✔
223
224	def extra_verbose?	1✔
225	verbose == "extra"	2,444✔
226	end
227
228	def benching?	1✔
229	@benching	226✔
230	end
231	end
232	end

pboling / gem_bench / 10955133417

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous