react-manifest-rails 0.2.34 → 0.3.1

data/lib/react_manifest/gitignore_patcher.rb

@@ -0,0 +1,81 @@
+require "fileutils"
+
+module ReactManifest
+  # Ensures the generated manifest dir is gitignored and that a committed .keep
+  # keeps the directory present on a fresh clone. Idempotent and best-effort:
+  # a filesystem error logs a warning and never raises.
+  class GitignorePatcher
+    include ReactManifest::Logging
+
+    Result = Struct.new(:appended, :keep_created, keyword_init: true)
+
+    def initialize(config = ReactManifest.configuration)
+      @config = config
+    end
+
+    def patch!
+      Result.new(appended: ensure_gitignore_entry, keep_created: ensure_keep)
+    end
+
+    # patch! plus a one-time hint to untrack previously-committed manifests when the
+    # .gitignore entry was just added (the gem never runs git itself). Returns true
+    # iff the .gitignore entry was appended.
+    def reconcile!
+      result = patch!
+      if result.appended
+        base = File.dirname(pattern)
+        log_info "If #{base}/*.js were previously committed, untrack them once: " \
+                 "git rm --cached #{base}/*.js"
+      end
+      result.appended
+    end
+
+    # The component-index sidecar written next to the manifests (see ComponentIndex).
+    def json_pattern
+      File.join(File.dirname(pattern), "*.json")
+    end
+
+    # Path (relative to Rails.root) that should be ignored, e.g.
+    # "app/assets/javascripts/ux_manifests/*.js".
+    def pattern
+      subdir = @config.normalized_manifest_subdir
+      base   = subdir.empty? ? @config.output_dir : File.join(@config.output_dir, subdir)
+      File.join(base, "*.js")
+    end
+
+    private
+
+    def gitignore_path
+      Rails.root.join(".gitignore").to_s
+    end
+
+    def ensure_gitignore_entry
+      path    = gitignore_path
+      content = File.exist?(path) ? File.read(path, encoding: "utf-8") : ""
+      lines   = content.split("\n").map(&:strip)
+      missing = [pattern, json_pattern] - lines
+      return false if missing.empty?
+
+      prefix = content.empty? || content.end_with?("\n") ? "" : "\n"
+      File.open(path, "a") { |f| f.write("#{prefix}#{missing.join("\n")}\n") }
+      log_info "Added #{missing.join(', ')} to .gitignore"
+      true
+    rescue Errno::EACCES, Errno::ENOENT => e
+      log_warn "Could not update .gitignore: #{e.message}"
+      false
+    end
+
+    def ensure_keep
+      dir  = @config.abs_manifest_dir
+      keep = File.join(dir, ".keep")
+      return false if File.exist?(keep)
+
+      FileUtils.mkdir_p(dir)
+      FileUtils.touch(keep)
+      true
+    rescue Errno::EACCES => e
+      log_warn "Could not create #{dir}/.keep: #{e.message}"
+      false
+    end
+  end
+end

data/lib/react_manifest/railtie.rb

@@ -26,6 +26,12 @@ module ReactManifest
         Rails.logger&.warn(error)
         $stdout.puts(error) if config.stdout_logging?
       end
+
+      begin
+        ReactManifest.reconcile_gitignore!(config)
+      rescue StandardError => e
+        Rails.logger&.warn("[ReactManifest] gitignore reconcile failed: #{e.message}")
+      end
     end
 
     # Expose config as Rails.application.config.react_manifest

data/lib/react_manifest/symbol_extractor.rb

@@ -44,6 +44,20 @@ module ReactManifest
       regex_extract_definitions(content)
     end
 
+    # Top-level const/let/class names of any casing (destructured ones included).
+    # These are the only declarations that throw when two classic scripts share a
+    # global lexical scope; var and function redeclaration is legal.
+    def extract_lexical_bindings(content, file_path: nil)
+      return [] unless content
+
+      if ast_engine_available?
+        result = AstExtractor.extract_lexical_bindings(content, file_path: file_path)
+        return result if result
+      end
+
+      regex_extract_lexical_bindings(content)
+    end
+
     def extract_usages(content, file_path: nil)
       return [] unless content
 
@@ -75,6 +89,19 @@ module ReactManifest
       symbols.uniq
     end
 
+    # ponytail: column-0 declarations only, flat destructuring; the AST path is exact.
+    def regex_extract_lexical_bindings(content)
+      names = content.scan(/^(?:export\s+)?class\s+([A-Za-z_$][\w$]*)/).flatten
+      content.scan(/^(?:export\s+)?(?:const|let)\s+([A-Za-z_$][\w$]*)/) { |m| names << m[0] }
+      content.scan(/^(?:export\s+)?(?:const|let)\s*[{\[]([^}\]]*)[}\]]\s*=[^=]/) do |m|
+        m[0].split(",").each do |part|
+          name = part.split("=").first.split(":").last.to_s.sub("...", "").strip
+          names << name if name.match?(/\A[A-Za-z_$][\w$]*\z/)
+        end
+      end
+      names.uniq
+    end
+
     def regex_extract_usages(content)
       local_syms = Set.new
       DEFINITION_PATTERNS.each { |p| content.scan(p) { |m| local_syms << m[0] } }