opal-rails 2.0.3 → 3.0.0

data/spec/opal/rails/watch_runner_spec.rb

@@ -0,0 +1,283 @@
+require 'spec_helper'
+require 'opal/rails/file_watcher'
+require 'opal/rails/watch_runner'
+
+RSpec.describe Opal::Rails::WatchRunner do
+  FakeBuilderRunner = Struct.new(:results, :calls) do
+    def build(entrypoints:)
+      calls << entrypoints
+      results.shift
+    end
+  end
+
+  FakeManifest = Struct.new(:prune_calls, :write_calls) do
+    def prune_stale!(outputs)
+      prune_calls << outputs
+    end
+
+    def write!(outputs)
+      write_calls << outputs
+    end
+  end
+
+  class FakeFileWatcher
+    class << self
+      attr_accessor :instances
+    end
+
+    self.instances = []
+
+    attr_reader :extra_directories, :files
+
+    def initialize(files:, extra_directories:, &callback)
+      @files = files
+      @extra_directories = extra_directories
+      @callback = callback
+      @started = false
+      @stopped = false
+      self.class.instances << self
+    end
+
+    def start
+      @started = true
+    end
+
+    def stop
+      @stopped = true
+    end
+
+    def started?
+      @started
+    end
+
+    def stopped?
+      @stopped
+    end
+  end
+
+  let(:source_path) { Pathname('/tmp/app/opal') }
+  let(:append_path) { Pathname('/tmp/app/shared/opal') }
+  let(:config) do
+    ActiveSupport::OrderedOptions.new.tap do |opal|
+      opal.source_path = source_path
+      opal.entrypoints_path = source_path
+      opal.build_path = Pathname('/tmp/app/assets/builds')
+      opal.entrypoints = { 'application' => 'application.rb', 'admin' => 'admin.rb' }
+      opal.append_paths = [append_path]
+      opal.source_map_enabled = true
+    end
+  end
+  let(:resolver) { instance_double(Opal::Rails::EntrypointsResolver) }
+  let(:manifest) { FakeManifest.new([], []) }
+  let(:builder_runner) { FakeBuilderRunner.new(results.dup, []) }
+  let(:results) do
+    [
+      {
+        outputs: %w[application.js application.js.map admin.js admin.js.map],
+        dependencies: {
+          'application' => ['/tmp/app/opal/application.rb', '/tmp/app/opal/shared.rb'],
+          'admin' => ['/tmp/app/opal/admin.rb']
+        }
+      },
+      {
+        outputs: %w[application.js application.js.map],
+        dependencies: {
+          'application' => ['/tmp/app/opal/application.rb', '/tmp/app/opal/shared.rb']
+        }
+      },
+      {
+        outputs: %w[application.js application.js.map admin.js admin.js.map],
+        dependencies: {
+          'application' => ['/tmp/app/opal/application.rb', '/tmp/app/opal/shared.rb', '/tmp/app/opal/new_file.rb'],
+          'admin' => ['/tmp/app/opal/admin.rb']
+        }
+      }
+    ]
+  end
+
+  before do
+    FakeFileWatcher.instances = []
+    allow(resolver).to receive(:resolve).and_return(
+      { 'application' => 'application.rb', 'admin' => 'admin.rb' },
+      { 'application' => 'application.rb', 'admin' => 'admin.rb' }
+    )
+    allow(Opal).to receive(:dependent_files).and_return(['/tmp/opal/corelib/runtime.rb'])
+  end
+
+  it 'builds all entrypoints once and starts a watcher' do
+    runner = described_class.new(
+      config: config,
+      resolver: resolver,
+      builder_runner: builder_runner,
+      manifest: manifest,
+      file_watcher_class: FakeFileWatcher
+    )
+
+    runner.start!
+
+    expect(builder_runner.calls).to eq([
+                                         { 'application' => 'application.rb', 'admin' => 'admin.rb' }
+                                       ])
+    expect(manifest.prune_calls).to eq([
+                                         %w[admin.js admin.js.map application.js application.js.map]
+                                       ])
+    expect(manifest.write_calls).to eq([
+                                         %w[admin.js admin.js.map application.js application.js.map]
+                                       ])
+    expect(FakeFileWatcher.instances.last).to be_started
+    expect(FakeFileWatcher.instances.last.extra_directories).to eq([
+                                                                     source_path.expand_path.to_s,
+                                                                     append_path.expand_path.to_s
+                                                                   ])
+  end
+
+  it 'rebuilds only affected entrypoints for known modified files' do
+    runner = described_class.new(
+      config: config,
+      resolver: resolver,
+      builder_runner: builder_runner,
+      manifest: manifest,
+      file_watcher_class: FakeFileWatcher
+    )
+
+    runner.start!
+    runner.process_changes(modified: ['/tmp/app/opal/shared.rb'], added: [], removed: [])
+
+    expect(builder_runner.calls).to eq([
+                                         { 'application' => 'application.rb', 'admin' => 'admin.rb' },
+                                         { 'application' => 'application.rb' }
+                                       ])
+    expect(manifest.prune_calls.length).to eq(1)
+    expect(manifest.write_calls.last).to eq(%w[admin.js admin.js.map application.js application.js.map])
+  end
+
+  it 'rebuilds all entrypoints when a new file appears' do
+    runner = described_class.new(
+      config: config,
+      resolver: resolver,
+      builder_runner: builder_runner,
+      manifest: manifest,
+      file_watcher_class: FakeFileWatcher
+    )
+
+    runner.start!
+    runner.process_changes(modified: [], added: ['/tmp/app/opal/new_file.rb'], removed: [])
+
+    expect(builder_runner.calls).to eq([
+                                         { 'application' => 'application.rb', 'admin' => 'admin.rb' },
+                                         { 'application' => 'application.rb', 'admin' => 'admin.rb' }
+                                       ])
+    expect(manifest.prune_calls.length).to eq(2)
+  end
+
+  it 'watches configured append_paths for rebuild-triggering changes' do
+    runner = described_class.new(
+      config: config,
+      resolver: resolver,
+      builder_runner: builder_runner,
+      manifest: manifest,
+      file_watcher_class: FakeFileWatcher
+    )
+
+    runner.start!
+    runner.process_changes(modified: [], added: ['/tmp/app/shared/opal/new_helper.rb'], removed: [])
+
+    expect(builder_runner.calls).to eq([
+                                         { 'application' => 'application.rb', 'admin' => 'admin.rb' },
+                                         { 'application' => 'application.rb', 'admin' => 'admin.rb' }
+                                       ])
+  end
+
+  it 're-resolves :all entrypoints and watches the dedicated entrypoints path' do
+    all_config = ActiveSupport::OrderedOptions.new.tap do |opal|
+      opal.source_path = Pathname('/tmp/app/opal')
+      opal.entrypoints_path = Pathname('/tmp/app/opal/entrypoints')
+      opal.build_path = Pathname('/tmp/app/assets/builds')
+      opal.entrypoints = :all
+      opal.append_paths = []
+      opal.source_map_enabled = true
+    end
+
+    all_resolver = instance_double(Opal::Rails::EntrypointsResolver)
+    allow(all_resolver).to receive(:resolve).and_return(
+      { 'application' => 'application.rb' },
+      { 'application' => 'application.rb', 'dashboard' => 'dashboard.rb' }
+    )
+
+    all_builder_runner = FakeBuilderRunner.new(
+      [
+        {
+          outputs: %w[application.js application.js.map],
+          dependencies: {
+            'application' => ['/tmp/app/opal/entrypoints/application.rb', '/tmp/app/opal/shared.rb']
+          }
+        },
+        {
+          outputs: %w[application.js application.js.map dashboard.js dashboard.js.map],
+          dependencies: {
+            'application' => ['/tmp/app/opal/entrypoints/application.rb', '/tmp/app/opal/shared.rb'],
+            'dashboard' => ['/tmp/app/opal/entrypoints/dashboard.rb']
+          }
+        }
+      ],
+      []
+    )
+
+    all_manifest = FakeManifest.new([], [])
+
+    runner = described_class.new(
+      config: all_config,
+      resolver: all_resolver,
+      builder_runner: all_builder_runner,
+      manifest: all_manifest,
+      file_watcher_class: FakeFileWatcher
+    )
+
+    runner.start!
+    expect(FakeFileWatcher.instances.last.extra_directories).to eq([
+                                                                     '/tmp/app/opal',
+                                                                     '/tmp/app/opal/entrypoints'
+                                                                   ])
+
+    runner.process_changes(modified: [], added: ['/tmp/app/opal/entrypoints/dashboard.rb'], removed: [])
+
+    expect(all_builder_runner.calls).to eq([
+                                             { 'application' => 'application.rb' },
+                                             { 'application' => 'application.rb', 'dashboard' => 'dashboard.rb' }
+                                           ])
+    expect(all_manifest.prune_calls).to eq([
+                                             %w[application.js application.js.map],
+                                             %w[application.js application.js.map dashboard.js dashboard.js.map]
+                                           ])
+    expect(all_manifest.write_calls.last).to eq(%w[application.js application.js.map dashboard.js dashboard.js.map])
+  end
+
+  it 'reports build errors without crashing the watcher' do
+    error_output = StringIO.new
+
+    failing_builder = FakeBuilderRunner.new(
+      [
+        results.first.dup,
+        nil # will not be reached; the second build raises
+      ],
+      []
+    )
+    allow(failing_builder).to receive(:build).and_call_original
+    allow(failing_builder).to receive(:build).with(entrypoints: { 'application' => 'application.rb' })
+                                             .and_raise(StandardError, 'syntax error in application.rb')
+
+    runner = described_class.new(
+      config: config,
+      resolver: resolver,
+      builder_runner: failing_builder,
+      manifest: manifest,
+      file_watcher_class: FakeFileWatcher,
+      error_output: error_output
+    )
+
+    runner.start!
+    expect { runner.process_changes(modified: ['/tmp/app/opal/shared.rb'], added: [], removed: []) }.not_to raise_error
+    expect(error_output.string).to include('Opal build error: syntax error in application.rb')
+    expect(FakeFileWatcher.instances.last).to be_started
+  end
+end

data/spec/opal/rails/watch_task_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'rake'
+require 'opal/rails/file_watcher'
+require 'opal/rails/watch_runner'
+
+RSpec.describe 'opal:watch task' do
+  before do
+    Rake.application = Rake::Application.new
+    Rails.application.load_tasks
+  end
+
+  after do
+    Rake.application = nil
+  end
+
+  it 'delegates to the watch runner' do
+    runner = instance_double(Opal::Rails::WatchRunner, watch: true)
+    expect(Opal::Rails::WatchRunner).to receive(:new).with(config: Rails.application.config.opal).at_least(:once).and_return(runner)
+
+    Rake::Task['opal:watch'].reenable
+    Rake::Task['opal:watch'].invoke
+  end
+end

data/spec/spec_helper.rb

@@ -1,4 +1,4 @@
-root_dir = File.expand_path('../../', __FILE__)
+File.expand_path('..', __dir__)
 
 require 'support/test_app'
 require 'rspec/rails'
@@ -38,7 +38,7 @@ RSpec.configure do |config|
     # ...rather than:
     #   # => "be bigger than 2"
     expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-    expectations.syntax = [:expect, :should]
+    expectations.syntax = %i[expect should]
   end
 
   # rspec-mocks config goes here. You can use an alternate test double
@@ -98,19 +98,28 @@ RSpec.configure do |config|
   # Configure Capybara
   Capybara.javascript_driver = :cuprite
   Capybara.register_driver(:cuprite) do |app|
-    Capybara::Cuprite::Driver.new(app,
+    driver_options = {
       window_size: [1200, 800],
-      browser_options: { 'no-sandbox': nil },
+      browser_options: {
+        'disable-dev-shm-usage': nil,
+        'no-sandbox': nil
+      },
       inspector: ENV['INSPECTOR'],
       headless: !ENV['NO_HEADLESS'],
+      process_timeout: 30,
       timeout: 20,
-      url_blacklist: [],
-    )
+      url_blacklist: []
+    }
+
+    browser_path = BrowserSupport.path
+    driver_options[:browser_path] = browser_path if browser_path
+
+    Capybara::Cuprite::Driver.new(app, **driver_options)
   end
 
   Capybara.register_server :puma do |app, port, host|
     require 'rack/handler/puma'
-    Rack::Handler::Puma.run(app, Host: host, Port: port, Threads: "0:4", Silent: true)
+    Rack::Handler::Puma.run(app, Host: host, Port: port, Threads: '0:4', Silent: true)
   end
 
   Capybara.default_max_wait_time = 5

data/spec/support/browser_support_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+RSpec.describe BrowserSupport do
+  describe '.path' do
+    it 'prefers an executable BROWSER_PATH override' do
+      allow(ENV).to receive(:[]).and_call_original
+      allow(ENV).to receive(:[]).with('BROWSER_PATH').and_return('/custom/browser')
+      allow(File).to receive(:executable?).and_call_original
+      allow(File).to receive(:executable?).with('/custom/browser').and_return(true)
+
+      expect(described_class.path).to eq('/custom/browser')
+    end
+
+    it 'falls back to known absolute browser paths' do
+      stub_const('BrowserSupport::ABSOLUTE_BROWSER_CANDIDATES', ['/custom/headless_shell'])
+      allow(ENV).to receive(:[]).and_call_original
+      allow(ENV).to receive(:[]).with('BROWSER_PATH').and_return(nil)
+      allow(ENV).to receive(:fetch).and_call_original
+      allow(ENV).to receive(:fetch).with('PATH', '').and_return('')
+      allow(File).to receive(:executable?).and_call_original
+      allow(File).to receive(:executable?).with('/custom/headless_shell').and_return(true)
+
+      expect(described_class.path).to eq('/custom/headless_shell')
+    end
+  end
+
+  describe '.available?' do
+    it 'reflects whether a browser path was found' do
+      allow(described_class).to receive(:path).and_return('/custom/browser')
+      expect(described_class.available?).to eq(true)
+
+      allow(described_class).to receive(:path).and_return(nil)
+      expect(described_class.available?).to eq(false)
+    end
+  end
+end

data/spec/support/capybara.rb

@@ -1,6 +1,50 @@
 require 'capybara/rspec'
 require 'capybara/cuprite'
 
+module BrowserSupport
+  BROWSER_CANDIDATES = %w[
+    chromium
+    chromium-browser
+    google-chrome
+    google-chrome-stable
+    chrome
+    headless_shell
+  ].freeze
+
+  ABSOLUTE_BROWSER_CANDIDATES = %w[
+    /usr/lib64/chromium-browser/headless_shell
+    /usr/lib/chromium-browser/headless_shell
+    /usr/lib/chromium/headless_shell
+  ].freeze
+
+  module_function
+
+  def path
+    env_path = ENV['BROWSER_PATH']
+    return env_path if env_path && File.executable?(env_path)
+
+    discovered_path = ENV.fetch('PATH', '').split(File::PATH_SEPARATOR).find do |directory|
+      BROWSER_CANDIDATES.any? do |name|
+        File.executable?(File.join(directory, name))
+      end
+    end
+
+    return File.join(discovered_path, discovered_executable_name(discovered_path)) if discovered_path
+
+    ABSOLUTE_BROWSER_CANDIDATES.find { |candidate| File.executable?(candidate) }
+  end
+
+  def available?
+    !path.nil?
+  end
+
+  def discovered_executable_name(directory)
+    BROWSER_CANDIDATES.find do |name|
+      File.executable?(File.join(directory, name))
+    end
+  end
+end
+
 module OpalHelper
   def compile_opal(code)
     Opal.compile(code, requireable: false)
@@ -32,6 +76,7 @@ module OpalHelper
 
     until evaluate_script('document.readyState') == 'complete'
       raise "reached max time (#{expire_in}s)" if timer.expired?
+
       sleep 0.01
     end
   end
@@ -41,6 +86,7 @@ module OpalHelper
 
     until evaluate_script('!!(window.Opal && window.Opal.gvars.ready)')
       raise "reached max time (#{expire_in}s)" if timer.expired?
+
       sleep 0.01
     end
   end
@@ -52,4 +98,19 @@ end
 
 RSpec.configure do |config|
   config.include OpalHelper
+
+  browser_path = BrowserSupport.path
+
+  config.before(:each, js: true) do
+    skip 'Browser-dependent spec skipped because no browser binary is available' unless BrowserSupport.available?
+  end
+
+  config.before(:suite) do
+    ENV['BROWSER_PATH'] ||= browser_path if browser_path
+  end
+
+  config.append_after(:each, js: true) do
+    session = Capybara.current_session
+    session.driver.restart if session.driver.is_a?(Capybara::Cuprite::Driver)
+  end
 end

data/spec/support/reset_assets_cache.rb

@@ -1,5 +1,13 @@
 require 'fileutils'
 
 RSpec.configure do |config|
-  config.before(:suite) { FileUtils.rmtree(Rails.root.join('tmp/cache/assets').to_s) }
+  config.before(:suite) do
+    FileUtils.rmtree(Rails.root.join('tmp/cache/assets').to_s)
+    TestAppAssets.clobber!
+    TestAppAssets.build!
+  end
+
+  config.after(:suite) do
+    TestAppAssets.clobber!
+  end
 end

data/spec/support/test_app.rb

@@ -1,5 +1,26 @@
+require 'logger'
 require 'rails'
-ENV["RAILS_ENV"] = "test"
+ENV['RAILS_ENV'] = 'test'
 ENV['DATABASE_URL'] = 'sqlite3::memory:'
-require_relative "../../test_apps/rails"
+require_relative '../../test_apps/rails'
 
+module TestAppAssets
+  module_function
+
+  def build!
+    config = Rails.application.config.opal
+    resolved_entrypoints = Opal::Rails::EntrypointsResolver.new(
+      entrypoints_path: config.entrypoints_path,
+      entrypoints: config.entrypoints
+    ).resolve
+
+    result = Opal::Rails::BuilderRunner.new(config: config).build(entrypoints: resolved_entrypoints)
+    manifest = Opal::Rails::OutputsManifest.new(build_path: config.build_path)
+    manifest.prune_stale!(result[:outputs])
+    manifest.write!(result[:outputs])
+  end
+
+  def clobber!
+    Opal::Rails::OutputsManifest.new(build_path: Rails.application.config.opal.build_path).clobber!
+  end
+end

data/test_apps/app/application_controller.rb

@@ -1,61 +1,52 @@
-LAYOUT = <<-HTML
-<!DOCTYPE html>
-<html>
-<head><%= javascript_include_tag "application" %></head>
-<body><%= yield %></body>
-</html>
+LAYOUT = <<~HTML
+  <!DOCTYPE html>
+  <html>
+  <head><%= ActionController::Base.helpers.javascript_include_tag "application" %></head>
+  <body><%= yield %></body>
+  </html>
 HTML
 
-INDEX = <<-HTML
-<script type="text/ruby">
-puts 'hello from a script tag!'
-</script>
+INDEX = <<~HTML
+  <script type="text/ruby">
+  puts 'hello from a script tag!'
+  </script>
 HTML
 
 HAML = <<~HAML
-:opal
-  $haml_filter = :working
+  :opal
+    $haml_filter = :working
 HAML
 
-WITH_ASSIGNMENTS = File.read "#{__dir__}/assets/javascripts/with_assignments.js.rb"
-
-require_relative '../../app/helpers/opal_helper'
+WITH_ASSIGNMENTS = File.read "#{__dir__}/opal/with_assignments.js.rb"
 
 class ApplicationController < ActionController::Base
   include Rails.application.routes.url_helpers
-  helper OpalHelper
   layout 'application'
   self.view_paths = [ActionView::FixtureResolver.new(
-    'layouts/application.html.erb'         => LAYOUT,
-    'application/index.html.erb'           => INDEX,
-    'application/haml_filter.html.haml'    => HAML,
-    'application/with_assignments.js.opal' => WITH_ASSIGNMENTS,
+    'layouts/application.html.erb' => LAYOUT,
+    'application/index.html.erb' => INDEX,
+    'application/haml_filter.html.haml' => HAML,
+    'application/with_assignments.js.opal' => WITH_ASSIGNMENTS
   )]
 
-  def index
-  end
+  def index; end
 
   def with_assignments
     object = Object.new
-    def object.as_json options = {}
-      {contents: 'json representation'}
+    def object.as_json(_options = {})
+      { contents: 'json representation' }
     end
 
     @number_var = 1234
     @string_var = 'hello'
-    @array_var  = [1,'a']
-    @hash_var   = {a: 1, b: 2}
+    @array_var  = [1, 'a']
+    @hash_var   = { a: 1, b: 2 }
     @object_var = object
 
     render type: :js, locals: { local_var: 'i am local' }
   end
 
-  def haml_filter
-  end
+  def haml_filter; end
 end
 
 Rails.logger = Logger.new(STDOUT) if $DEBUG
-
-require 'opal/sprockets/version'
-p rails: Rails.version, opal: Opal::VERSION, ruby: RUBY_VERSION, opal_sprockets: Opal::Sprockets::VERSION
-

data/test_apps/app/assets/config/manifest.js

@@ -1 +1,3 @@
-//= link_directory ../javascripts .js
+//= link_tree ../images
+//= link_directory ../builds .js
+//= link_directory ../builds .map

data/test_apps/app/opal/application.rb

@@ -0,0 +1,5 @@
+# backtick_javascript: true
+
+require 'opal'
+
+`window.opal_loaded = true`

data/test_apps/app/{assets/javascripts/source_map_example.js.rb → opal/source_map_example.rb}

@@ -1,4 +1,3 @@
 class SourceMapExample
-  def works?
-  end
+  def works?; end
 end

data/test_apps/app/opal/with_assignments.js.rb

@@ -0,0 +1,8 @@
+{
+  number_var: @number_var,
+  string_var: @string_var,
+  array_var: @array_var,
+  hash_var: @hash_var,
+  object_var: @object_var,
+  local_var: defined?(local_var) ? local_var : nil
+}.to_json