react-manifest-rails 0.2.21 → 0.2.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a68f022a75a440c68e741e931c5453e6c96c126380356757825a984de94e2143
-  data.tar.gz: 52d20e65e685a1b82d833ee650677c91a6fc5faa9e7b32c1075d85a2e6f53fa7
+  metadata.gz: 907e5e7bb8b3e6a8554009c4e8a87a39379d8bd09c4455fd9c02b082a014c18b
+  data.tar.gz: 11d4e6ca8833973107937eee1b82881f620f3b2e74442ab0883521ea5803d58b
 SHA512:
-  metadata.gz: bfd3abb4dde7e8d661df2623b42345a6f5a191f6b119ce25d8913ab094261ea76592ea435709a9fd80d320703673deb073b4df2a8de90a2fb76d6cf43532272b
-  data.tar.gz: cef2fd10f820ebf0a1583772fa7236e34f5c5d2744e076f682111d374cf220c265b2625d02a6f88d0274baaaa8e215eb55cfec353e528d85ac82327ef466dc6f
+  metadata.gz: 950abc3b34f1ffe0e8eb6fcd4ae7798469b60746531d0bb0171de0975881cb2572f35182e07785255fcf932ce14ccaac369a1238e2d5e2fe3b8689d323861d06
+  data.tar.gz: dc6fcbfb087a8aa9f95ff109147ee0345b2aa32fc1a0281118ffb60d12313735d659ecb55200832eb940bf6def8675ab711e64208fcc0ec17514e71e0ea57f42

data/CHANGELOG.md

@@ -7,10 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.23] - 2026-04-21
+
 ### Fixed
 - `react_component` now emits only `ux_shared` plus the direct owning bundle for the requested component symbol, instead of also emitting transitive controller manifests as separate script tags. This prevents unnecessary network requests for additional `ux_*.js` manifests while preserving dependency loading through generated manifest `require` directives.
 - Generator now skips `external_roots` and `external_providers` entries that resolve to files already included in `ux_shared`, preventing duplicate runtime declarations from overlapping shared/external includes.
 - View helper bundle deduplication now canonicalizes bundle names (e.g. `ux_shared` vs `ux_manifests/ux_shared`) to avoid re-emitting equivalent script tags.
+- Controller manifests now include scanner-detected shared dependencies after `ux_shared` removal, including transitive shared dependencies needed by shared components (for example `DataTable` -> `SortHeader`).
+- Shared `ux/lib` utility files are now included in controller manifests, restoring runtime availability for global helper functions such as `formatDate` and `formatCurrency`.
 
 ## [0.2.10] - 2026-04-16
 

data/README.md

@@ -235,6 +235,18 @@ If you see errors like `UserSignInForm is not defined` (often from `eval` inside
 
 Using `defer: true` can cause `react_component` inline scripts to run before your `ux_*.js` bundles are executed.
 
+### `Identifier '<Name>' has already been declared`
+
+This usually means the same component/function is being loaded from two separate bundles.
+
+Common cause: a file outside `ux/` (for example `app/assets/javascripts/components/navbar/*` loaded by `application.js`) references a symbol defined in `ux/app/<controller>/...`, while that controller bundle is also loaded via `react_bundle_tag`.
+
+Recommended fix:
+- Move globally reused symbols out of `ux/app/*` into a shared dir (`ux/components`, `ux/hooks`, `ux/lib`) so they are emitted once via `ux_shared.js`.
+- Keep controller-specific symbols in `ux/app/*` and avoid importing/using them from non-ux global assets.
+
+If you use `external_roots`, `react_manifest:analyze` and generation warnings will now flag this pattern explicitly.
+
 ## Compatibility
 
 - Ruby: 3.2+

data/lib/react_manifest/generator.rb

@@ -42,11 +42,11 @@ module ReactManifest
     # written and others stale/missing.
     def run!
       classification = @classifier.classify
-      controller_context = build_controller_context(classification.controller_dirs, classification.shared_dirs)
+      scan_result = Scanner.new(@config).scan(classification)
+      controller_context = build_controller_context(classification.controller_dirs, classification.shared_dirs, scan_result)
 
       # Phase 1: build all content in memory — no I/O.
       manifests = []
-      manifests << build_shared(classification.shared_dirs)
       classification.controller_dirs.each { |ctrl| manifests << build_controller(ctrl, controller_context) }
 
       migrate_legacy_manifests!
@@ -62,33 +62,20 @@ module ReactManifest
 
     # ------------------------------------------------------------------ shared
 
-    def build_shared(shared_dirs)
-      lines     = header_lines
-      any_files = false
 
-      shared_dirs.each do |shared_dir|
-        files = js_files_in(shared_dir[:path])
-        next if files.empty?
-
-        any_files = true
-        files.each { |f| lines << "//= require #{relative_require_path(f)}" }
-      end
-
-      lines << "// (no shared files found)" unless any_files
-
-      { filename: "#{@config.shared_bundle}.js", content: "#{lines.join("\n")}\n" }
-    end
 
     # --------------------------------------------------------------- controller
 
     def build_controller(ctrl, controller_context)
       lines = header_lines
       dep_requires = controller_dependency_requires(ctrl[:bundle_name], controller_context)
+      lib_reqs = controller_context[:shared_lib_requires]
+      shared_reqs = controller_context[:shared_requires].fetch(ctrl[:bundle_name], Set.new).to_a.sort
       ext_reqs = controller_context[:external_requires].fetch(ctrl[:bundle_name], Set.new).to_a.sort
 
       files = js_files_in(ctrl[:path])
       own_requires = files.map { |f| relative_require_path(f) }
-      all_requires = (dep_requires + ext_reqs + own_requires).uniq
+      all_requires = (dep_requires + lib_reqs + shared_reqs + ext_reqs + own_requires).uniq
 
       if all_requires.empty?
         lines << "// (no JSX files found in #{ctrl[:name]}/)"
@@ -99,13 +86,24 @@ module ReactManifest
       { filename: "#{ctrl[:bundle_name]}.js", content: "#{lines.join("\n")}\n" }
     end
 
-    def build_controller_context(controller_dirs, shared_dirs)
+    def build_controller_context(controller_dirs, shared_dirs, scan_result)
       bundle_files = {}
       symbol_to_bundle = {}
       external_symbol_to_require = {}
       dependencies = Hash.new { |h, k| h[k] = Set.new }
       external_requires = Hash.new { |h, k| h[k] = Set.new }
       shared_require_paths = shared_require_path_set(shared_dirs)
+      shared_requires = Hash.new { |h, k| h[k] = Set.new }
+      shared_dependency_map = build_shared_dependency_map(shared_dirs, shared_require_paths, scan_result)
+      shared_lib_requires = shared_lib_require_paths(shared_dirs)
+
+      controller_dirs.each do |ctrl|
+        scan_result.controller_usages.fetch(ctrl[:name], []).each do |req_path|
+          shared_requires[ctrl[:bundle_name]] << req_path
+        end
+        shared_requires[ctrl[:bundle_name]] = expand_shared_requires(shared_requires[ctrl[:bundle_name]],
+                                                                     shared_dependency_map)
+      end
 
       # Index controller-defined symbols for cross-app detection
       controller_dirs.each do |ctrl|
@@ -127,10 +125,8 @@ module ReactManifest
         abs_root = abs_external_root(root_path)
         external_js_files_in(abs_root).each do |file_path|
           req_path = relative_require_path(file_path)
-          if shared_require_paths.include?(normalize_require_path(req_path))
-            warn "[ReactManifest] Skipping external_roots file already provided by shared bundle: #{req_path}"
-            next
-          end
+
+          warn_on_external_controller_references(file_path, symbol_to_bundle)
 
           extract_defined_symbols(file_path).each do |sym|
             external_symbol_to_require[sym] ||= req_path
@@ -140,12 +136,6 @@ module ReactManifest
 
       # Explicit external_providers win over scanned roots on symbol conflicts
       @config.external_providers.each do |sym, req_path|
-        if shared_require_paths.include?(normalize_require_path(req_path))
-          warn "[ReactManifest] Skipping external provider '#{sym}' because it is already " \
-               "provided by shared bundle: #{req_path}"
-          next
-        end
-
         external_symbol_to_require[sym] = req_path
       end
 
@@ -165,6 +155,8 @@ module ReactManifest
       {
         bundle_files: bundle_files,
         dependencies: dependencies,
+        shared_lib_requires: shared_lib_requires,
+        shared_requires: shared_requires,
         external_requires: external_requires
       }
     end
@@ -368,10 +360,73 @@ module ReactManifest
       end
     end
 
+    def shared_lib_require_paths(shared_dirs)
+      shared_dirs.each_with_object([]) do |shared_dir, paths|
+        next unless File.basename(shared_dir[:path]) == "lib"
+
+        js_files_in(shared_dir[:path]).each do |file_path|
+          paths << normalize_require_path(relative_require_path(file_path))
+        end
+      end.sort.uniq
+    end
+
+    def build_shared_dependency_map(shared_dirs, shared_require_paths, scan_result)
+      dependency_map = Hash.new { |h, k| h[k] = Set.new }
+
+      shared_symbol_index = scan_result.symbol_index.each_with_object({}) do |(sym, req_path), index|
+        normalized = normalize_require_path(req_path)
+        next unless shared_require_paths.include?(normalized)
+
+        index[sym] = normalized
+      end
+
+      shared_dirs.each do |shared_dir|
+        js_files_in(shared_dir[:path]).each do |file_path|
+          from_req = normalize_require_path(relative_require_path(file_path))
+          extract_used_component_symbols(file_path).each do |sym|
+            to_req = shared_symbol_index[sym]
+            next if to_req.nil? || to_req == from_req
+
+            dependency_map[from_req] << to_req
+          end
+        end
+      end
+
+      dependency_map
+    end
+
+    def expand_shared_requires(initial_requires, dependency_map)
+      expanded = Set.new(initial_requires)
+      queue = initial_requires.to_a
+
+      until queue.empty?
+        req = queue.shift
+        dependency_map.fetch(req, Set.new).each do |dep_req|
+          next if expanded.include?(dep_req)
+
+          expanded << dep_req
+          queue << dep_req
+        end
+      end
+
+      expanded
+    end
+
     def normalize_require_path(path)
       path.to_s.sub(/\.js\.jsx$/, "").sub(/\.jsx$/, "").sub(/\.js$/, "")
     end
 
+    def warn_on_external_controller_references(file_path, symbol_to_bundle)
+      extract_used_component_symbols(file_path).each do |sym|
+        dep_bundle = symbol_to_bundle[sym]
+        next unless dep_bundle
+
+        warn "[ReactManifest] External file '#{relative_require_path(file_path)}' references " \
+             "controller-only symbol '#{sym}' (#{dep_bundle}). " \
+             "Move '#{sym}' to a shared ux dir to avoid duplicate runtime declarations."
+      end
+    end
+
     def auto_generated?(path)
       # Avoid TOCTOU: don't check existence separately — just attempt the read
       # and treat a missing/unreadable file as not auto-generated.

data/lib/react_manifest/scanner.rb

@@ -9,7 +9,6 @@ module ReactManifest
   # Phase 1 — builds a symbol index from shared dirs:
   #   "PrimaryButton" => "ux/components/buttons/primary_button"
   #   "useFetch"      => "ux/hooks/use_fetch"
-  #   "formatDate"    => "ux/lib/format_date"
   #
   # Phase 2 — scans controller files for usage of those symbols
   #   and produces per-controller lists of referenced shared files.
@@ -21,22 +20,19 @@ module ReactManifest
     DEFINITION_PATTERNS = [
       # CommonJS / variable-assignment style
       /(?:const|let|var)\s+([A-Z][A-Za-z0-9_]*)\s*=/, # const FooBar =
-      /function\s+([A-Z][A-Za-z0-9_]*)\s*\(/,                                       # function FooBar(
-      /class\s+([A-Z][A-Za-z0-9_]*)\s*(?:extends|\{)/,                              # class FooBar
+      /function\s+([A-Z][A-Za-z0-9_]*)\s*\(/,         # function FooBar(
+      /class\s+([A-Z][A-Za-z0-9_]*)\s*(?:extends|\{)/, # class FooBar
       /(?:const|let|var)\s+(use[A-Z][A-Za-z0-9_]*)\s*=/, # const useFoo = (hooks)
-      /function\s+(use[A-Z][A-Za-z0-9_]*)\s*\(/, # function useFoo(
-      /(?:const|let|var)\s+([a-z][A-Za-z0-9_]{2,})\s*=\s*(?:function|\()/, # const formatDate = function/arrow
-      /^function\s+([a-z][A-Za-z0-9_]{2,})\s*\(/, # function formatDate( at line start
+      /function\s+(use[A-Z][A-Za-z0-9_]*)\s*\(/,     # function useFoo(
 
       # ES module style (export default / named exports)
-      /^export\s+default\s+(?:function|class)\s+([A-Z][A-Za-z0-9_]*)/,             # export default function Foo
-      /^export\s+default\s+(?:function|class)\s+(use[A-Z][A-Za-z0-9_]*)/,          # export default function useFoo
-      /^export\s+(?:const|let|var)\s+([A-Z][A-Za-z0-9_]*)\s*=/,                    # export const Foo =
-      /^export\s+(?:const|let|var)\s+(use[A-Z][A-Za-z0-9_]*)\s*=/,                 # export const useFoo =
-      /^export\s+(?:const|let|var)\s+([a-z][A-Za-z0-9_]{2,})\s*=\s*(?:function|\()/, # export const formatDate =
-      /^export\s+function\s+([A-Z][A-Za-z0-9_]*)\s*\(/,                             # export function Foo(
-      /^export\s+function\s+(use[A-Z][A-Za-z0-9_]*)\s*\(/,                          # export function useFoo(
-      /^export\s+class\s+([A-Z][A-Za-z0-9_]*)\s*(?:extends|\{)/ # export class Foo
+      /^export\s+default\s+(?:function|class)\s+([A-Z][A-Za-z0-9_]*)/,
+      /^export\s+default\s+(?:function|class)\s+(use[A-Z][A-Za-z0-9_]*)/,
+      /^export\s+(?:const|let|var)\s+([A-Z][A-Za-z0-9_]*)\s*=/,
+      /^export\s+(?:const|let|var)\s+(use[A-Z][A-Za-z0-9_]*)\s*=/,
+      /^export\s+function\s+([A-Z][A-Za-z0-9_]*)\s*\(/,
+      /^export\s+function\s+(use[A-Z][A-Za-z0-9_]*)\s*\(/,
+      /^export\s+class\s+([A-Z][A-Za-z0-9_]*)\s*(?:extends|\{)/
     ].freeze
 
     # Patterns to detect usage in controller files.
@@ -57,7 +53,8 @@ module ReactManifest
       Object Array String Number Boolean Symbol Map Set WeakMap
     ].freeze
 
-    Result = Struct.new(:symbol_index, :controller_usages, :warnings, :shared_violations, keyword_init: true)
+    Result = Struct.new(:symbol_index, :controller_usages, :warnings, :shared_violations,
+                        :external_violations, keyword_init: true)
 
     def initialize(config = ReactManifest.configuration)
       @config = config
@@ -65,8 +62,9 @@ module ReactManifest
 
     # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/PerceivedComplexity
     def scan(classification)
-      warnings      = []
+      warnings      = Set.new
       symbol_index  = {}
+      external_file_paths = {} # file_path => relative_require_path for external_roots files
 
       # Phase 1a: index symbols from shared dirs
       shared_file_paths = {} # file_path => relative_require_path for all shared files
@@ -77,7 +75,7 @@ module ReactManifest
           symbols = extract_definitions(file_path)
           symbols.each do |sym|
             if symbol_index.key?(sym)
-              warnings << "Duplicate symbol '#{sym}' in #{relative} (already from #{symbol_index[sym]})"
+              warnings.add("Duplicate symbol '#{sym}' in #{relative} (already from #{symbol_index[sym]})")
             else
               symbol_index[sym] = relative
             end
@@ -90,7 +88,8 @@ module ReactManifest
         abs_root = abs_external_root(root_path)
         js_files_in(abs_root).each do |file_path|
           relative = relative_require_path(file_path)
-          symbols  = extract_definitions(file_path)
+          external_file_paths[file_path] = relative
+          symbols = extract_definitions(file_path)
           symbols.each do |sym|
             symbol_index[sym] ||= relative
           end
@@ -119,6 +118,7 @@ module ReactManifest
 
       # Phase 1e: detect shared files that use app-dir (controller) symbols
       shared_violations = detect_shared_violations(shared_file_paths, controller_symbol_index, warnings)
+      external_violations = detect_external_root_violations(external_file_paths, controller_symbol_index, warnings)
 
       # Phase 2: scan controller dirs for usage
       controller_usages = {}
@@ -127,7 +127,7 @@ module ReactManifest
         files   = js_files_in(ctrl[:path])
         used    = Set.new
 
-        warnings << "Controller dir '#{ctrl[:name]}' has no JS/JSX files" if files.empty? && @config.verbose?
+        warnings.add("Controller dir '#{ctrl[:name]}' has no JS/JSX files") if files.empty? && @config.verbose?
 
         files.each do |file_path|
           validate_naming(file_path, ctrl[:name], warnings)
@@ -146,8 +146,9 @@ module ReactManifest
       Result.new(
         symbol_index: symbol_index,
         controller_usages: controller_usages,
-        warnings: warnings,
-        shared_violations: shared_violations
+        warnings: warnings.to_a,
+        shared_violations: shared_violations,
+        external_violations: external_violations
       )
     end
     # rubocop:enable Metrics/MethodLength,Metrics/AbcSize,Metrics/PerceivedComplexity
@@ -195,8 +196,8 @@ module ReactManifest
       # Expected: <controller>_index, <controller>_show, <controller>_form, etc.
       return if basename.start_with?("#{ctrl_name}_") || basename == ctrl_name
 
-      warnings << "File '#{File.basename(file_path)}' in '#{ctrl_name}' does not follow " \
-                  "'#{ctrl_name}_<action>.js.jsx' naming convention"
+      warnings.add("File '#{File.basename(file_path)}' in '#{ctrl_name}' does not follow " \
+                  "'#{ctrl_name}_<action>.js.jsx' naming convention")
     end
 
     def detect_shared_violations(shared_file_paths, controller_symbol_index, warnings)
@@ -220,9 +221,39 @@ module ReactManifest
             info = controller_symbol_index[sym]
             violations << { shared_file: relative, symbol: sym,
                             controller: info[:controller], app_file: info[:file] }
-            warnings << "Shared file '#{relative}' uses app-dir symbol '#{sym}' " \
+            warnings.add("Shared file '#{relative}' uses app-dir symbol '#{sym}' " \
+                        "(from ux/app/#{info[:controller]}). " \
+                        "Move '#{sym}' to a shared dir or the shared file will be incomplete.")
+          end
+        end
+      end
+      violations
+    end
+
+    def detect_external_root_violations(external_file_paths, controller_symbol_index, warnings)
+      violations = []
+      external_file_paths.each do |file_path, relative|
+        content = begin
+          File.read(file_path, encoding: "utf-8")
+        rescue Errno::ENOENT, Errno::EACCES, Encoding::InvalidByteSequenceError
+          next
+        end
+
+        local_syms = Set.new
+        DEFINITION_PATTERNS.each { |p| content.scan(p) { |m| local_syms << m[0] } }
+
+        [PASCAL_TOKEN_PATTERN, HOOK_TOKEN_PATTERN].each do |pattern|
+          content.scan(pattern) do |match|
+            sym = match[0]
+            next if local_syms.include?(sym)
+            next unless controller_symbol_index.key?(sym)
+
+            info = controller_symbol_index[sym]
+            violations << { external_file: relative, symbol: sym,
+                            controller: info[:controller], app_file: info[:file] }
+            warnings.add("External file '#{relative}' uses app-dir symbol '#{sym}' " \
                         "(from ux/app/#{info[:controller]}). " \
-                        "Move '#{sym}' to a shared dir or the shared file will be incomplete."
+                        "Move '#{sym}' into a shared ux dir to avoid duplicate runtime declarations.")
           end
         end
       end
@@ -238,8 +269,7 @@ module ReactManifest
 
       fanout.each do |file, count|
         if count > 3
-          warnings << "High fan-out: '#{file}' is used by #{count} controllers " \
-                      "(consider ensuring it's in the shared bundle)"
+          warnings.add("High fan-out: '#{file}' is used by #{count} controllers")
         end
       end
     end
@@ -247,10 +277,10 @@ module ReactManifest
     def read_controller_file(file_path, warnings)
       File.read(file_path, encoding: "utf-8")
     rescue Errno::ENOENT, Errno::EACCES => e
-      warnings << "Skipping #{file_path}: #{e.message}"
+      warnings.add("Skipping #{file_path}: #{e.message}")
       nil
     rescue Encoding::InvalidByteSequenceError
-      warnings << "Skipping #{file_path}: not valid UTF-8"
+      warnings.add("Skipping #{file_path}: not valid UTF-8")
       nil
     end
 

data/lib/react_manifest/version.rb

@@ -1,3 +1,3 @@
 module ReactManifest
-  VERSION = "0.2.21".freeze
+  VERSION = "0.2.23".freeze
 end

data/lib/react_manifest/view_helpers.rb

@@ -5,11 +5,10 @@ module ReactManifest
   #   <%= react_bundle_tag %>
   #
   # Resolves which ux_*.js bundles to include based on controller_path:
-  #   1. Always includes config.shared_bundle (e.g. "ux_shared")
-  #   2. Always appends config.always_include (e.g. ["ux_main"])
-  #   3. Appends "ux_<controller_path>" if that bundle file exists
-  #   4. For namespaced controllers (admin/users): checks ux_admin_users, then ux_admin
-  #   5. Returns "" for pure ERB/HAML pages with no matching bundle, or when
+  #   1. Appends config.always_include (e.g. ["ux_main"])
+  #   2. Appends "ux_<controller_path>" if that bundle file exists
+  #   3. For namespaced controllers (admin/users): checks ux_admin_users, then ux_admin
+  #   4. Returns "" for pure ERB/HAML pages with no matching bundle, or when
   #      called outside a controller context (mailers, engines, etc.)
   module ViewHelpers
     def react_bundle_tag(**html_options)
@@ -22,10 +21,14 @@ module ReactManifest
       return "".html_safe if bundles.empty?
 
       # Record emitted bundles so react_component doesn't re-emit them.
-      emitted = (@_react_manifest_emitted_bundles ||= [])
-      bundles.each { |b| emitted << b unless emitted_bundle?(emitted, b) }
+      emitted = emitted_bundles
+      fresh_bundles = bundles.reject { |b| emitted_bundle?(emitted, b) }
+      return "".html_safe if fresh_bundles.empty?
 
-      asset_names = bundles.map { |bundle| "#{bundle}.js" }
+      fresh_bundles.each { |b| emitted << b }
+      mark_bundle_tag_rendered
+
+      asset_names = fresh_bundles.map { |bundle| "#{bundle}.js" }
       javascript_include_tag(*asset_names, extname: false, **html_options)
     end
 
@@ -35,12 +38,13 @@ module ReactManifest
     # This avoids strict dependence on controller_path -> bundle naming alignment.
     def react_component(*args, **kwargs, &block)
       html = super
+      return html if bundle_tag_rendered?
 
       component_name = args.first
       bundles = ReactManifest.resolve_bundles_for_component_direct(component_name)
       return html if bundles.empty?
 
-      emitted = (@_react_manifest_emitted_bundles ||= [])
+      emitted = emitted_bundles
 
       new_tags = bundles.filter_map do |bundle|
         next if emitted_bundle?(emitted, bundle)
@@ -64,5 +68,27 @@ module ReactManifest
     def canonical_bundle_name(bundle)
       bundle.to_s.split("/").last
     end
+
+    def emitted_bundles
+      # ActionView can instantiate multiple helper contexts during one request.
+      # Store emitted bundles in request env so layout + template helpers dedupe.
+      if respond_to?(:request, true) && request
+        request.env["react_manifest.emitted_bundles"] ||= []
+      else
+        @_react_manifest_emitted_bundles ||= []
+      end
+    end
+
+    def mark_bundle_tag_rendered
+      return unless respond_to?(:request, true) && request
+
+      request.env["react_manifest.bundle_tag_rendered"] = true
+    end
+
+    def bundle_tag_rendered?
+      return false unless respond_to?(:request, true) && request
+
+      request.env["react_manifest.bundle_tag_rendered"] == true
+    end
   end
 end

data/tasks/react_manifest.rake

@@ -130,12 +130,6 @@ namespace :react_manifest do
     scan_result    = scanner.scan(classification)
     dep_map        = ReactManifest::DependencyMap.new(scan_result)
     dep_map.print_report
-
-    unless scan_result.warnings.empty?
-      puts "Warnings (#{scan_result.warnings.size}):"
-      scan_result.warnings.each { |w| puts "  ⚠  #{w}" }
-      puts
-    end
   end
 
   desc "Analyze application*.js files — show what migrate_application would change"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: react-manifest-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.21
+  version: 0.2.23
 platform: ruby
 authors:
 - Oliver Noonan