opal-vite-rails 0.3.12 → 0.3.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 810c47fa4b67b501e83a0be79ea5f983d5955d90e912ecc0f04ac1ed06021775
-  data.tar.gz: 12fe595103f3c4ddea6ce2e809066792871581301372d8c464a5b1b9afb04595
+  metadata.gz: 5ef10da23927e3793b0aa7d4730e9007800bf70ab430b05ee9ddc550a81af197
+  data.tar.gz: d06c1b304ebf7e7985b74d89f352fa0ec6f08edba9a0726ed1a407733329bd02
 SHA512:
-  metadata.gz: 11400a07df86c8c2c71242e992706ec3c5f42d0a58db8eea68dd80a50716794861d0c44d014022efb0664dfcecb57b738931a806ab6823ed2093d8c3ed7135b5
-  data.tar.gz: badf7f8a3bceef8ec071dc08e614536f89b19b7a8909ccea65858b25b1f586cf5d2c77a7345d8b676c17bb66b92805f4bba9543937c60fcb0a25a828d7058af5
+  metadata.gz: d8a1992423ad276695e0dfcb021e4b2d6f0109ebc6688b27f13251359eae7d7ccdebd36c832c73e41d3825f30a0bff791a66999d718127558562a52fbaae8223
+  data.tar.gz: d2e47d18cebb49f142b840985e7ff1361b3740c41bdc5002669450d66143f3d587f73fa022aae250127a85f9964ae9a693200a2b0f1f17a25e875eefbd2d5fd6

data/README.md

@@ -37,13 +37,18 @@ Run the generator:
 rails generate opal_vite:install
 ```
 
-This will:
-- Create `app/opal/` directory for your Ruby code
-- Generate `app/opal/application.rb` entry point
+This will (paths assume vite_ruby's default `sourceCodeDir` of `app/frontend`;
+the generator reads `config/vite.json`):
+- Generate `app/frontend/opal/application.rb`, the Ruby entry point
+- Generate `app/frontend/entrypoints/opal.js`, the Vite entrypoint that imports it
 - Configure Vite with the Opal plugin
-- Create an example controller and view
+- Create an example controller and view (`/opal_demo`)
 - Add necessary routes
 
+The engine tells Zeitwerk to ignore the Opal source directories
+(`config.opal_vite.source_path`, default `app/opal`, and `<sourceCodeDir>/opal`),
+so the browser-side Ruby is never loaded by the server.
+
 Install JavaScript dependencies:
 
 ```bash
@@ -72,10 +77,16 @@ Visit `http://localhost:3000/opal_demo` to see Opal in action!
 
 ### Writing Opal Code
 
-Create Ruby files in `app/opal/`:
+Create Ruby files in `app/frontend/opal/` and import them from an entrypoint
+in `app/frontend/entrypoints/`:
+
+```js
+// app/frontend/entrypoints/hello.js
+import '../opal/hello.rb'
+```
 
 ```ruby
-# app/opal/hello.rb
+# app/frontend/opal/hello.rb
 require 'native'
 
 puts "Hello from Ruby running in the browser!"
@@ -117,9 +128,12 @@ Add Opal JavaScript to your views with the helper:
 <%= opal_javascript_tag "hello" %>
 ```
 
-The helper automatically handles development vs production modes:
-- **Development**: Loads from Vite dev server with HMR
-- **Production**: Loads precompiled assets from manifest
+`opal_javascript_tag "hello"` is `vite_javascript_tag "hello.js"`, so it
+emits `type="module"` and switches between the Vite dev server and the build
+manifest the same way.
+
+The Opal runtime is imported by the compiled Ruby itself; you don't need a
+separate tag or `import '/@opal-runtime'` for it.
 
 ### View Helpers
 
@@ -130,9 +144,12 @@ Loads an Opal JavaScript bundle:
 ```erb
 <%= opal_javascript_tag "application" %>
 <%= opal_javascript_tag "application", defer: true %>
-<%= opal_javascript_tag "application", type: "module" %>
 ```
 
+#### `opal_runtime_tag` (deprecated)
+
+Outputs nothing. The runtime is loaded by the compiled `.rb` modules.
+
 #### `opal_asset_path`
 
 Gets the path to an Opal asset:
@@ -158,14 +175,14 @@ Checks if Vite dev server is running:
 Organize your code with `require`:
 
 ```ruby
-# app/opal/lib/calculator.rb
+# app/frontend/opal/lib/calculator.rb
 class Calculator
   def add(a, b)
     a + b
   end
 end
 
-# app/opal/application.rb
+# app/frontend/opal/application.rb
 require 'lib/calculator'
 
 calc = Calculator.new
@@ -211,15 +228,18 @@ config.opal_vite.public_output_path = "vite"  # Default
 
 ```
 app/
-├── opal/
-│   ├── application.rb          # Entry point
-│   ├── application_loader.js   # JS loader (required for Vite)
-│   └── lib/
-│       └── my_module.rb        # Your Ruby modules
+├── frontend/                   # vite_ruby sourceCodeDir
+│   ├── entrypoints/
+│   │   ├── application.js      # Created by `vite install`
+│   │   └── opal.js             # Imports ../opal/application.rb
+│   └── opal/
+│       ├── application.rb      # Ruby entry point
+│       └── lib/
+│           └── my_module.rb    # Your Ruby modules
 ├── controllers/
 └── views/
 
-vite.config.ts                   # Vite config with opal plugin
+vite.config.ts                  # Vite config with the opal plugin
 ```
 
 ## How It Works
@@ -243,14 +263,14 @@ Customize `vite.config.ts`:
 
 ```typescript
 import { defineConfig } from 'vite'
-import RubyPlugin from 'vite_ruby/plugins/ruby'
+import RubyPlugin from 'vite-plugin-ruby'
 import opal from 'vite-plugin-opal'
 
 export default defineConfig({
   plugins: [
     RubyPlugin(),
     opal({
-      loadPaths: ['./app/opal', './lib/opal'],
+      loadPaths: ['./app/frontend/opal', './lib/opal'],
       sourceMap: true,
       debug: process.env.NODE_ENV === 'development'
     })
@@ -278,7 +298,7 @@ require 'ostruct'     # OpenStruct
 
 Make sure:
 1. Vite dev server is running (`bin/vite dev`)
-2. You're using the JavaScript loader pattern (`.rb` files imported via `.js` loaders)
+2. The `.rb` file is imported from a file in `entrypoints/` (directly or via other imports)
 3. Rails is configured to proxy to Vite in development
 
 ### Assets not loading in production
@@ -300,6 +320,16 @@ opal({
 })
 ```
 
+## Version Compatibility
+
+The npm plugin runs the gem's Ruby code, so keep the two in step:
+
+| vite-plugin-opal (npm) | opal-vite (gem) | opal-vite-rails (gem) | Notes |
+|------------------------|-----------------|-----------------------|-------|
+| >= 0.3.16 | >= 0.3.15 | >= 0.3.14 | Shared runtime: corelib is loaded once |
+| >= 0.3.16 | 0.3.12 – 0.3.14 | — | Works; each `.rb` bundle carries its own corelib (warning at startup) |
+| >= 0.3.16 | < 0.3.12 | — | Works without the `stubs` option (using it fails with a clear error) |
+
 ## Examples
 
 See the [examples/rails-app](../../examples/rails-app) directory for a complete working example.

data/lib/opal/vite/rails/engine.rb

@@ -20,6 +20,22 @@ module Opal
 
         end
 
+        # app/* subdirectories are Zeitwerk roots, so without this the Opal
+        # sources (browser code) would be eager loaded by MRI in production
+        # and fail with LoadError on `require 'native'` etc.
+        initializer "opal_vite.ignore_opal_sources" do |app|
+          opal_dirs = [
+            ::Rails.root.join(app.config.opal_vite.source_path || Opal::Vite::Rails.config.source_path)
+          ]
+          if defined?(ViteRuby)
+            opal_dirs << ViteRuby.config.root.join(ViteRuby.config.source_code_dir, "opal")
+          end
+
+          ::Rails.autoloaders.each do |autoloader|
+            opal_dirs.uniq.each { |dir| autoloader.ignore(dir) }
+          end
+        end
+
         initializer "opal_vite.view_helpers" do
           ActiveSupport.on_load(:action_view) do
             include Opal::Vite::Rails::Helper

data/lib/opal/vite/rails/generators/install_generator.rb

@@ -1,4 +1,6 @@
 require "rails/generators/base"
+require "json"
+require "pathname"
 
 module Opal
   module Vite
@@ -7,6 +9,8 @@ module Opal
         class InstallGenerator < ::Rails::Generators::Base
           source_root File.expand_path("../../../../../templates", __dir__)
 
+          namespace "opal_vite:install"
+
           desc "Install Opal-Vite in your Rails application"
 
           def check_vite_rails
@@ -17,24 +21,27 @@ module Opal
             end
           end
 
-          def create_opal_directory
-            empty_directory "app/opal"
-            create_file "app/opal/.keep"
+          # Opal sources live under vite_ruby's sourceCodeDir so that the Vite
+          # dev server and autoBuild watch them like any other frontend file.
+          def create_application_rb
+            template "application.rb.tt", File.join(opal_dir, "application.rb")
           end
 
-          def create_application_rb
-            template "application.rb.tt", "app/opal/application.rb"
+          # An entrypoint is what puts the Ruby code into a Vite bundle; without
+          # it application.rb is never compiled.
+          def create_entrypoint
+            template "opal_entrypoint.js.tt", File.join(entrypoints_dir, "opal.js")
           end
 
           def create_vite_config
-            if File.exist?("vite.config.ts")
+            if File.exist?(File.join(destination_root, "vite.config.ts"))
               inject_into_file "vite.config.ts", after: "import { defineConfig } from 'vite'\n" do
                 "import opal from 'vite-plugin-opal'\n"
               end
 
               inject_into_file "vite.config.ts", after: "plugins: [\n" do
                 "    opal({\n" \
-                "      loadPaths: ['./app/opal'],\n" \
+                "      loadPaths: ['./#{opal_dir}'],\n" \
                 "      sourceMap: true\n" \
                 "    }),\n"
               end
@@ -58,7 +65,7 @@ module Opal
                 <p>Check your browser console to see Opal output!</p>
               </div>
 
-              <%= opal_javascript_tag "application" %>
+              <%= opal_javascript_tag "opal" %>
             ERB
           end
 
@@ -90,6 +97,43 @@ module Opal
             say "     http://localhost:3000/opal_demo"
             say "\n" + "="*60, :green
           end
+
+          private
+
+          def source_code_dir
+            vite_config_value(:source_code_dir, "sourceCodeDir", "app/frontend")
+          end
+
+          def entrypoints_dir
+            File.join(source_code_dir, vite_config_value(:entrypoints_dir, "entrypointsDir", "entrypoints"))
+          end
+
+          def opal_dir
+            File.join(source_code_dir, "opal")
+          end
+
+          # Path of application.rb as imported from the entrypoint
+          def opal_import_path
+            path = Pathname.new(File.join(opal_dir, "application.rb"))
+              .relative_path_from(Pathname.new(entrypoints_dir)).to_s
+            path.start_with?(".") ? path : "./#{path}"
+          end
+
+          # Read a vite_ruby setting, falling back to config/vite.json (vite_rails
+          # may have been installed by this generator in a separate process) and
+          # then to vite_ruby's default.
+          def vite_config_value(method, json_key, default)
+            return ViteRuby.config.public_send(method).to_s if defined?(ViteRuby)
+
+            vite_json.dig("all", json_key) || default
+          end
+
+          def vite_json
+            @vite_json ||= begin
+              path = File.join(destination_root, "config", "vite.json")
+              File.exist?(path) ? JSON.parse(File.read(path)) : {}
+            end
+          end
         end
       end
     end

data/lib/opal/vite/rails/helper.rb

@@ -2,20 +2,17 @@ module Opal
   module Vite
     module Rails
       module Helper
-        # Generate script tag for Opal JavaScript
+        # Generate script tag for an entrypoint that loads Opal code
         #
         # Usage in views:
         #   <%= opal_javascript_tag "application" %>
         #
+        # Delegates to vite_javascript_tag in every environment: Vite emits ES
+        # modules, so the tag must carry type="module" (plus crossorigin and
+        # modulepreload links), and vite_ruby already switches between the dev
+        # server and the build manifest.
         def opal_javascript_tag(name, **options)
-          if vite_running?
-            # Development: load from Vite dev server
-            vite_javascript_tag("#{name}.js", **options)
-          else
-            # Production: load from manifest
-            asset_path = opal_asset_path("#{name}.js")
-            javascript_include_tag(asset_path, **options)
-          end
+          vite_javascript_tag("#{name}.js", **options)
         end
 
         # Generate multiple script tags for Opal JavaScript files
@@ -33,25 +30,34 @@ module Opal
         end
 
         # Get asset path from Vite manifest
+        #
+        # NOTE: the manifest lives on the ViteRuby *instance* — `ViteRuby.manifest`
+        # is not a class-level delegator (it raises NoMethodError), so we go
+        # through `ViteRuby.instance`. Use ViteRuby::Manifest#path_for (public)
+        # rather than #lookup: #lookup is *protected* and returns the raw manifest
+        # entry Hash ({ "file" => "..." }), so `lookup(name).to_s` would emit the
+        # Hash's inspect string instead of a URL. #path_for returns the resolved
+        # asset URL string.
         def opal_asset_path(name)
           if defined?(ViteRuby)
-            ViteRuby.manifest.lookup(name).to_s
+            ViteRuby.instance.manifest.path_for(name)
           else
             # Fallback to standard asset path
             "/#{Opal::Vite::Rails.config.public_output_path}/#{name}"
           end
         end
 
-        # Include Opal runtime
-        # This is automatically included when using opal_javascript_tag,
-        # but can be called explicitly if needed
-        def opal_runtime_tag(**options)
-          if vite_running?
-            vite_javascript_tag("@opal-runtime", **options)
-          else
-            asset_path = opal_asset_path("opal-runtime.js")
-            javascript_include_tag(asset_path, **options)
-          end
+        # Deprecated: outputs nothing.
+        #
+        # Compiled .rb modules import the Opal runtime (`/@opal-runtime`)
+        # themselves, and in production it is bundled into the entrypoint's
+        # chunks, so there is no separate runtime file to load. A standalone
+        # tag would load a second copy of the runtime in development.
+        def opal_runtime_tag(**_options)
+          ActiveSupport::Deprecation.new("0.4", "opal-vite-rails").warn(
+            "opal_runtime_tag is no longer needed and outputs nothing; remove it from your views."
+          )
+          "".html_safe
         end
       end
     end

data/lib/opal/vite/rails/version.rb

@@ -1,7 +1,7 @@
 module Opal
   module Vite
     module Rails
-      VERSION = "0.3.12"
+      VERSION = "0.3.14"
     end
   end
 end

data/templates/opal_entrypoint.js.tt

@@ -0,0 +1,6 @@
+// Vite entrypoint for the Opal application.
+// Load it in a view with: <%%= opal_javascript_tag "opal" %>
+//
+// The compiled Ruby imports the Opal runtime itself, so nothing else is
+// needed here.
+import '<%= opal_import_path %>'

data/templates/vite.config.ts.tt

@@ -1,22 +1,13 @@
 import { defineConfig } from 'vite'
-import RubyPlugin from 'vite_ruby/plugins/ruby'
+import RubyPlugin from 'vite-plugin-ruby'
 import opal from 'vite-plugin-opal'
 
 export default defineConfig({
   plugins: [
     RubyPlugin(),
     opal({
-      loadPaths: ['./app/opal'],
-      sourceMap: true,
-      debug: process.env.NODE_ENV === 'development'
+      loadPaths: ['./<%= opal_dir %>'],
+      sourceMap: true
     })
-  ],
-  build: {
-    manifest: true,
-    rollupOptions: {
-      input: {
-        'application': './app/opal/application_loader.js'
-      }
-    }
-  }
+  ]
 })

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opal-vite-rails
 version: !ruby/object:Gem::Version
-  version: 0.3.12
+  version: 0.3.14
 platform: ruby
 authors:
 - stofu1234
@@ -16,6 +16,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.15
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -23,6 +26,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.15
 - !ruby/object:Gem::Dependency
   name: ostruct
   requirement: !ruby/object:Gem::Requirement
@@ -138,7 +144,7 @@ files:
 - lib/opal/vite/rails/version.rb
 - lib/tasks/opal_vite.rake
 - templates/application.rb.tt
-- templates/application_loader.js.tt
+- templates/opal_entrypoint.js.tt
 - templates/vite.config.ts.tt
 homepage: https://stofu1234.github.io/opal-vite/
 licenses:

data/templates/application_loader.js.tt

@@ -1,4 +0,0 @@
-// Loader for Opal application
-// This file imports the Ruby code so Vite can process it
-
-import './application.rb'