Class: Herb::ActionView::RenderAnalyzer

Inherits:
Object
  • Object
show all
Includes:
Colors
Defined in:
lib/herb/action_view/render_analyzer.rb,
sig/herb/action_view/render_analyzer.rbs

Defined Under Namespace

Classes: Result

Constant Summary

Constants included from Colors

Colors::CLEAR_SCREEN, Colors::HIDE_CURSOR, Colors::SHOW_CURSOR

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Colors

bold, bright_magenta, cyan, dimmed, enabled?, fg, fg_bg, green, magenta, red, #self?.bold, #self?.bright_magenta, #self?.cyan, #self?.dimmed, #self?.enabled?, #self?.fg, #self?.fg_bg, #self?.green, #self?.magenta, #self?.red, #self?.white, #self?.yellow, white, yellow

Constructor Details

#initialize(project_path, configuration: nil) ⇒ RenderAnalyzer

Returns a new instance of RenderAnalyzer.

Parameters:

  • project_path (Object)
  • configuration: (Object) (defaults to: nil) 


21
22
23
24
 
# File 'lib/herb/action_view/render_analyzer.rb', line 21

def initialize(project_path, configuration: nil)
  @project_path = Pathname.new(File.expand_path(project_path))
  @configuration = configuration || Configuration.load(@project_path.to_s)
end

Instance Attribute Details

#configuration ⇒ Object (readonly)

Returns the value of attribute configuration.

Returns:

  • (Object) 


19
20
21
 
# File 'lib/herb/action_view/render_analyzer.rb', line 19

def configuration
  @configuration
end

#project_path ⇒ Object (readonly)

Returns the value of attribute project_path.

Returns:

  • (Object) 


19
20
21
 
# File 'lib/herb/action_view/render_analyzer.rb', line 19

def project_path
  @project_path
end

Instance Method Details

#analyze(erb_files = nil, view_root = nil) ⇒ Object

Parameters:

  • erb_files (Object) (defaults to: nil)
  • view_root (Object) (defaults to: nil)

Returns:

  • (Object) 


371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
 
# File 'lib/herb/action_view/render_analyzer.rb', line 371

def analyze(erb_files = nil, view_root = nil)
  erb_files ||= find_erb_files
  view_root ||= find_view_root

  render_calls_by_file = collect_render_calls_by_file(erb_files)
  ruby_partial_references = collect_ruby_render_references
  partial_files = find_partial_files(view_root)

  all_render_calls = render_calls_by_file.values.flatten
  static_calls, dynamic_calls = partition_dynamic(all_render_calls)

  render_graph = build_render_graph(render_calls_by_file, partial_files, view_root)

  unresolved = find_unresolved(static_calls, partial_files, view_root)

  unused = find_unused_by_reachability(
    render_graph, partial_files, ruby_partial_references,
    collect_all_dynamic_prefixes(dynamic_calls, ruby_partial_references),
    view_root
  )

  Result.new(
    render_calls: all_render_calls,
    dynamic_calls: dynamic_calls,
    partial_files: partial_files,
    unresolved: unresolved,
    unused: unused,
    view_root: view_root
  )
end

#analyze_from_collected(render_calls_by_file:, dynamic_prefixes_from_erb: [], layout_refs_from_erb: []) ⇒ Object

Parameters:

  • render_calls_by_file: (Object)
  • dynamic_prefixes_from_erb: (Object) (defaults to: [])
  • layout_refs_from_erb: (Object) (defaults to: [])

Returns:

  • (Object) 


402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
 
# File 'lib/herb/action_view/render_analyzer.rb', line 402

def analyze_from_collected(render_calls_by_file:, dynamic_prefixes_from_erb: [], layout_refs_from_erb: [])
  view_root = find_view_root

  @dynamic_prefixes_from_erb = dynamic_prefixes_from_erb
  @layout_refs_from_erb = layout_refs_from_erb

  ruby_partial_references = collect_ruby_render_references
  partial_files = find_partial_files(view_root)

  all_render_calls = render_calls_by_file.values.flatten
  static_calls, dynamic_calls = partition_dynamic(all_render_calls)

  render_graph = build_render_graph(render_calls_by_file, partial_files, view_root)

  unresolved = find_unresolved(static_calls, partial_files, view_root)

  unused = find_unused_by_reachability(
    render_graph, partial_files, ruby_partial_references,
    collect_all_dynamic_prefixes(dynamic_calls, ruby_partial_references),
    view_root
  )

  Result.new(
    render_calls: all_render_calls,
    dynamic_calls: dynamic_calls,
    partial_files: partial_files,
    unresolved: unresolved,
    unused: unused,
    view_root: view_root
  )
end

#build_render_graph(render_calls_by_file, partial_files, view_root) ⇒ Object

Parameters:

  • render_calls_by_file (Object)
  • partial_files (Object)
  • view_root (Object)

Returns:

  • (Object) 


819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
 
# File 'lib/herb/action_view/render_analyzer.rb', line 819

def build_render_graph(render_calls_by_file, partial_files, view_root)
  graph = {} #: Hash[String, Array[String]]

  render_calls_by_file.each do |file, calls|
    resolved_names = [] #: Array[String]

    calls.each do |call|
      partial_reference = call[:partial] || call[:layout]
      next unless partial_reference

      resolved = resolve_partial(partial_reference, file, partial_files, view_root)
      if resolved
        resolved_name = partial_name_for_file(resolved, view_root)
        resolved_names << resolved_name if resolved_name
      else
        resolved_names << partial_reference
      end
    end

    graph[file] = resolved_names.uniq
  end

  (@layout_refs_from_erb || []).each do |layout_reference|
    graph["__layout_refs__"] ||= []
    graph["__layout_refs__"] << layout_reference
  end

  graph
end

#check! ⇒ Object

Returns:

  • (Object) 


26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/herb/action_view/render_analyzer.rb', line 26

def check!
  start_time = Time.now

  erb_files = find_erb_files
  view_root = find_view_root

  if erb_files.empty?
    puts "No ERB files found."
    return false
  end

  puts ""
  puts "#{bold("Herb")} \u{1f33f} #{dimmed("v#{Herb::VERSION}")}"
  puts ""

  if configuration.config_path
    puts "#{green("\u2713")} Using Herb config file at #{dimmed(configuration.config_path.to_s)}"
  else
    puts dimmed("No .herb.yml found, using defaults")
  end

  puts dimmed("Checking render calls in #{erb_files.count} #{pluralize(erb_files.count, "file")}...")

  result = analyze(erb_files, view_root)
  duration = Time.now - start_time

  print_results(result, duration)

  result.issues?
end

#collect_all_dynamic_prefixes(dynamic_calls, ruby_references) ⇒ Object

Parameters:

  • dynamic_calls (Object)
  • ruby_references (Object)

Returns:

  • (Object) 


925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
 
# File 'lib/herb/action_view/render_analyzer.rb', line 925

def collect_all_dynamic_prefixes(dynamic_calls, ruby_references)
  prefixes = dynamic_calls.filter_map { |call|
    next unless call[:partial]

    prefix = call[:partial].gsub(/\A["']|["']\z/, "")
    prefix = prefix.split("\#{").first&.chomp("/")
    prefix unless prefix.nil? || prefix.empty?
  }

  ruby_references.each do |reference|
    prefixes << reference[:prefix] if reference.is_a?(Hash) && reference[:prefix]
  end

  prefixes.concat(@dynamic_prefixes_from_erb || [])
  prefixes.uniq
end

#collect_render_calls_by_file(files) ⇒ Object

Parameters:

  • files (Object)

Returns:

  • (Object) 


727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
 
# File 'lib/herb/action_view/render_analyzer.rb', line 727

def collect_render_calls_by_file(files)
  @dynamic_prefixes_from_erb = [] #: Array[String]
  @layout_refs_from_erb = [] #: Array[String]

  ensure_parallel!

  file_results = Parallel.map(files, in_processes: Parallel.processor_count) do |file|
    process_file_for_render_calls(file)
  end

  render_calls_by_file = {} #: Hash[String, Array[Hash[Symbol, untyped]]]

  file_results.each do |file_result|
    next unless file_result

    render_calls_by_file[file_result[:file]] = file_result[:calls]
    @dynamic_prefixes_from_erb.concat(file_result[:dynamic_prefixes])
    @layout_refs_from_erb.concat(file_result[:layout_references])
  end

  render_calls_by_file
end

#collect_ruby_render_references ⇒ Object

Returns:

  • (Object) 


790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
 
# File 'lib/herb/action_view/render_analyzer.rb', line 790

def collect_ruby_render_references
  references = [] #: Array[untyped]

  ruby_directories = [
    @project_path.join("app"),
    @project_path.join("lib")
  ]

  ruby_directories.each do |directory|
    next unless directory.directory?

    Dir[File.join(directory, "**", "*.rb")].each do |file|
      content = File.read(file)

      content.scan(%r{(?:render\s+(?:partial:\s*)?|(?:self\.)?partial(?:\s*[:=]\s*|\s*=\s*))["']([a-z0-9_/]+)["']}) do |match|
        references << match[0]
      end

      content.scan(%r{(?:render\s+(?:partial:\s*)?|(?:self\.)?partial(?:\s*[:=]\s*|\s*=\s*))["']([a-z0-9_/]+)/\#\{}) do |match|
        references << { prefix: match[0] }
      end
    rescue StandardError
      next
    end
  end

  references
end

#compute_reachable(render_graph, partial_files, ruby_references, dynamic_prefixes) ⇒ Object

Parameters:

  • render_graph (Object)
  • partial_files (Object)
  • ruby_references (Object)
  • dynamic_prefixes (Object)

Returns:

  • (Object) 


545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
 
# File 'lib/herb/action_view/render_analyzer.rb', line 545

def compute_reachable(render_graph, partial_files, ruby_references, dynamic_prefixes)
  reachable = Set.new
  queue = [] #: Array[String]

  render_graph.each_key do |file|
    next if file.start_with?("__")

    basename = File.basename(file)
    next if basename.start_with?("_")

    queue << file
  end

  ruby_references.each do |reference|
    next unless reference.is_a?(String)

    reachable << reference
    resolved_file = partial_files[reference]
    queue << resolved_file if resolved_file
  end

  (render_graph["__layout_refs__"] || []).each do |layout_name|
    reachable << layout_name
    resolved_file = partial_files[layout_name]
    queue << resolved_file if resolved_file
  end

  visited_files = Set.new

  until queue.empty?
    current_file = queue.shift
    next if visited_files.include?(current_file)

    visited_files << current_file

    partial_names = render_graph[current_file] || []

    partial_names.each do |partial_name|
      next if reachable.include?(partial_name)

      reachable << partial_name

      resolved_file = partial_files[partial_name]
      queue << resolved_file if resolved_file && render_graph.key?(resolved_file)
    end
  end

  partial_files.each_key do |name|
    if dynamic_prefixes.any? { |prefix| name.start_with?("#{prefix}/") }
      reachable << name
    end
  end

  reachable
end

#dynamic_partial?(partial_name) ⇒ Boolean

Parameters:

  • partial_name (Object)

Returns:

  • (Boolean) 


921
922
923
 
# File 'lib/herb/action_view/render_analyzer.rb', line 921

def dynamic_partial?(partial_name)
  partial_name.include?("\#{") || partial_name.include?("#\{") || partial_name.match?(%r{[^a-z0-9_/]})
end

#ensure_parallel! ⇒ Object

Returns:

  • (Object) 


784
785
786
787
788
 
# File 'lib/herb/action_view/render_analyzer.rb', line 784

def ensure_parallel!
  return if defined?(Parallel)

  Herb.ensure_installed { gem "parallel" }
end

#expected_file_path(partial_name, view_root) ⇒ Object

Parameters:

  • partial_name (Object)
  • view_root (Object)

Returns:

  • (Object) 


972
973
974
975
976
977
978
979
980
 
# File 'lib/herb/action_view/render_analyzer.rb', line 972

def expected_file_path(partial_name, view_root)
  parts = partial_name.split("/")
  parts[-1] = "_#{parts[-1]}"
  relative = parts.join("/")

  relative_root = relative_path(view_root.to_s)

  Herb::PARTIAL_EXTENSIONS.map { |extension| "#{relative_root}/#{relative}#{extension}" }.join(", ")
end

#file_display_name(file, view_root) ⇒ Object

Parameters:

  • file (Object)
  • view_root (Object)

Returns:

  • (Object) 


539
540
541
542
543
 
# File 'lib/herb/action_view/render_analyzer.rb', line 539

def file_display_name(file, view_root)
  Pathname.new(file).relative_path_from(view_root).to_s
rescue ArgumentError
  relative_path(file)
end

#find_erb_files ⇒ Object

Returns:

  • (Object) 


676
677
678
679
680
681
682
683
684
685
686
 
# File 'lib/herb/action_view/render_analyzer.rb', line 676

def find_erb_files
  patterns = configuration.file_include_patterns
  exclude = configuration.file_exclude_patterns

  files = patterns.flat_map { |pattern| Dir[File.join(@project_path, pattern)] }.uniq

  files.reject do |file|
    relative = Pathname.new(file).relative_path_from(@project_path).to_s
    exclude.any? { |pattern| File.fnmatch?(pattern, relative, File::FNM_PATHNAME) }
  end.sort
end

#find_partial_files(view_root) ⇒ Object

Parameters:

  • view_root (Object)

Returns:

  • (Object) 


697
698
699
700
701
702
703
704
705
706
707
708
 
# File 'lib/herb/action_view/render_analyzer.rb', line 697

def find_partial_files(view_root)
  return {} unless view_root.directory?

  partials = {} #: Hash[String, String]

  Dir[File.join(view_root, "**", Herb::PARTIAL_GLOB_PATTERN)].each do |file|
    partial_name = partial_name_for_file(file, view_root)
    partials[partial_name] = file if partial_name
  end

  partials
end

#find_unresolved(render_calls, partial_files, view_root) ⇒ Object

Parameters:

  • render_calls (Object)
  • partial_files (Object)
  • view_root (Object)

Returns:

  • (Object) 


942
943
944
945
946
947
948
 
# File 'lib/herb/action_view/render_analyzer.rb', line 942

def find_unresolved(render_calls, partial_files, view_root)
  render_calls.select do |call|
    next false unless call[:partial]

    !resolve_partial(call[:partial], call[:file], partial_files, view_root)
  end
end

#find_unused_by_reachability(render_graph, partial_files, ruby_references, dynamic_prefixes, _view_root) ⇒ Object

Parameters:

  • render_graph (Object)
  • partial_files (Object)
  • ruby_references (Object)
  • dynamic_prefixes (Object)
  • _view_root (Object)

Returns:

  • (Object) 


849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
 
# File 'lib/herb/action_view/render_analyzer.rb', line 849

def find_unused_by_reachability(render_graph, partial_files, ruby_references, dynamic_prefixes, _view_root)
  reachable = Set.new
  queue = [] #: Array[String]

  render_graph.each_key do |file|
    next if file.start_with?("__")

    basename = File.basename(file)
    next if basename.start_with?("_")

    queue << file
  end

  ruby_references.each do |reference|
    next unless reference.is_a?(String)

    reachable << reference
    resolved_file = partial_files[reference]

    queue << resolved_file if resolved_file
  end

  (render_graph["__layout_refs__"] || []).each do |layout_name|
    reachable << layout_name
    resolved_file = partial_files[layout_name]
    queue << resolved_file if resolved_file
  end

  visited_files = Set.new

  until queue.empty?
    current_file = queue.shift
    next if visited_files.include?(current_file)

    visited_files << current_file

    partial_names = render_graph[current_file] || []

    partial_names.each do |partial_name|
      next if reachable.include?(partial_name)

      reachable << partial_name

      resolved_file = partial_files[partial_name]
      queue << resolved_file if resolved_file && render_graph.key?(resolved_file)
    end
  end

  partial_files.each_key do |name|
    if dynamic_prefixes.any? { |prefix| name.start_with?("#{prefix}/") }
      reachable << name
    end
  end

  partial_files.except(*reachable)
end

#find_view_root ⇒ Object

Returns:

  • (Object) 


688
689
690
691
692
693
694
695
 
# File 'lib/herb/action_view/render_analyzer.rb', line 688

def find_view_root
  candidates = [
    @project_path.join("app", "views"),
    @project_path
  ]

  candidates.find(&:directory?) || @project_path
end

#format_duration(seconds) ⇒ Object

Parameters:

  • seconds (Object)

Returns:

  • (Object) 


1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
 
# File 'lib/herb/action_view/render_analyzer.rb', line 1004

def format_duration(seconds)
  if seconds < 1
    "#{(seconds * 1000).round(2)}ms"
  elsif seconds < 60
    "#{seconds.round(2)}s"
  else
    minutes = (seconds / 60).to_i
    remaining_seconds = seconds % 60

    "#{minutes}m #{remaining_seconds.round(2)}s"
  end
end

#fully_resolvable?(file_path) ⇒ Boolean

Parameters:

  • file_path (Object)

Returns:

  • (Boolean) 


57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/herb/action_view/render_analyzer.rb', line 57

def fully_resolvable?(file_path)
  file_path = @project_path.join(file_path).to_s unless Pathname.new(file_path).absolute?

  erb_files = find_erb_files
  view_root = find_view_root

  render_calls_by_file = collect_render_calls_by_file(erb_files)
  partial_files = find_partial_files(view_root)

  visited = Set.new
  queue = [file_path]

  while (current = queue.shift)
    next if visited.include?(current)

    visited << current

    calls = render_calls_by_file[current] || []

    calls.each do |call|
      return false if call[:dynamic]

      partial_ref = call[:partial] || call[:layout]
      next unless partial_ref

      return false if dynamic_partial?(partial_ref)

      resolved = resolve_partial(partial_ref, current, partial_files, view_root)
      return false unless resolved

      queue << resolved
    end
  end

  true
end

#graph! ⇒ Object

Returns:

  • (Object) 


221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
 
# File 'lib/herb/action_view/render_analyzer.rb', line 221

def graph!
  erb_files = find_erb_files
  view_root = find_view_root

  if erb_files.empty?
    puts "No ERB files found."
    return
  end

  puts ""
  puts "#{bold("Herb")} \u{1f33f} #{dimmed("v#{Herb::VERSION}")}"
  puts ""

  if configuration.config_path
    puts "#{green("\u2713")} Using Herb config file at #{dimmed(configuration.config_path.to_s)}"
  else
    puts dimmed("No .herb.yml found, using defaults")
  end

  puts dimmed("Building render graph for #{erb_files.count} #{pluralize(erb_files.count, "file")}...")

  render_calls_by_file = collect_render_calls_by_file(erb_files)
  ruby_partial_references = collect_ruby_render_references
  partial_files = find_partial_files(view_root)
  render_graph = build_render_graph(render_calls_by_file, partial_files, view_root)

  all_render_calls = render_calls_by_file.values.flatten
  _, dynamic_calls = partition_dynamic(all_render_calls)
  dynamic_prefixes = collect_all_dynamic_prefixes(dynamic_calls, ruby_partial_references)
  reverse_graph = Hash.new { |hash, key| hash[key] = [] } #: Hash[String, Array[String]]

  render_graph.each do |file, partial_names|
    next if file.start_with?("__")

    display_name = file_display_name(file, view_root)

    partial_names.each do |partial_name|
      reverse_graph[partial_name] << display_name
    end
  end

  ruby_partial_references.each do |reference|
    next unless reference.is_a?(String)

    reverse_graph[reference] << "#{dimmed("[Ruby]")} #{reference}"
  end

  entry_points = render_graph.keys.reject { |file|
    file.start_with?("__") || File.basename(file).start_with?("_")
  }.sort

  reachable = compute_reachable(render_graph, partial_files, ruby_partial_references, dynamic_prefixes)

  puts ""
  puts separator
  puts ""

  if entry_points.any?
    puts " #{bold("Entry points:")} #{dimmed("(#{entry_points.count} #{pluralize(entry_points.count, "template")})")}"

    entry_points.each do |file|
      display = file_display_name(file, view_root)
      partials = render_graph[file] || []

      puts ""
      puts " #{cyan(display)}"

      if partials.empty?
        puts "   #{dimmed("(no render calls)")}"
      else
        print_partial_tree(partials, render_graph, partial_files, view_root, reachable, indent: "   ", visited: Set.new)
      end
    end
  end

  ruby_static_references = ruby_partial_references.select { |reference| reference.is_a?(String) }

  if ruby_static_references.any?
    puts ""
    puts " #{separator}"
    puts ""
    puts " #{bold("Ruby references:")} #{dimmed("(#{ruby_static_references.count} #{pluralize(ruby_static_references.count, "partial")})")}"

    ruby_static_references.sort.each do |reference|
      resolved = partial_files[reference]
      status = resolved ? green("\u2713") : red("\u2717")
      puts ""
      puts "   #{status} #{bold(reference)}"

      if resolved
        children = render_graph[resolved] || []
        print_partial_tree(children, render_graph, partial_files, view_root, reachable, indent: "     ", visited: Set.new)
      end
    end
  end

  unreachable = partial_files.except(*reachable)

  puts ""
  puts " #{separator}"
  puts ""
  puts " #{bold("Partial usage:")} #{dimmed("(who renders each partial)")}"

  partial_files.keys.sort.each do |name|
    callers = reverse_graph[name]
    status = reachable.include?(name) ? green("\u2713") : yellow("~")

    puts ""
    puts "   #{status} #{bold(name)}"

    if callers.any?
      callers.sort.each_with_index do |caller_name, index|
        connector = index == callers.size - 1 ? "\u2514\u2500\u2500" : "\u251c\u2500\u2500"
        puts "     #{connector} #{dimmed("rendered by")} #{caller_name}"
      end
    else
      puts "     #{dimmed("(not rendered by any file)")}"
    end
  end

  if unreachable.any?
    puts ""
    puts " #{separator}"
    puts ""
    puts " #{bold(yellow("Unreachable partials:"))} #{dimmed("(#{unreachable.count} #{pluralize(unreachable.count, "file")})")}"

    unreachable.each do |name, file|
      display = file_display_name(file, view_root)
      children = render_graph[file] || []

      puts ""
      puts "   #{yellow("~")} #{bold(name)} #{dimmed(display)}"

      if children.any?
        print_partial_tree(children, render_graph, partial_files, view_root, reachable, indent: "     ", visited: Set.new)
      end
    end
  end

  puts ""
  puts " #{separator}"
  puts ""
  puts " #{bold("Summary:")}"
  puts "  #{label("Entry points")} #{cyan(entry_points.count.to_s)}"
  puts "  #{label("Partials")} #{cyan(partial_files.count.to_s)}"
  puts "  #{label("Reachable")} #{bold(green(reachable.count.to_s))}"
  puts "  #{label("Unreachable")} #{unreachable.any? ? bold(yellow(unreachable.count.to_s)) : bold(green("0"))}"
  puts ""
end

#graph_file!(file_path) ⇒ Object

Parameters:

  • file_path (Object)

Returns:

  • (Object) 


94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
 
# File 'lib/herb/action_view/render_analyzer.rb', line 94

def graph_file!(file_path)
  is_partial = File.basename(file_path).start_with?("_")

  puts ""
  puts " #{bold("Herb")} \u{1f33f} #{dimmed("v#{Herb::VERSION}")}"
  puts ""
  puts " #{dimmed("Building render graph...")}"

  erb_files = find_erb_files
  view_root = find_view_root

  if erb_files.empty?
    puts "No ERB files found in project."
    return
  end

  render_calls_by_file = collect_render_calls_by_file(erb_files)
  ruby_partial_references = collect_ruby_render_references
  partial_files = find_partial_files(view_root)
  render_graph = build_render_graph(render_calls_by_file, partial_files, view_root)

  all_render_calls = render_calls_by_file.values.flatten
  _, dynamic_calls = partition_dynamic(all_render_calls)
  dynamic_prefixes = collect_all_dynamic_prefixes(dynamic_calls, ruby_partial_references)
  reachable = compute_reachable(render_graph, partial_files, ruby_partial_references, dynamic_prefixes)
  reverse_graph = Hash.new { |hash, key| hash[key] = [] } #: Hash[String, Array[String]]

  render_graph.each do |file, partial_names|
    next if file.start_with?("__")

    partial_names.each do |partial_name|
      reverse_graph[partial_name] << file
    end
  end

  ruby_partial_references.each do |reference|
    next unless reference.is_a?(String)

    reverse_graph[reference] << "__ruby__"
  end

  puts ""

  if is_partial
    partial_name = partial_name_for_file(file_path, view_root)

    unless partial_name
      puts "Could not determine partial name for: #{file_path}"
      return
    end

    display = file_display_name(file_path, view_root)
    status = reachable.include?(partial_name) ? green("\u2713") : yellow("~")

    puts " #{status} #{bold(partial_name)} #{dimmed(display)}"
    puts ""

    callers = reverse_graph[partial_name]

    if callers.any?
      puts " #{bold("Rendered by:")}"

      callers.each_with_index do |caller_file, index|
        connector = index == callers.size - 1 ? "\u2514\u2500\u2500" : "\u251c\u2500\u2500"

        if caller_file == "__ruby__"
          puts "   #{connector} #{dimmed("[Ruby code]")}"
        else
          caller_display = file_display_name(caller_file, view_root)
          caller_basename = File.basename(caller_file)
          caller_status = caller_basename.start_with?("_") ? dimmed("(partial)") : dimmed("(entry point)")
          puts "   #{connector} #{cyan(caller_display)} #{caller_status}"
        end
      end

      puts ""
      puts " #{bold("Reachable from:")}"
      entry_chains = trace_to_entry_points(partial_name, reverse_graph, partial_files, view_root)

      if entry_chains.any?
        entry_chains.each_with_index do |chain, index|
          connector = index == entry_chains.size - 1 ? "\u2514\u2500\u2500" : "\u251c\u2500\u2500"
          reversed = chain.reverse

          chain_display = reversed.each_with_index.map do |name, i|
            if i == 0
              bold(green(name))
            elsif i == reversed.size - 1
              bold(name)
            else
              dimmed(name)
            end
          end.join(dimmed(" \u2192 "))
          puts "   #{connector} #{chain_display}"
        end
      else
        puts "   #{yellow("(not reachable from any entry point)")}"
      end
    else
      puts " #{dimmed("Not rendered by any file.")}"
    end

    children = render_graph[file_path] || []

    if children.any?
      puts ""
      puts " #{bold("Renders:")}"
      print_partial_tree(children, render_graph, partial_files, view_root, reachable, indent: "   ", visited: Set.new)
    end
  else
    display = file_display_name(file_path, view_root)
    puts " #{cyan(display)} #{dimmed("(entry point)")}"
    puts ""

    children = render_graph[file_path] || []

    if children.any?
      puts " #{bold("Renders:")}"
      print_partial_tree(children, render_graph, partial_files, view_root, reachable, indent: "   ", visited: Set.new)
    else
      puts " #{dimmed("No render calls in this file.")}"
    end
  end

  puts ""
end

#label(text, width = 12) ⇒ Object

Parameters:

  • text (Object)
  • width (Object) (defaults to: 12)

Returns:

  • (Object) 


982
983
984
 
# File 'lib/herb/action_view/render_analyzer.rb', line 982

def label(text, width = 12)
  dimmed(text.ljust(width))
end

#partial_name_for_file(file_path, view_root) ⇒ Object

Parameters:

  • file_path (Object)
  • view_root (Object)

Returns:

  • (Object) 


710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
 
# File 'lib/herb/action_view/render_analyzer.rb', line 710

def partial_name_for_file(file_path, view_root)
  relative = Pathname.new(file_path).relative_path_from(view_root).to_s

  directory = File.dirname(relative)
  basename = File.basename(relative)

  return nil unless basename.start_with?("_")

  name = basename.sub(/\A_/, "").sub(/\..*\z/, "")

  if directory == "."
    name
  else
    "#{directory}/#{name}"
  end
end

#partition_dynamic(render_calls) ⇒ Object

Parameters:

  • render_calls (Object)

Returns:

  • (Object) 


906
907
908
909
910
911
912
913
914
915
916
917
918
919
 
# File 'lib/herb/action_view/render_analyzer.rb', line 906

def partition_dynamic(render_calls)
  static = [] #: Array[Hash[Symbol, untyped]]
  dynamic = [] #: Array[Hash[Symbol, untyped]]

  render_calls.each do |call|
    if call[:partial] && dynamic_partial?(call[:partial])
      dynamic << call
    else
      static << call
    end
  end

  [static, dynamic]
end

#pluralize(count, singular, plural = nil) ⇒ Object

Parameters:

  • count (Object)
  • singular (Object)
  • plural (Object) (defaults to: nil)

Returns:

  • (Object) 


1000
1001
1002
 
# File 'lib/herb/action_view/render_analyzer.rb', line 1000

def pluralize(count, singular, plural = nil)
  count == 1 ? singular : (plural || "#{singular}s")
end

#print_file_lists(result) ⇒ Object

Parameters:

  • result (Object)

Returns:

  • (Object) 


434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
 
# File 'lib/herb/action_view/render_analyzer.rb', line 434

def print_file_lists(result)
  return unless result.issues?

  if result.unresolved.any?
    puts "\n"
    puts " #{bold("Unresolved render calls:")}"
    puts " #{dimmed("These render calls reference partials that could not be found on disk.")}"

    grouped = result.unresolved.group_by { |call| call[:file] }

    grouped.each do |file, calls|
      relative = relative_path(file)

      puts ""
      puts " #{cyan(relative)}:"

      calls.each do |call|
        location = call[:location] ? dimmed("at #{call[:location]}") : nil
        expected = expected_file_path(call[:partial], result.view_root)
        puts "   #{red("\u2717")} #{bold(call[:partial])} #{location} #{dimmed("-")} #{dimmed(expected)}"
      end
    end
  end

  return unless result.unused.any?

  puts "\n #{separator}" if result.unresolved.any?
  puts "\n"
  puts " #{bold("Unused partials:")}"
  puts " #{dimmed("These partial files are not referenced by any reachable render call.")}"

  result.unused.each do |name, file|
    relative = relative_path(file)

    puts ""
    puts " #{cyan(relative)}:"
    puts "   #{yellow("~")} #{bold(name)} #{dimmed("not referenced")}"
  end
end

#print_issue_summary(result) ⇒ Object

Parameters:

  • result (Object)

Returns:

  • (Object) 


474
475
476
477
478
479
480
481
482
483
484
485
486
 
# File 'lib/herb/action_view/render_analyzer.rb', line 474

def print_issue_summary(result)
  return unless result.issues?

  if result.unresolved.any?
    files_count = result.unresolved.map { |call| call[:file] }.uniq.count

    puts "  #{white("Unresolved partials")} #{dimmed("(#{result.unresolved.count} #{pluralize(result.unresolved.count, "reference")} in #{files_count} #{pluralize(files_count, "file")})")}"
  end

  return unless result.unused.any?

  puts "  #{white("Unused partials")} #{dimmed("(#{result.unused.count} #{pluralize(result.unused.count, "file")})")}"
end

#print_partial_tree(partial_names, render_graph, partial_files, view_root, reachable, indent: "", visited: Set.new) ⇒ Object

Parameters:

  • partial_names (Object)
  • render_graph (Object)
  • partial_files (Object)
  • view_root (Object)
  • reachable (Object)
  • indent: (Object) (defaults to: "")
  • visited: (Object) (defaults to: Set.new)

Returns:

  • (Object) 


509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
 
# File 'lib/herb/action_view/render_analyzer.rb', line 509

def print_partial_tree(partial_names, render_graph, partial_files, view_root, reachable, indent: "", visited: Set.new)
  partial_names.each_with_index do |name, index|
    is_last = index == partial_names.size - 1
    connector = is_last ? "\u2514\u2500\u2500" : "\u251c\u2500\u2500"
    child_indent = is_last ? "    " : "\u2502   "

    resolved_file = partial_files[name]
    status = if !resolved_file
               red("\u2717")
             elsif reachable.include?(name)
               green("\u2713")
             else
               yellow("~")
             end

    puts "#{indent}#{connector} #{status} #{name}"

    next unless resolved_file
    next if visited.include?(name)

    visited.add(name)

    children = render_graph[resolved_file] || []

    if children.any?
      print_partial_tree(children, render_graph, partial_files, view_root, reachable, indent: "#{indent}#{child_indent}", visited: visited)
    end
  end
end

#print_results(result, duration) ⇒ Object

Parameters:

  • result (Object)
  • duration (Object)

Returns:

  • (Object) 


638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
 
# File 'lib/herb/action_view/render_analyzer.rb', line 638

def print_results(result, duration)
  if result.issues?
    puts ""
    puts separator
  end

  print_file_lists(result)

  if result.issues?
    puts "\n #{separator}"
    puts "\n"
    puts " #{bold("Issue summary:")}"
    print_issue_summary(result)
  end

  puts "\n #{separator}"

  scanned_files = result.render_calls.map { |call| call[:file] }.uniq.count
  issues = result.unresolved.count + result.unused.count

  puts "\n"
  puts " #{bold("Summary:")}"

  puts "  #{label("Version")} #{cyan(Herb.version)}"
  puts "  #{label("Checked")} #{cyan("#{scanned_files} #{pluralize(scanned_files, "file")}")}"

  print_summary_line(result)

  puts "  #{label("Duration")} #{cyan(format_duration(duration))}"

  if issues.zero?
    puts ""
    puts " #{bold(green("\u2713"))} #{green("All render calls resolve and all partials are used!")}"
  end

  puts ""
end

#print_summary_line(result) ⇒ Object

Parameters:

  • result (Object)

Returns:

  • (Object) 


488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
 
# File 'lib/herb/action_view/render_analyzer.rb', line 488

def print_summary_line(result)
  render_parts = [] #: Array[String]

  partials_only = result.render_calls.count { |call| call[:partial] }
  render_parts << stat(result.render_calls.count, "total", :green)
  render_parts << stat(partials_only, "with partial", :green)
  render_parts << stat(result.dynamic_calls.count, "dynamic", :yellow) if result.dynamic_calls.any?
  other_count = result.render_calls.count - partials_only
  render_parts << stat(other_count, "other", :green) if other_count.positive?

  partial_parts = [] #: Array[String]
  partial_parts << stat(result.partial_files.count, "on disk", :green)
  partial_parts << stat(result.unresolved.count, "unresolved", :red) if result.unresolved.any?
  partial_parts << stat(result.unused.count, "unused", :yellow) if result.unused.any?

  puts "  #{label("Renders")} #{render_parts.join(" | ")}"
  puts "  #{label("Partials")} #{partial_parts.join(" | ")}"
end

#process_file_for_render_calls(file) ⇒ Object

Parameters:

  • file (Object)

Returns:

  • (Object) 


750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
 
# File 'lib/herb/action_view/render_analyzer.rb', line 750

def process_file_for_render_calls(file)
  content = File.read(file)
  result = Herb.parse(content, render_nodes: true)

  visitor = RenderCallVisitor.new(file)
  visitor.visit(result.value)
  calls = visitor.render_calls.dup

  visitor_partials = calls.filter_map { |call| call[:partial] }.to_set

  dynamic_prefixes = [] #: Array[untyped]
  layout_references = [] #: Array[untyped]

  content.scan(%r{render[\s(]+(?:partial:\s*)?["']([a-z0-9_/]+)["']}) do |match|
    partial = match[0]
    next if visitor_partials.include?(partial)

    calls << { file: file, partial: partial }
  end

  content.scan(%r{render\s+(?:partial:\s*)?["']([a-z0-9_/]+)/\#\{}) do |match|
    dynamic_prefixes << match[0]
  end

  content.scan(%r{render\s+layout:\s*["']([a-z0-9_/]+)["']}) do |match|
    layout_references << match[0]
  end

  { file: file, calls: calls, dynamic_prefixes: dynamic_prefixes, layout_references: layout_references }
rescue StandardError => e
  warn "Warning: Could not parse #{file}: #{e.message}"
  nil
end

#relative_path(path) ⇒ Object

Parameters:

  • path (Object)

Returns:

  • (Object) 


1017
1018
1019
1020
1021
 
# File 'lib/herb/action_view/render_analyzer.rb', line 1017

def relative_path(path)
  Pathname.new(path).relative_path_from(Pathname.pwd).to_s
rescue ArgumentError
  path.to_s
end

#resolve_partial(partial_name, source_file, partial_files, view_root) ⇒ Object

Parameters:

  • partial_name (Object)
  • source_file (Object)
  • partial_files (Object)
  • view_root (Object)

Returns:

  • (Object) 


950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
 
# File 'lib/herb/action_view/render_analyzer.rb', line 950

def resolve_partial(partial_name, source_file, partial_files, view_root)
  return partial_files[partial_name] if partial_files.key?(partial_name)

  source_directory = begin
    Pathname.new(File.dirname(source_file)).relative_path_from(view_root).to_s
  rescue ArgumentError
    nil
  end

  if source_directory && source_directory != "."
    relative_name = "#{source_directory}/#{partial_name}"
    return partial_files[relative_name] if partial_files.key?(relative_name)
  end

  unless partial_name.include?("/")
    application_name = "application/#{partial_name}"
    return partial_files[application_name] if partial_files.key?(application_name)
  end

  nil
end

#separator ⇒ Object

Returns:

  • (Object) 


996
997
998
 
# File 'lib/herb/action_view/render_analyzer.rb', line 996

def separator
  dimmed("\u2500" * 60)
end

#stat(count, text, color) ⇒ Object

Parameters:

  • count (Object)
  • text (Object)
  • color (Object)

Returns:

  • (Object) 


986
987
988
989
990
991
992
993
994
 
# File 'lib/herb/action_view/render_analyzer.rb', line 986

def stat(count, text, color)
  value = "#{count} #{text}"

  if count.positive?
    bold(send(color, value))
  else
    bold(green(value))
  end
end

#trace_to_entry_points(partial_name, reverse_graph, _partial_files, view_root) ⇒ Object

Parameters:

  • partial_name (Object)
  • reverse_graph (Object)
  • _partial_files (Object)
  • view_root (Object)

Returns:

  • (Object) 


601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
 
# File 'lib/herb/action_view/render_analyzer.rb', line 601

def trace_to_entry_points(partial_name, reverse_graph, _partial_files, view_root)
  chains = [] #: Array[Array[String]]
  queue = [[partial_name]]
  visited = Set.new([partial_name])

  until queue.empty?
    current_chain = queue.shift

    current_name = current_chain.last
    callers = reverse_graph[current_name] || []

    callers.each do |caller_file|
      next if caller_file == "__ruby__"

      caller_basename = File.basename(caller_file)

      if caller_basename.start_with?("_")
        caller_name = partial_name_for_file(caller_file, view_root)
        next unless caller_name
        next if visited.include?(caller_name)

        visited.add(caller_name)
        queue << (current_chain + [caller_name])
      else
        entry_display = file_display_name(caller_file, view_root)
        chains << (current_chain + [entry_display])
      end
    end

    if callers.include?("__ruby__")
      chains << (current_chain + ["[Ruby code]"])
    end
  end

  chains
end