opal-vite 0.3.19 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecdd0963648ad4f8e23a05841df5bb7f3b8205ad18c54c5a9b194ae84ae8996d
-  data.tar.gz: 802febb7fa45d581b5e96223a3922b980190b430a513688ad02cf57736ffa253
+  metadata.gz: ba1cd330c7e4a9de6c8a3cefac5bebd1e4f61187708babc92bb15ea5bcffa896
+  data.tar.gz: dfd2b6ec75acfd368e36b66e1fc88628b047b90a008ac831991f9ef5f2a07bd1
 SHA512:
-  metadata.gz: 918e5f96eac1e25c4b2f93a120262b5c2aa8a1c4dab8d725fd76b0d2357227a251a09dd4f889838ce11f1ad3c71e48406ce54e52f509192d826a9cf9f31583a7
-  data.tar.gz: 1634578d7ee98ce77f86d87d897491b84225aa6e77aeb2a252b25a3e3cfdce11899d095d6a14ba91a7f10fbaf45d07f062104712e971c92cf9440aab1dfe3741
+  metadata.gz: d14e7be8d32dbf925fb7fd1c5f95272272cde0f3ee2ab027baff615d1f1ed80b01ef3d2ef1f3baa59c85060693ab44e5cf3de078316b1d9176a8cec9318397a8
+  data.tar.gz: d67ba35d806db20dee767796b82a7f4c1d68361404817665b6d17c4d3583e4c035463f97697932212fed583b164a457fc5c988f939db22fff4f6f3b02d2fa1fe

data/lib/opal/vite/cli.rb

@@ -29,6 +29,8 @@ module Opal
       private
 
       def compile_command
+        # Parse options first so they may appear before or after the file name
+        parse_compile_options
         file_path = @argv.shift
 
         unless file_path
@@ -42,12 +44,16 @@ module Opal
           exit 1
         end
 
-        parse_compile_options
+        # Without -o the compiled JS goes to stdout, so progress messages go to
+        # stderr to keep stdout a clean JS stream
+        log = @options[:output] ? $stdout : $stderr
 
         begin
-          puts "Compiling #{file_path}..."
+          log.puts "Compiling #{file_path}..."
 
-          compiler = Opal::Vite::Compiler.new
+          config = Opal::Vite::Config.new
+          config.source_map_enabled = !!@options[:source_map]
+          compiler = Opal::Vite::Compiler.new(config: config)
           source = File.read(file_path)
           result = compiler.compile(source, file_path)
 
@@ -66,13 +72,13 @@ module Opal
           end
 
           if @options[:verbose]
-            puts "\nDependencies:"
+            log.puts "\nDependencies:"
             result[:dependencies].each do |dep|
-              puts "  - #{dep}"
+              log.puts "  - #{dep}"
             end
           end
 
-          puts "✅ Compilation successful!"
+          log.puts "✅ Compilation successful!"
         rescue => e
           puts "❌ Compilation failed: #{e.message}"
           puts e.backtrace.first(5).join("\n") if @options[:verbose]
@@ -133,6 +139,9 @@ module Opal
             @options[:verbose] = true
           end
         end.parse!(@argv)
+      rescue OptionParser::ParseError => e
+        puts "Error: #{e.message}"
+        exit 1
       end
     end
   end

data/lib/opal/vite/compiler.rb

@@ -22,12 +22,18 @@ module Opal
         @compiler_options = options.fetch(:compiler_options, {})
       end
 
+      # Opal compiler options for the Builder. Options explicitly set through
+      # Opal::Vite.configure come first; options given to Compiler.new win.
+      def builder_compiler_options
+        @config.explicit_compiler_options.merge(@compiler_options)
+      end
+
       # Compile Ruby source code to JavaScript
       # Returns a hash with :code, :map, and :dependencies
       def compile(source, file_path)
         begin
           # Use Opal::Builder and add the file's directory to load paths
-          builder = Opal::Builder.new(stubs: @stubs, compiler_options: @compiler_options)
+          builder = Opal::Builder.new(stubs: @stubs, compiler_options: builder_compiler_options)
           builder.prerequired = self.class.runtime_requires if @external_runtime
 
           # Add the directory containing the file to load paths
@@ -65,7 +71,8 @@ module Opal
           end
 
           result
-        rescue StandardError => e
+        rescue StandardError, ScriptError => e
+          # ScriptError covers LoadError / Opal::MissingRequire and syntax errors
           raise CompilationError, "Failed to compile #{file_path}: #{e.message}\n#{e.backtrace.first(5).join("\n")}"
         end
       end
@@ -323,6 +330,7 @@ module Opal
         section_abs_name = 0
 
         first_segment_processed = false
+        name_bridged = false
 
         lines.each do |line|
           if line.empty?
@@ -364,12 +372,21 @@ module Opal
                 new_name_delta = global_abs_name - prev_name
 
                 new_values = [gen_col_delta, new_source_delta, new_orig_line_delta, new_orig_col_delta]
-                new_values << new_name_delta if values.length > 4
+                if values.length > 4
+                  new_values << new_name_delta
+                  name_bridged = true
+                end
 
                 first_segment_processed = true
               else
                 # Subsequent segments: deltas are already correct (relative within section = relative within merged)
                 new_values = values.dup
+                if values.length > 4 && !name_bridged
+                  # The first segment of this section had no name, so this is
+                  # the section's first name: bridge from the merged name state
+                  new_values[4] = global_abs_name - prev_name
+                  name_bridged = true
+                end
               end
 
               result_segments << encode_vlq(new_values)

data/lib/opal/vite/config.rb

@@ -3,14 +3,22 @@ require 'json'
 module Opal
   module Vite
     class Config
-      attr_accessor :source_map_enabled,
-                    :arity_check,
-                    :freezing,
-                    :esm,
-                    :dynamic_require_severity,
-                    :missing_require_severity
+      # Options passed on to Opal's compiler (see #explicit_compiler_options)
+      COMPILER_OPTION_KEYS = %i[arity_check freezing esm dynamic_require_severity missing_require_severity].freeze
+
+      attr_accessor :source_map_enabled
+
+      attr_reader(*COMPILER_OPTION_KEYS)
+
+      COMPILER_OPTION_KEYS.each do |key|
+        define_method(:"#{key}=") do |value|
+          @explicit_compiler_options[key] = value
+          instance_variable_set(:"@#{key}", value)
+        end
+      end
 
       def initialize
+        @explicit_compiler_options = {}
         @source_map_enabled = true
         @arity_check = false
         @freezing = true
@@ -35,6 +43,16 @@ module Opal
         end
       end
 
+      # Compiler options that were set explicitly (via a writer, a config file
+      # or Opal::Vite.configure). Unset ones are left to Opal's own defaults, so
+      # the output does not change unless the user asked for it.
+      def explicit_compiler_options
+        @explicit_compiler_options.to_h do |key, value|
+          # Severities arrive as strings when read from a JSON config file
+          [key, key.to_s.end_with?('_severity') && value ? value.to_sym : value]
+        end
+      end
+
       def to_compiler_options
         {
           source_map_enabled: source_map_enabled,

data/lib/opal/vite/testing/stable_helpers.rb

@@ -81,8 +81,9 @@ module Opal
         # @param value [String] Value to set
         # @param timeout [Integer] Maximum wait time in seconds
         def stable_set(selector, value, timeout: DEFAULT_TIMEOUT)
-          escaped_value = escape_js(value)
-          js_retry_action(selector, 'set', value: escaped_value, timeout: timeout)
+          # js_retry_action escapes the value itself; escaping here too would
+          # double-escape quotes and backslashes
+          js_retry_action(selector, 'set', value: value.to_s, timeout: timeout)
         end
 
         # Send keys to element with stability check
@@ -360,7 +361,7 @@ module Opal
         # @param timeout [Integer] Maximum wait time in seconds
         def js_retry_action(selector, action, value: nil, timeout: DEFAULT_TIMEOUT)
           escaped_selector = escape_js(selector)
-          escaped_value = value ? escape_js(value) : ''
+          escaped_value = value.nil? ? '' : escape_js(value)
           start_time = Time.now
 
           loop do
@@ -404,7 +405,7 @@ module Opal
 
         # Escape string for JavaScript
         def escape_js(str)
-          str.to_s.gsub('\\', '\\\\\\\\').gsub("'", "\\\\'").gsub("\n", '\\n')
+          str.to_s.gsub('\\', '\\\\\\\\').gsub("'", "\\\\'").gsub("\n", '\\n').gsub("\r", '\\r')
         end
       end
     end

data/lib/opal/vite/version.rb

@@ -1,5 +1,5 @@
 module Opal
   module Vite
-    VERSION = "0.3.19"
+    VERSION = "0.4.0"
   end
 end

data/opal/opal_vite/concerns/v1/action_cable_helpers.rb

@@ -88,6 +88,9 @@ module OpalVite
           raise "Cable not connected. Call cable_connect first." unless @_cable_consumer
 
           @_cable_subscriptions ||= {}
+          # Subscribing again with the same channel and params replaces the
+          # earlier subscription instead of leaving both active
+          unsubscribe_from(channel_name, params)
           subscription_params = { channel: channel_name }.merge(params)
           native_params = subscription_params.to_n
 
@@ -204,6 +207,9 @@ module OpalVite
           raise "Cable not connected. Call cable_connect first." unless @_cable_consumer
 
           @_cable_subscriptions ||= {}
+          # Subscribing again with the same channel and params replaces the
+          # earlier subscription instead of leaving both active
+          unsubscribe_from(channel_name, params)
           subscription_params = { channel: channel_name }.merge(params)
           native_params = subscription_params.to_n
 
@@ -354,7 +360,8 @@ module OpalVite
         def cable_route(data, handlers, type_key = "type")
           data_type = cable_data_type(data, type_key)
           return unless data_type
-          handler = handlers[data_type] || handlers[data_type.to_sym]
+          # The type may be a non-String (e.g. a number), so convert before to_sym
+          handler = handlers[data_type] || handlers[data_type.to_s] || handlers[data_type.to_s.to_sym]
           handler&.call
         end
 

data/opal/opal_vite/concerns/v1/base64_helpers.rb

@@ -164,7 +164,8 @@ module OpalVite
         # @return [String] Basic auth header value
         def basic_auth_header(username, password)
           credentials = "#{username}:#{password}"
-          encoded = base64_encode(credentials)
+          # UTF-8 (RFC 7617), so non-Latin-1 characters work; btoa alone fails on them
+          encoded = base64_encode_unicode(credentials)
           "Basic #{encoded}"
         end
 
@@ -177,6 +178,7 @@ module OpalVite
           encoded = header[6..-1]
           decoded = base64_decode(encoded)
           return nil unless decoded
+          decoded = binary_to_utf8(decoded)
 
           parts = decoded.split(':', 2)
           return nil if parts.length != 2
@@ -200,6 +202,7 @@ module OpalVite
           payload_base64 = parts[1]
           payload_json = base64_decode_urlsafe(payload_base64)
           return nil unless payload_json
+          payload_json = binary_to_utf8(payload_json)
 
           `JSON.parse(#{payload_json})`
         rescue Exception
@@ -268,6 +271,14 @@ module OpalVite
           # unpadded/URL-safe input (len % 4 == 2 or 3) would yield e.g. 16.5.
           ((len * 3) / 4).floor - padding
         end
+
+        private
+
+        # Reinterpret a binary string (as returned by atob) as UTF-8 text.
+        # Input that is not valid UTF-8 is returned unchanged.
+        def binary_to_utf8(str)
+          `(function(s) { try { return decodeURIComponent(escape(s)); } catch (e) { return s; } })(#{str})`
+        end
       end
     end
   end

data/opal/opal_vite/concerns/v1/stimulus_helpers.rb

@@ -367,12 +367,14 @@ module OpalVite
 
       # Get JSON-parsed value from localStorage
       # @param key [String] Storage key
-      # @param default [Object] Default value if key doesn't exist
+      # @param default [Object] Default value if key doesn't exist or is not valid JSON
       # @return [Object] Parsed value or default
       def storage_get_json(key, default = nil)
         stored = storage_get(key)
         return default if `#{stored} === null`
-        `JSON.parse(#{stored})`
+        # A value that is not valid JSON (e.g. written by something else)
+        # yields the default instead of raising
+        `(function(s, d) { try { return JSON.parse(s); } catch (e) { return d; } })(#{stored}, #{default})`
       end
 
       # Set JSON-stringified value in localStorage
@@ -457,34 +459,41 @@ module OpalVite
       end
 
       # Get the current event's target element
+      # @param evt [Native, nil] The event (the argument Stimulus passes to the
+      #   action). Pass it when you can: without it the deprecated global
+      #   window.event is used, which is undefined after an await / in callbacks.
       # @return [Native] Event target element
-      def event_target
-        `event.currentTarget`
+      def event_target(evt: nil)
+        e = current_event(evt)
+        `#{e}.currentTarget`
       end
 
       # Get data attribute from current event target
       # @param attr [String] Data attribute name (without 'data-' prefix)
       # @return [String, nil] Attribute value
-      def event_data(attr)
-        `event.currentTarget.getAttribute('data-' + #{attr})`
+      def event_data(attr, evt: nil)
+        e = current_event(evt)
+        `#{e}.currentTarget.getAttribute('data-' + #{attr})`
       end
 
       # Get integer data attribute from current event target
       # @param attr [String] Data attribute name (without 'data-' prefix)
       # @return [Integer, nil] Parsed integer value
-      def event_data_int(attr)
-        parse_int(event_data(attr))
+      def event_data_int(attr, evt: nil)
+        parse_int(event_data(attr, evt: evt))
       end
 
       # Prevent default event behavior
-      def prevent_default
-        `event.preventDefault()`
+      def prevent_default(evt: nil)
+        e = current_event(evt)
+        `#{e}.preventDefault()`
       end
 
       # Get event key (for keyboard events)
       # @return [String] Key name
-      def event_key
-        `event.key`
+      def event_key(evt: nil)
+        e = current_event(evt)
+        `#{e}.key`
       end
 
       # ===== Element Methods =====
@@ -1585,8 +1594,9 @@ module OpalVite
       #   def delete(event)
       #     params = action_params  # => { id: 123 }
       #   end
-      def action_params
-        `event.params || {}`
+      def action_params(evt: nil)
+        e = current_event(evt)
+        `#{e}.params || {}`
       end
 
       # Get a specific action parameter
@@ -1595,16 +1605,17 @@ module OpalVite
       # @example
       #   action_param(:id)   # => 123 (Number)
       #   action_param(:url)  # => "/api/item" (String)
-      def action_param(name)
-        `(event.params || {})[#{name.to_s}]`
+      def action_param(name, evt: nil)
+        e = current_event(evt)
+        `(#{e}.params || {})[#{name.to_s}]`
       end
 
       # Get action parameter as integer with default
       # @param name [Symbol, String] Parameter name
       # @param default [Integer] Default value if missing or NaN
       # @return [Integer] Parameter value
-      def action_param_int(name, default = 0)
-        value = action_param(name)
+      def action_param_int(name, default = 0, evt: nil)
+        value = action_param(name, evt: evt)
         result = parse_int(value)
         is_nan?(result) ? default : result
       end
@@ -1612,16 +1623,17 @@ module OpalVite
       # Get action parameter as boolean
       # @param name [Symbol, String] Parameter name
       # @return [Boolean] Parameter value
-      def action_param_bool(name)
-        value = action_param(name)
+      def action_param_bool(name, evt: nil)
+        value = action_param(name, evt: evt)
         `!!#{value} && #{value} !== "false" && #{value} !== "0"`
       end
 
       # Check if an action parameter exists
       # @param name [Symbol, String] Parameter name
       # @return [Boolean] true if parameter exists
-      def has_action_param?(name)
-        `(event.params || {}).hasOwnProperty(#{name.to_s})`
+      def has_action_param?(name, evt: nil)
+        e = current_event(evt)
+        `(#{e}.params || {}).hasOwnProperty(#{name.to_s})`
       end
 
       # ===== Stimulus Controller Access =====
@@ -1777,13 +1789,15 @@ module OpalVite
       # Deep merge two objects
       # @param target [Hash] Target object
       # @param source [Hash] Source object
-      # @return [Hash] Merged object
+      # @return [Native] Merged plain JavaScript object (not a Ruby Hash);
+      #   the keys __proto__ / constructor / prototype are skipped
       def deep_merge(target, source)
         `
           function deepMerge(target, source) {
             var result = Object.assign({}, target);
             for (var key in source) {
-              if (source.hasOwnProperty(key)) {
+              if (key === '__proto__' || key === 'constructor' || key === 'prototype') continue;
+              if (Object.prototype.hasOwnProperty.call(source, key)) {
                 if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
                   result[key] = deepMerge(result[key] || {}, source[key]);
                 } else {
@@ -1991,6 +2005,13 @@ module OpalVite
 
       private
 
+      # The event to read: the one passed in (a wrapper such as opal_stimulus's
+      # JS::Proxy or Native is unwrapped with to_n), else the global window.event
+      # (deprecated, and undefined outside the synchronous event dispatch).
+      def current_event(evt)
+        `(function(e) { if (e == null || e === #{nil}) return window.event; return typeof e.$to_n === 'function' ? e.$to_n() : e; })(#{evt})`
+      end
+
       # Convert snake_case to camelCase, preserving existing camelCase
       # @param name [Symbol, String] The name to convert
       # @param capitalize_first [Boolean] Whether to capitalize first letter

data/opal/opal_vite/concerns/v1/turbo_helpers.rb

@@ -159,15 +159,18 @@ module OpalVite
 
         # Get the target frame from current event
         # @return [Native, nil] Frame element from event
-        def event_turbo_frame
-          `event.target.closest('turbo-frame')`
+        # @param evt [Native, nil] The event; defaults to the deprecated global window.event
+        def event_turbo_frame(evt: nil)
+          e = `(function(e) { if (e == null || e === #{nil}) return window.event; return typeof e.$to_n === 'function' ? e.$to_n() : e; })(#{evt})`
+          `#{e}.target.closest('turbo-frame')`
         end
 
         # ===== Turbo Streams =====
 
         # Render a Turbo Stream action
         # @param action [Symbol, String] Stream action (:append, :prepend, :replace, :update, :remove, :before, :after)
-        # @param target [String] Target element ID
+        # @param target [String] Target element ID (HTML-escaped when rendered;
+        #   the html argument is NOT escaped, escape user data with escape_html)
         # @param html [String] HTML content (not needed for :remove)
         # @example
         #   turbo_stream(:append, "messages", "<div>New message</div>")
@@ -176,7 +179,7 @@ module OpalVite
           action_s = action.to_s
           template_content = html ? "<template>#{html}</template>" : ""
 
-          stream_html = %{<turbo-stream action="#{action_s}" target="#{target}">#{template_content}</turbo-stream>}
+          stream_html = %{<turbo-stream action="#{turbo_escape_attr(action_s)}" target="#{turbo_escape_attr(target)}">#{template_content}</turbo-stream>}
           render_turbo_stream(stream_html)
         end
 
@@ -468,6 +471,11 @@ module OpalVite
 
         private
 
+        # Escape a value for use inside a double-quoted HTML attribute
+        def turbo_escape_attr(value)
+          TurboStreamBuilder.escape_attr(value)
+        end
+
         def turbo_event_name(event_name)
           event_name.start_with?("turbo:") ? event_name : "turbo:#{event_name}"
         end
@@ -475,36 +483,42 @@ module OpalVite
 
       # Builder for creating multiple Turbo Stream operations
       class TurboStreamBuilder
+        # Escape a value for use inside a double-quoted HTML attribute
+        def self.escape_attr(value)
+          str = value.to_s
+          `#{str}.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;')`
+        end
+
         def initialize
           @streams = []
         end
 
         def append(target, html)
-          @streams << %{<turbo-stream action="append" target="#{target}"><template>#{html}</template></turbo-stream>}
+          @streams << %{<turbo-stream action="append" target="#{TurboStreamBuilder.escape_attr(target)}"><template>#{html}</template></turbo-stream>}
         end
 
         def prepend(target, html)
-          @streams << %{<turbo-stream action="prepend" target="#{target}"><template>#{html}</template></turbo-stream>}
+          @streams << %{<turbo-stream action="prepend" target="#{TurboStreamBuilder.escape_attr(target)}"><template>#{html}</template></turbo-stream>}
         end
 
         def replace(target, html)
-          @streams << %{<turbo-stream action="replace" target="#{target}"><template>#{html}</template></turbo-stream>}
+          @streams << %{<turbo-stream action="replace" target="#{TurboStreamBuilder.escape_attr(target)}"><template>#{html}</template></turbo-stream>}
         end
 
         def update(target, html)
-          @streams << %{<turbo-stream action="update" target="#{target}"><template>#{html}</template></turbo-stream>}
+          @streams << %{<turbo-stream action="update" target="#{TurboStreamBuilder.escape_attr(target)}"><template>#{html}</template></turbo-stream>}
         end
 
         def remove(target)
-          @streams << %{<turbo-stream action="remove" target="#{target}"></turbo-stream>}
+          @streams << %{<turbo-stream action="remove" target="#{TurboStreamBuilder.escape_attr(target)}"></turbo-stream>}
         end
 
         def before(target, html)
-          @streams << %{<turbo-stream action="before" target="#{target}"><template>#{html}</template></turbo-stream>}
+          @streams << %{<turbo-stream action="before" target="#{TurboStreamBuilder.escape_attr(target)}"><template>#{html}</template></turbo-stream>}
         end
 
         def after(target, html)
-          @streams << %{<turbo-stream action="after" target="#{target}"><template>#{html}</template></turbo-stream>}
+          @streams << %{<turbo-stream action="after" target="#{TurboStreamBuilder.escape_attr(target)}"><template>#{html}</template></turbo-stream>}
         end
 
         def render

data/opal/opal_vite/concerns/v1/uri_helpers.rb

@@ -277,10 +277,12 @@ module OpalVite
         # ===== Path Utilities =====
 
         # Join path segments
-        # @param segments [Array<String>] Path segments
+        # @param segments [Array<String>] Path segments (a leading "/" on the first one is kept)
         # @return [String] Joined path
         def join_path(*segments)
-          segments.map { |s| s.to_s.gsub(%r{^/|/$}, '') }.reject(&:empty?).join('/')
+          joined = segments.map { |s| s.to_s.gsub(%r{^/+|/+$}, '') }.reject(&:empty?).join('/')
+          # Keep the leading slash of an absolute first segment (join_path('/api', 'users') => '/api/users')
+          segments.first.to_s.start_with?('/') ? "/#{joined}" : joined
         end
 
         # Get the filename from a path
@@ -294,9 +296,11 @@ module OpalVite
         # @param path [String] Path
         # @return [String] Directory path
         def path_dirname(path)
-          parts = path.to_s.split('/')
-          parts.pop
-          parts.join('/') || '/'
+          str = path.to_s.sub(%r{/+$}, '')
+          idx = str.rindex('/')
+          return '' if idx.nil?       # no directory part
+          return '/' if idx == 0      # '/file.txt' => '/'
+          str[0...idx]
         end
 
         # Get the file extension from a path

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opal-vite
 version: !ruby/object:Gem::Version
-  version: 0.3.19
+  version: 0.4.0
 platform: ruby
 authors:
 - stofu1234