opal-rails 2.0.3 → 3.0.0

data/lib/generators/opal/install/install_generator.rb

@@ -1,14 +1,165 @@
 class Opal::InstallGenerator < Rails::Generators::Base
   source_root File.expand_path('templates', __dir__)
 
-  def configure_sprockets
-    append_to_file 'app/assets/config/manifest.js', '//= link_directory ../javascript .js'
-    template "application.js.rb", "app/assets/javascript/application.js.rb"
-    template "initializer.rb", "config/initializers/opal.rb"
-
-    # Add the javascript tag to the application head tag
-    gsub_file 'app/views/layouts/application.html.erb', %r{(\n *)</head>},
-      '\1  <%= javascript_include_tag "application", "data-turbolinks-track": "reload" %>' \
-      '\1</head>'
+  def create_opal_files
+    create_application_entrypoint
+    template 'initializer.rb.tt', 'config/initializers/opal.rb'
+    empty_directory 'app/assets/builds'
+    create_file 'app/assets/builds/.keep' unless destination_file_exist?('app/assets/builds/.keep')
+    ensure_manifest_build_links
+    ensure_test_asset_debug
+    ensure_gitignore_entries
+    ensure_procfile_dev
+    ensure_bin_dev
+    ensure_javascript_include_tag
+  end
+
+  private
+
+  def create_application_entrypoint
+    return unless generate_application_entrypoint?
+
+    template 'application.rb', application_entrypoint_path
+  end
+
+  def opal_source_path
+    destination_directory_exist?('app/assets/opal') ? 'app/assets/opal' : 'app/opal'
+  end
+
+  def application_entrypoint_path
+    File.join(opal_source_path, 'application.rb')
+  end
+
+  def generate_application_entrypoint?
+    return false if destination_file_exist?(application_entrypoint_path)
+
+    existing_top_level_entrypoints.empty?
+  end
+
+  def application_entrypoint_available?
+    generate_application_entrypoint? || destination_file_exist?(application_entrypoint_path)
+  end
+
+  def entrypoints_literal
+    return ':all' if bulk_entrypoints_layout?
+
+    "{ '#{application_logical_name}' => 'application.rb' }"
+  end
+
+  def application_logical_name
+    application_asset_name_reserved? ? 'opal' : 'application'
+  end
+
+  def application_asset_name_reserved?
+    reserved_application_asset_paths.any? { |path| destination_file_exist?(path) }
+  end
+
+  def reserved_application_asset_paths
+    %w[
+      app/javascript/application.js
+      app/javascript/application.mjs
+      app/javascript/application.ts
+      app/javascript/application.tsx
+      app/assets/javascripts/application.js
+      app/assets/javascripts/application.js.erb
+      app/assets/builds/application.js
+    ]
+  end
+
+  def bulk_entrypoints_layout?
+    return false if existing_top_level_entrypoints.empty?
+
+    existing_top_level_entrypoints.length > 1 || existing_top_level_entrypoints.first != 'application.rb'
+  end
+
+  def existing_top_level_entrypoints
+    @existing_top_level_entrypoints ||= begin
+      source_root_path = destination_path(opal_source_path)
+      if File.directory?(source_root_path)
+        Dir.children(source_root_path)
+           .select { |entry| entry.end_with?('.rb') && File.file?(File.join(source_root_path, entry)) }
+           .sort
+      else
+        []
+      end
+    end
+  end
+
+  def ensure_gitignore_entries
+    return unless destination_file_exist?('.gitignore')
+
+    append_unless_present('.gitignore', "/app/assets/builds/*\n")
+    append_unless_present('.gitignore', "!/app/assets/builds/.keep\n")
+  end
+
+  def ensure_manifest_build_links
+    manifest_path = 'app/assets/config/manifest.js'
+    return unless destination_file_exist?(manifest_path)
+
+    append_unless_present(manifest_path, "//= link_directory ../builds .js\n")
+    append_unless_present(manifest_path, "//= link_directory ../builds .map\n")
+  end
+
+  def ensure_test_asset_debug
+    test_env_path = 'config/environments/test.rb'
+    return unless destination_file_exist?(test_env_path)
+    return unless destination_file_exist?('app/assets/config/manifest.js')
+
+    test_env_contents = File.read(destination_path(test_env_path))
+    return if test_env_contents.match?(/config\.assets\.debug\s*=/)
+
+    insert_into_file test_env_path, "\n  config.assets.debug = true", before: /\nend\s*\z/
+  end
+
+  def ensure_procfile_dev
+    if destination_file_exist?('Procfile.dev')
+      append_unless_present('Procfile.dev', "opal: bin/rails opal:watch\n")
+    else
+      create_file 'Procfile.dev', "web: bin/rails server\nopal: bin/rails opal:watch\n"
+    end
+  end
+
+  def ensure_bin_dev
+    if destination_file_exist?('bin/dev')
+      # Replace bin/dev if it doesn't use Procfile.dev -- Rails 8.1+
+      # generates a bin/dev that just execs "bin/rails server" directly.
+      bin_dev_content = File.read(destination_path('bin/dev'))
+      return if bin_dev_content.include?('Procfile.dev')
+
+      remove_file 'bin/dev'
+    end
+
+    empty_directory 'bin'
+    template 'dev', 'bin/dev'
+    chmod 'bin/dev', 0o755
+  end
+
+  def ensure_javascript_include_tag
+    layout_path = 'app/views/layouts/application.html.erb'
+    return unless destination_file_exist?(layout_path)
+    return unless application_entrypoint_available?
+
+    layout_contents = File.read(destination_path(layout_path))
+    return if layout_contents.match?(/javascript_include_tag\s+["']#{Regexp.escape(application_logical_name)}["']/)
+
+    tag = %(<%= javascript_include_tag "#{application_logical_name}", "data-turbo-track": "reload" %>)
+
+    insert_into_file layout_path, "  #{tag}\n", before: %r{\n *</head>}
+  end
+
+  def append_unless_present(path, contents)
+    append_to_file(path, contents) unless File.read(destination_path(path)).include?(contents.strip)
+  end
+
+  def destination_directory_exist?(relative_path)
+    File.directory?(destination_path(relative_path))
+  end
+
+  def destination_file_exist?(relative_path)
+    File.exist?(destination_path(relative_path))
+  end
+
+  def destination_path(relative_path)
+    File.join(destination_root, relative_path)
   end
 end

data/lib/generators/opal/install/templates/{application.js.rb → application.rb}

@@ -1,12 +1,12 @@
-require "opal"
+require 'opal'
 
-# Uncomment the following to print out you're hello-world with Opal:
+# Uncomment the following to print a hello-world message with Opal:
 #
-#   puts "hello world!"
+#   puts 'hello world!'
 #
 # The following will append a hello-world to your <body> element:
 #
-#   require "native"
+#   require 'native'
 #   $$[:document].addEventListener :DOMContentLoaded do
 #     $$[:document][:body][:innerHTML] = '<h2>Hello World!</h2>'
 #   end

data/lib/generators/opal/install/templates/dev.tt

@@ -0,0 +1,8 @@
+#!/usr/bin/env sh
+
+if ! gem list foreman -i --silent; then
+  echo "Installing foreman..."
+  gem install foreman
+fi
+
+exec foreman start -f Procfile.dev "$@"

data/lib/generators/opal/install/templates/{initializer.rb → initializer.rb.tt}

@@ -19,4 +19,12 @@ Rails.application.configure do
   #   - :ivars  # only instance variables
   #
   config.opal.assigns_in_templates = false
+
+  # Build-oriented Opal asset configuration
+  config.opal.source_path = Rails.root.join('<%= opal_source_path %>')
+  config.opal.entrypoints_path = config.opal.source_path
+  config.opal.build_path = Rails.root.join('app/assets/builds')
+  config.opal.entrypoints = <%= entrypoints_literal %>
+  config.opal.append_paths = []
+  config.opal.use_gems = []
 end

data/lib/opal/rails/builder_runner.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'pathname'
+
+module Opal
+  module Rails
+    class BuilderRunner
+      def initialize(config:, builder_class: Opal::Builder)
+        @config = config
+        @builder_class = builder_class
+      end
+
+      def build(entrypoints:)
+        with_opal_config do
+          outputs = []
+          dependencies = {}
+
+          FileUtils.mkdir_p(build_path)
+
+          entrypoints.each_pair do |logical_name, relative_source_file|
+            builder = build_entrypoint(relative_source_file)
+            js_output = "#{logical_name}.js"
+
+            write_output(js_output, compiled_source_for(builder, js_output))
+            outputs << js_output
+
+            if source_map_enabled?
+              map_output = "#{js_output}.map"
+              write_output(map_output, builder.source_map.to_json)
+              outputs << map_output
+            end
+
+            dependencies[logical_name] = builder.dependent_files
+          end
+
+          {
+            outputs: outputs,
+            dependencies: dependencies
+          }
+        end
+      end
+
+      private
+
+      attr_reader :builder_class, :config
+
+      def build_entrypoint(relative_source_file)
+        builder = builder_class.new(
+          compiler_options: Opal::Config.compiler_options,
+          missing_require_severity: Opal::Config.missing_require_severity
+        )
+
+        builder.append_paths(*builder_paths)
+        Array(config.use_gems).each { |gem_name| builder.use_gem(gem_name) }
+        builder.build(relative_source_file)
+        builder
+      end
+
+      def builder_paths
+        [
+          config.entrypoints_path,
+          config.source_path,
+          *Array(config.append_paths)
+        ].compact.map { |path| Pathname(path).expand_path.to_s }.uniq
+      end
+
+      def build_path
+        Pathname(config.build_path).expand_path
+      end
+
+      def source_map_enabled?
+        value = config[:source_map_enabled]
+        value.nil? ? Opal::Config.source_map_enabled : value
+      end
+
+      def compiled_source_for(builder, js_output)
+        source = builder.to_s
+        return source unless source_map_enabled?
+
+        [source, "//# sourceMappingURL=#{File.basename(js_output)}.map", nil].join("\n")
+      end
+
+      def write_output(relative_path, contents)
+        output_path = build_path.join(relative_path)
+        FileUtils.mkdir_p(output_path.dirname)
+        output_path.write(contents)
+      end
+
+      def with_opal_config
+        original_config = snapshot_opal_config
+        apply_app_config_to_opal!
+        yield
+      ensure
+        restore_opal_config(original_config)
+      end
+
+      def snapshot_opal_config
+        Opal::Config.config.each_with_object({}) do |(key, value), snapshot|
+          snapshot[key] = begin
+            value.dup
+          rescue TypeError
+            value
+          end
+        end
+      end
+
+      def apply_app_config_to_opal!
+        config.each_pair do |key, value|
+          setter = "#{key}="
+          Opal::Config.public_send(setter, value) if Opal::Config.respond_to?(setter)
+        end
+      end
+
+      def restore_opal_config(snapshot)
+        return unless snapshot
+
+        Opal::Config.reset!
+        snapshot.each_pair do |key, value|
+          setter = "#{key}="
+          Opal::Config.public_send(setter, value) if Opal::Config.respond_to?(setter)
+        end
+      end
+    end
+  end
+end

data/lib/opal/rails/engine.rb

@@ -1,6 +1,4 @@
 require 'rails'
-require 'opal/sprockets'
-require 'sprockets/railtie'
 
 module Opal
   module Rails
@@ -11,13 +9,17 @@ module Opal
 
       config.opal.dynamic_require_severity = :ignore
       config.opal.assigns_in_templates = true
+      config.opal.entrypoints = { 'application' => 'application.rb' }
+      config.opal.append_paths = []
+      config.opal.use_gems = []
+      config.opal.suppress_legacy_upgrade_warning = false
 
       def (config.opal).assign_locals_in_templates?
-        assigns_in_templates == true || assigns_in_templates == :locals
+        [true, :locals].include?(assigns_in_templates)
       end
 
       def (config.opal).assign_instance_variables_in_templates?
-        assigns_in_templates == true || assigns_in_templates == :ivars
+        [true, :ivars].include?(assigns_in_templates)
       end
 
       # Cache eager_load_paths now, otherwise the assets dir is added
@@ -25,11 +27,8 @@ module Opal
       config.eager_load_paths
 
       config.before_initialize do |app|
-        app.config.eager_load_paths = app.config.eager_load_paths.dup - Dir["#{app.root}/app/{assets,views}"]
-      end
-
-      initializer 'opal.append_assets_path', after: :append_assets_path, group: :all do |app|
-        app.config.assets.paths.unshift(*Opal.paths)
+        Opal::Rails::LegacyUpgradeWarning.warn_if_needed(app)
+        Opal::Rails::PathSetup.apply!(app)
       end
 
       config.after_initialize do |app|
@@ -43,6 +42,9 @@ module Opal
         end
       end
 
+      rake_tasks do
+        load File.expand_path('../../tasks/opal.rake', __dir__)
+      end
     end
   end
 end

data/lib/opal/rails/entrypoints_resolver.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Opal
+  module Rails
+    class EntrypointsResolver
+      def initialize(entrypoints_path:, entrypoints:)
+        @entrypoints_path = Pathname(entrypoints_path).expand_path
+        @entrypoints = entrypoints
+      end
+
+      def resolve
+        case entrypoints
+        when Hash
+          resolve_hash
+        when :all
+          resolve_all
+        else
+          raise InvalidEntrypointsConfigError,
+                "config.opal.entrypoints must be a Hash or :all, got #{entrypoints.inspect}"
+        end
+      end
+
+      private
+
+      attr_reader :entrypoints_path, :entrypoints
+
+      def resolve_hash
+        resolved = {}
+
+        unless entrypoints_path.directory?
+          raise MissingEntrypointError,
+                "Opal entrypoints_path #{entrypoints_path} does not exist"
+        end
+
+        entrypoints.each_pair do |logical_name, relative_source_file|
+          logical_name = logical_name.to_s
+          relative_source_file = relative_source_file.to_s
+          absolute_source_file = entrypoints_path.join(relative_source_file)
+
+          unless absolute_source_file.file?
+            raise MissingEntrypointError,
+                  "configured Opal entrypoint #{relative_source_file.inspect} was not found under #{entrypoints_path}"
+          end
+
+          if resolved.key?(logical_name)
+            raise DuplicateEntrypointError,
+                  "duplicate Opal logical entrypoint #{logical_name.inspect}"
+          end
+
+          resolved[logical_name] = relative_source_file
+        end
+
+        resolved
+      end
+
+      def resolve_all
+        unless entrypoints_path.directory?
+          raise MissingEntrypointError,
+                "Opal entrypoints_path #{entrypoints_path} does not exist"
+        end
+
+        entrypoints_path.children
+                        .select(&:file?)
+                        .select { |path| path.extname == '.rb' }
+                        .sort_by { |path| path.basename.to_s }
+                        .each_with_object({}) do |path, resolved|
+          logical_name = path.basename('.rb').to_s
+
+          if resolved.key?(logical_name)
+            raise DuplicateEntrypointError,
+                  "duplicate Opal logical entrypoint #{logical_name.inspect}"
+          end
+
+          resolved[logical_name] = path.basename.to_s
+        end
+      end
+    end
+  end
+end

data/lib/opal/rails/errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Opal
+  module Rails
+    class Error < StandardError; end
+
+    class MissingEntrypointError < Error; end
+    class DuplicateEntrypointError < Error; end
+    class InvalidEntrypointsConfigError < Error; end
+  end
+end

data/lib/opal/rails/file_watcher.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Opal
+  module Rails
+    class FileWatcher
+      def initialize(files:, extra_directories: [], &callback)
+        @files = normalize_paths(files)
+        @extra_directories = normalize_paths(extra_directories)
+        @callback = callback
+      end
+
+      def start
+        require 'listen'
+
+        @listener = Listen.to(*directories) do |modified, added, removed|
+          callback.call(
+            modified: normalize_paths(modified),
+            added: normalize_paths(added),
+            removed: normalize_paths(removed)
+          )
+        end
+        @listener.start
+      rescue LoadError
+        raise Error, 'opal:watch requires the listen gem'
+      end
+
+      def stop
+        @listener&.stop
+      end
+
+      private
+
+      attr_reader :callback, :extra_directories, :files
+
+      def directories
+        dirs = files.map { |file| File.directory?(file) ? file : File.dirname(file) }
+        collapse_directories((dirs + extra_directories).uniq.sort)
+      end
+
+      def collapse_directories(directories)
+        previous_dir = nil
+
+        directories.each_with_object([]) do |dir, collapsed|
+          next if previous_dir && dir.start_with?(previous_dir + File::SEPARATOR)
+
+          collapsed << dir
+          previous_dir = dir
+        end
+      end
+
+      def normalize_paths(paths)
+        Array(paths).map { |path| Pathname(path).expand_path.to_s }.uniq.sort
+      end
+    end
+  end
+end

data/lib/opal/rails/haml6_filter.rb

@@ -1,22 +1,22 @@
-require "haml"
-require "haml/filters"
-require "haml/filters/base"
+require 'haml'
+require 'haml/filters'
+require 'haml/filters/base'
 
 module Haml
   class Filters
     class Opal < Base
       def mime_type
+        ::Opal::Config.esm ? 'module' : 'text/javascript'
       end
-      
+
       def compile(node)
         template = [:multi]
         template << [:static, "<script type='#{mime_type}'>\n"]
-        template << [:static, ::Opal.compile(node.value[:text]) ]
+        template << [:static, ::Opal.compile(node.value[:text])]
         template << [:static, "\n</script>"]
         template
       end
     end
-    ::Opal::Config.esm ? 'module' : 'text/javascript'
   end
 end
 

data/lib/opal/rails/haml_filter.rb

@@ -1,9 +1,6 @@
+require 'opal'
 require 'haml'
 
-haml_version = Haml::VERSION.to_i
+raise LoadError, 'opal-rails requires Haml 6 or newer for the :opal filter' if Haml::VERSION.to_i < 6
 
-if haml_version < 6
-  require 'opal/rails/haml5_filter'
-else
-  require 'opal/rails/haml6_filter'
-end
+require 'opal/rails/haml6_filter'

data/lib/opal/rails/legacy_upgrade_warning.rb

@@ -0,0 +1,95 @@
+module Opal
+  module Rails
+    module LegacyUpgradeWarning
+      module_function
+
+      LEGACY_OPAL_CONFIG_KEYS = %w[
+        method_missing_enabled
+        const_missing_enabled
+        arity_check_enabled
+        freezing_stubs_enabled
+        missing_require_severity
+      ].freeze
+
+      BUILD_CONFIG_KEYS = %w[
+        source_path
+        entrypoints_path
+        build_path
+        entrypoints
+      ].freeze
+
+      def warn_if_needed(app, output: $stderr)
+        return false if suppress_warning?(app)
+
+        warning = warning_for(app.root)
+        return false unless warning
+
+        output.puts(warning)
+        true
+      end
+
+      def warning_for(root)
+        signals = legacy_signals(root)
+        return if signals.empty?
+
+        <<~WARNING
+          WARNING: opal-rails detected a likely 2.x application layout that has not been ported to the 3.x build pipeline yet.
+
+          This app may fail after upgrade with missing `app/opal` entrypoints or missing `application.js` assets.
+          Pin `opal-rails` to the 2.0 series until the app can be ported, or follow `PORTING.md` before continuing.
+          If you have already ported the app and want to silence this check, set `config.opal.suppress_legacy_upgrade_warning = true`.
+
+          Detected legacy signals:
+          #{signals.map { |signal| "- #{signal}" }.join("\n")}
+        WARNING
+      end
+
+      def suppress_warning?(app)
+        return false unless app.respond_to?(:config)
+
+        app.config.respond_to?(:opal) && app.config.opal.suppress_legacy_upgrade_warning
+      end
+
+      def legacy_signals(root)
+        root = Pathname(root)
+        signals = []
+
+        initializer = root.join('config/initializers/opal.rb')
+        initializer_body = initializer.exist? ? initializer.read : nil
+
+        if legacy_initializer?(initializer_body)
+          signals << 'config/initializers/opal.rb still uses legacy 2.x runtime settings'
+        end
+
+        legacy_entrypoints(root).each do |entrypoint|
+          signals << "legacy Opal asset entrypoint present at #{relative_to_root(entrypoint, root)}"
+        end
+
+        manifest = root.join('app/assets/config/manifest.js')
+        if manifest.exist? && manifest.read.match?(%r{link_(?:tree|directory)\s+\.\./javascript\b})
+          signals << 'app/assets/config/manifest.js still links the legacy javascript asset tree'
+        end
+
+        return [] unless initializer_body && signals.length >= 2
+        return signals if root.join('app/opal').directory?
+
+        signals << 'expected 3.x source root app/opal is missing'
+      end
+
+      def legacy_initializer?(initializer_body)
+        return false unless initializer_body
+        return false if BUILD_CONFIG_KEYS.any? { |key| initializer_body.include?("config.opal.#{key}") }
+
+        LEGACY_OPAL_CONFIG_KEYS.any? { |key| initializer_body.include?("config.opal.#{key}") }
+      end
+
+      def legacy_entrypoints(root)
+        Dir[root.join('app/assets/{javascript,javascripts}/**/*.js.rb').to_s].sort.map { |path| Pathname(path) }
+      end
+
+      def relative_to_root(path, root)
+        path.relative_path_from(root).to_s
+      end
+    end
+  end
+end