datastar 1.0.0.beta.2 → 1.0.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 23de694fa3da7ad6bd9cc78a02851ec22ab16f5d16e475beb9bc175569fbce02
-  data.tar.gz: eab01bb873a350c595dcdaddddb722ea2a69aef584b86f1bab5309f61764a699
+  metadata.gz: cc457ac67196befbcb6a6c1510b970e81e728261dff0987d42d7760e358ad7fe
+  data.tar.gz: 5dcf48dc09ee9adb4c08f53d2ef63df316a34929ca6d3bcf0d15cf0d27083540
 SHA512:
-  metadata.gz: 3f386d1039d1a9fc53b698ce9d4390f595dcf1dfec1166c03d7bb1fa17ec87c062089386151cc7d1ea6117e4b8350d6d819458215b3f305bc3e756f1a691dba2
-  data.tar.gz: 88e7e8505d1640151bcd494aca0000b3ee5d935f0ad426b937372d6c93b8191e5a2b4838e0ed86a58eeab11e5a5e66e92a92841967812f4095564ebc39adbf36
+  metadata.gz: edba4b371362360de36fcfb7379a80b96ac5743c7d765a264bf8dbd21a223147e44677d05fea02f1136d8db5aa84579af943e3a0593662d4cecdbfe5155df96a
+  data.tar.gz: fa551cb816ca6cfe0ea46ec53c9b1d51256009c6eb378b77df51a1376a297ec3fea97bebd26ef8dab330d857f366bbbacf32dd7e1a6c20d97b9e097942ee5301

data/README.md

@@ -44,7 +44,7 @@ There are two ways to use this gem in HTTP handlers:
 #### One-off update:
 
 ```ruby
-datastar.merge_fragments(%(<h1 id="title">Hello, World!</h1>))
+datastar.patch_elements(%(<h1 id="title">Hello, World!</h1>))
 ```
 In this mode, the response is closed after the fragment is sent.
 
@@ -52,11 +52,11 @@ In this mode, the response is closed after the fragment is sent.
 
 ```ruby
 datastar.stream do |sse|
-  sse.merge_fragments(%(<h1 id="title">Hello, World!</h1>))
+  sse.patch_elements(%(<h1 id="title">Hello, World!</h1>))
   # Streaming multiple updates
   100.times do |i|
     sleep 1
-    sse.merge_fragments(%(<h1 id="title">Hello, World #{i}!</h1>))
+    sse.patch_elements(%(<h1 id="title">Hello, World #{i}!</h1>))
   end
 end
 ```
@@ -72,14 +72,14 @@ Their updates are linearized and sent to the browser as they are produced.
 datastar.stream do |sse|
   100.times do |i|
     sleep 1
-    sse.merge_fragments(%(<h1 id="slow">#{i}!</h1>))
+    sse.patch_elements(%(<h1 id="slow">#{i}!</h1>))
   end
 end
 
 datastar.stream do |sse|
   1000.times do |i|
     sleep 0.1
-    sse.merge_fragments(%(<h1 id="fast">#{i}!</h1>))
+    sse.patch_elements(%(<h1 id="fast">#{i}!</h1>))
   end
 end
 ```
@@ -90,48 +90,73 @@ See the [examples](https://github.com/starfederation/datastar/tree/main/examples
 
 All these methods are available in both the one-off and the streaming modes.
 
-#### `merge_fragments`
-See https://data-star.dev/reference/sse_events#datastar-merge-fragments
+#### `patch_elements`
+See https://data-star.dev/reference/sse_events#datastar-patch-elements
 
 ```ruby
-sse.merge_fragments(%(<div id="foo">\n<span>hello</span>\n</div>))
+sse.patch_elements(%(<div id="foo">\n<span>hello</span>\n</div>))
 
 # or a Phlex view object
-sse.merge_fragments(UserComponet.new)
+sse.patch_elements(UserComponent.new)
 
 # Or pass options
-sse.merge_fragments(
+sse.patch_elements(
   %(<div id="foo">\n<span>hello</span>\n</div>),
-  merge_mode: 'append'
+  mode: 'append'
 )
 ```
 
-#### `remove_fragments`
- See https://data-star.dev/reference/sse_events#datastar-remove-fragments
+You can patch multiple elements at once by passing an array of elements (or components):
 
 ```ruby
-sse.remove_fragments('#users')
+sse.patch_elements([
+  %(<div id="foo">\n<span>hello</span>\n</div>),
+  %(<div id="bar">\n<span>world</span>\n</div>)
+])
+```
+
+#### `remove_elements`
+
+Sugar on top of `#patch_elements`
+ See https://data-star.dev/reference/sse_events#datastar-patch-elements
+
+```ruby
+sse.remove_elements('#users')
 ```
 
-#### `merge_signals`
- See https://data-star.dev/reference/sse_events#datastar-merge-signals
+#### `patch_signals`
+ See https://data-star.dev/reference/sse_events#datastar-patch-signals
 
 ```ruby
-sse.merge_signals(count: 4, user: { name: 'John' })
+sse.patch_signals(count: 4, user: { name: 'John' })
 ```
 
 #### `remove_signals`
- See https://data-star.dev/reference/sse_events#datastar-remove-signals
+
+Sugar on top of `#patch_signals`
 
 ```ruby
 sse.remove_signals(['user.name', 'user.email'])
 ```
 
 #### `execute_script`
-See https://data-star.dev/reference/sse_events#datastar-execute-script
+
+Sugar on top of `#patch_elements`. Appends a temporary `<script>` tag to the DOM, which will execute the script in the browser.
 
 ```ruby
-sse.execute_scriprt(%(alert('Hello World!'))
+sse.execute_script(%(alert('Hello World!'))
+```
+
+Pass `attributes` that will be added to the `<script>` tag:
+
+```ruby
+sse.execute_script(%(alert('Hello World!')), attributes: { type: 'text/javascript' })
+```
+
+These script tags are automatically removed after execution, so they can be used to run one-off scripts in the browser. Pass `auto_remove: false` if you want to keep the script tag in the DOM.
+
+```ruby
+sse.execute_script(%(alert('Hello World!')), auto_remove: false)
 ```
 
 #### `signals`
@@ -165,7 +190,7 @@ end
 Register server-side code to run when the connection is closed by the client
 
 ```ruby
-datastar.on_client_connect do
+datastar.on_client_disconnect do
   puts 'A user has disconnected connected'
 end
 ```
@@ -178,7 +203,7 @@ Register server-side code to run when the connection is closed by the server.
 Ie when the served is done streaming without errors.
 
 ```ruby
-datastar.on_server_connect do
+datastar.on_server_disconnect do
   puts 'Server is done streaming'
 end
 ```
@@ -264,25 +289,25 @@ datastar.stream do |sse|
   10.times do |i|
     sleep 1
     tpl = render_to_string('events/user', layout: false, locals: { name: "David #{i}" })
-    sse.merge_fragments tpl
+    sse.patch_elements tpl
   end
 end
 ```
 
 ### Rendering Phlex components
 
-`#merge_fragments` supports [Phlex](https://www.phlex.fun) component instances.
+`#patch_elements` supports [Phlex](https://www.phlex.fun) component instances.
 
 ```ruby
-sse.merge_fragments(UserComponent.new(user: User.first))
+sse.patch_elements(UserComponent.new(user: User.first))
 ```
 
 ### Rendering ViewComponent instances
 
-`#merge_fragments` also works with [ViewComponent](https://viewcomponent.org) instances.
+`#patch_elements` also works with [ViewComponent](https://viewcomponent.org) instances.
 
 ```ruby
-sse.merge_fragments(UserViewComponent.new(user: User.first))
+sse.patch_elements(UserViewComponent.new(user: User.first))
 ```
 
 ### Rendering `#render_in(view_context)` interfaces
@@ -302,7 +327,7 @@ end
 ```
 
 ```ruby
-sse.merge_fragments MyComponent.new('Joe')
+sse.patch_elements MyComponent.new('Joe')
 ```
 
 
@@ -338,6 +363,12 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+### Building
+
+To build `consts.rb` file from template, run Docker and run `make task build`
+
+The template is located at `build/consts_ruby.gtpl`.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/starfederation/datastar.

data/examples/test.ru

@@ -35,21 +35,17 @@ run do |env|
     sse.signals['events'].each do |event|
       type = event.delete('type')
       case type
-      when 'mergeSignals'
-        arg = event.delete('signals')
-        sse.merge_signals(arg, event)
-      when 'removeSignals'
-        arg = event.delete('paths')
-        sse.remove_signals(arg, event)
+      when 'patchSignals'
+        arg = event.delete('signals') || event.delete('signals-raw')
+        sse.patch_signals(arg, event)
       when 'executeScript'
         arg = event.delete('script')
         sse.execute_script(arg, event)
-      when 'mergeFragments'
-        arg = event.delete('fragments')
-        sse.merge_fragments(arg, event)
-      when 'removeFragments'
-        arg = event.delete('selector')
-        sse.remove_fragments(arg, event)
+      when 'patchElements'
+        arg = event.delete('elements')
+        sse.patch_elements(arg, event)
+      else
+        raise "Unknown event type: #{type}"
       end
     end
   end

data/lib/datastar/configuration.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'thread'
+require 'logger'
 
 module Datastar
   # The default executor based on Ruby threads
@@ -30,17 +31,19 @@ module Datastar
   # You'd normally do this on app initialization 
   # For example in a Rails initializer
   class Configuration
-    NOOP_CALLBACK = ->(_error) {}
     RACK_FINALIZE = ->(_view_context, response) { response.finish }
     DEFAULT_HEARTBEAT = 3
 
-    attr_accessor :executor, :error_callback, :finalize, :heartbeat
+    attr_accessor :executor, :error_callback, :finalize, :heartbeat, :logger
 
     def initialize
       @executor = ThreadExecutor.new
-      @error_callback = NOOP_CALLBACK
       @finalize = RACK_FINALIZE
       @heartbeat = DEFAULT_HEARTBEAT
+      @logger = Logger.new(STDOUT)
+      @error_callback = proc do |e|
+        @logger.error("#{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}")
+      end
     end
 
     def on_error(callable = nil, &block)

data/lib/datastar/consts.rb

@@ -4,67 +4,54 @@
 module Datastar
   module Consts
     DATASTAR_KEY = 'datastar'
-    VERSION = '1.0.0-beta.5'
-
-    # The default duration for settling during fragment merges. Allows for CSS transitions to complete.
-    DEFAULT_FRAGMENTS_SETTLE_DURATION = 300
+    VERSION = '1.0.0-RC.13'
 
     # The default duration for retrying SSE on connection reset. This is part of the underlying retry mechanism of SSE.
     DEFAULT_SSE_RETRY_DURATION = 1000
 
-    # Should fragments be merged using the ViewTransition API?
-    DEFAULT_FRAGMENTS_USE_VIEW_TRANSITIONS = false
-
-    # Should a given set of signals merge if they are missing?
-    DEFAULT_MERGE_SIGNALS_ONLY_IF_MISSING = false
+    # Should elements be patched using the ViewTransition API?
+    DEFAULT_ELEMENTS_USE_VIEW_TRANSITIONS = false
 
-    # Should script element remove itself after execution?
-    DEFAULT_EXECUTE_SCRIPT_AUTO_REMOVE = true
+    # Should a given set of signals patch if they are missing?
+    DEFAULT_PATCH_SIGNALS_ONLY_IF_MISSING = false
 
-    # The default attributes for <script/> element use when executing scripts. It is a set of key-value pairs delimited by a newline \\n character.}
-    DEFAULT_EXECUTE_SCRIPT_ATTRIBUTES = 'type module'
+    module ElementPatchMode
 
-    module FragmentMergeMode
-
-      # Morphs the fragment into the existing element using idiomorph.
-      MORPH = 'morph'
+      # Morphs the element into the existing element.
+      OUTER = 'outer';
 
       # Replaces the inner HTML of the existing element.
-      INNER = 'inner'
+      INNER = 'inner';
 
-      # Replaces the outer HTML of the existing element.
-      OUTER = 'outer'
+      # Removes the existing element.
+      REMOVE = 'remove';
 
-      # Prepends the fragment to the existing element.
-      PREPEND = 'prepend'
+      # Replaces the existing element with the new element.
+      REPLACE = 'replace';
 
-      # Appends the fragment to the existing element.
-      APPEND = 'append'
+      # Prepends the element inside to the existing element.
+      PREPEND = 'prepend';
 
-      # Inserts the fragment before the existing element.
-      BEFORE = 'before'
+      # Appends the element inside the existing element.
+      APPEND = 'append';
 
-      # Inserts the fragment after the existing element.
-      AFTER = 'after'
+      # Inserts the element before the existing element.
+      BEFORE = 'before';
 
-      # Upserts the attributes of the existing element.
-      UPSERT_ATTRIBUTES = 'upsertAttributes'
+      # Inserts the element after the existing element.
+      AFTER = 'after';
     end
 
-    # The mode in which a fragment is merged into the DOM.
-    DEFAULT_FRAGMENT_MERGE_MODE = FragmentMergeMode::MORPH
+
+    # The mode in which an element is patched into the DOM.
+    DEFAULT_ELEMENT_PATCH_MODE = ElementPatchMode::OUTER
 
     # Dataline literals.
     SELECTOR_DATALINE_LITERAL = 'selector'
-    MERGE_MODE_DATALINE_LITERAL = 'mergeMode'
-    SETTLE_DURATION_DATALINE_LITERAL = 'settleDuration'
-    FRAGMENTS_DATALINE_LITERAL = 'fragments'
+    MODE_DATALINE_LITERAL = 'mode'
+    ELEMENTS_DATALINE_LITERAL = 'elements'
     USE_VIEW_TRANSITION_DATALINE_LITERAL = 'useViewTransition'
     SIGNALS_DATALINE_LITERAL = 'signals'
     ONLY_IF_MISSING_DATALINE_LITERAL = 'onlyIfMissing'
-    PATHS_DATALINE_LITERAL = 'paths'
-    SCRIPT_DATALINE_LITERAL = 'script'
-    ATTRIBUTES_DATALINE_LITERAL = 'attributes'
-    AUTO_REMOVE_DATALINE_LITERAL = 'autoRemove'
   end
 end

data/lib/datastar/dispatcher.rb

@@ -10,20 +10,21 @@ module Datastar
   #  datastar = Datastar.new(request:, response:, view_context: self)
   #
   #  # One-off fragment response
-  #  datastar.merge_fragments(template)
+  #  datastar.patch_elements(template)
   #
   #  # Streaming response with multiple messages
   #  datastar.stream do |sse|
-  #    sse.merge_fragments(template)
+  #    sse.patch_elements(template)
   #    10.times do |i|
   #      sleep 0.1
-  #      sse.merge_signals(count: i)
+  #      sse.patch_signals(count: i)
   #    end
   #  end
   #
   class Dispatcher
     BLANK_BODY = [].freeze
     SSE_CONTENT_TYPE = 'text/event-stream'
+    SSE_ACCEPT_EXP = /text\/event-stream/
     HTTP_ACCEPT = 'HTTP_ACCEPT'
     HTTP1 = 'HTTP/1.1'
 
@@ -72,7 +73,7 @@ module Datastar
     # Check if the request accepts SSE responses
     # @return [Boolean]
     def sse?
-      @request.get_header(HTTP_ACCEPT) == SSE_CONTENT_TYPE
+      !!(@request.get_header(HTTP_ACCEPT).to_s =~ SSE_ACCEPT_EXP)
     end
 
     # Register an on-connect callback
@@ -119,47 +120,48 @@ module Datastar
       @signals ||= parse_signals(request).freeze
     end
 
-    # Send one-off fragments to the UI
-    # See https://data-star.dev/reference/sse_events#datastar-merge-fragments
+    # Send one-off elements to the UI
+    # See https://data-star.dev/reference/sse_events#datastar-patch-elements
     # @example
     #
-    #  datastar.merge_fragments(%(<div id="foo">\n<span>hello</span>\n</div>\n))
+    #  datastar.patch_elements(%(<div id="foo">\n<span>hello</span>\n</div>\n))
     #  # or a Phlex view object
-    #  datastar.merge_fragments(UserComponet.new)
+    #  datastar.patch_elements(UserComponet.new)
     #
-    # @param fragments [String, #call(view_context: Object) => Object] the HTML fragment or object
+    # @param elements [String, #call(view_context: Object) => Object] the HTML elements or object
     # @param options [Hash] the options to send with the message
-    def merge_fragments(fragments, options = BLANK_OPTIONS)
+    def patch_elements(elements, options = BLANK_OPTIONS)
       stream_no_heartbeat do |sse|
-        sse.merge_fragments(fragments, options)
+        sse.patch_elements(elements, options)
       end
     end
 
-    # One-off remove fragments from the UI
-    # See https://data-star.dev/reference/sse_events#datastar-remove-fragments
+    # One-off remove elements from the UI
+    # Sugar on top of patch-elements with mode: 'remove'
+    # See https://data-star.dev/reference/sse_events#datastar-patch-elements
     # @example
     #
-    #  datastar.remove_fragments('#users')
+    #  datastar.remove_elements('#users')
     #
     # @param selector [String] a CSS selector for the fragment to remove
     # @param options [Hash] the options to send with the message
-    def remove_fragments(selector, options = BLANK_OPTIONS)
+    def remove_elements(selector, options = BLANK_OPTIONS)
       stream_no_heartbeat do |sse|
-        sse.remove_fragments(selector, options)
+        sse.remove_elements(selector, options)
       end
     end
 
-    # One-off merge signals in the UI
-    # See https://data-star.dev/reference/sse_events#datastar-merge-signals
+    # One-off patch signals in the UI
+    # See https://data-star.dev/reference/sse_events#datastar-patch-signals
     # @example
     #
-    #  datastar.merge_signals(count: 1, toggle: true)
+    #  datastar.patch_signals(count: 1, toggle: true)
     #
-    # @param signals [Hash] signals to merge
+    # @param signals [Hash, String] signals to merge
     # @param options [Hash] the options to send with the message
-    def merge_signals(signals, options = BLANK_OPTIONS)
+    def patch_signals(signals, options = BLANK_OPTIONS)
       stream_no_heartbeat do |sse|
-        sse.merge_signals(signals, options)
+        sse.patch_signals(signals, options)
       end
     end
 
@@ -209,9 +211,9 @@ module Datastar
     #
     #  datastar.stream do |sse|
     #    total = 300
-    #    sse.merge_fragments(%(<progress data-signal-progress="0" id="progress" max="#{total}" data-attr-value="$progress">0</progress>))
+    #    sse.patch_elements(%(<progress data-signal-progress="0" id="progress" max="#{total}" data-attr-value="$progress">0</progress>))
     #    total.times do |i|
-    #      sse.merge_signals(progress: i)
+    #      sse.patch_signals(progress: i)
     #    end
     #  end
     #

data/lib/datastar/railtie.rb

@@ -14,6 +14,8 @@ module Datastar
     initializer 'datastar' do |_app|
       Datastar.config.finalize = FINALIZE
 
+      Datastar.config.logger = Rails.logger
+
       Datastar.config.executor = if config.active_support.isolation_level == :fiber
                                    require 'datastar/rails_async_executor'
                                    RailsAsyncExecutor.new

data/lib/datastar/server_sent_event_generator.rb

@@ -4,7 +4,7 @@ require 'json'
 
 module Datastar
   class ServerSentEventGenerator
-    MSG_END = "\n\n"
+    MSG_END = "\n"
 
     SSE_OPTION_MAPPING = {
       'eventId' => 'id',
@@ -15,21 +15,12 @@ module Datastar
 
     OPTION_DEFAULTS = {
       'retry' => Consts::DEFAULT_SSE_RETRY_DURATION,
-      Consts::AUTO_REMOVE_DATALINE_LITERAL => Consts::DEFAULT_EXECUTE_SCRIPT_AUTO_REMOVE,
-      Consts::MERGE_MODE_DATALINE_LITERAL => Consts::DEFAULT_FRAGMENT_MERGE_MODE,
-      Consts::SETTLE_DURATION_DATALINE_LITERAL => Consts::DEFAULT_FRAGMENTS_SETTLE_DURATION,
-      Consts::USE_VIEW_TRANSITION_DATALINE_LITERAL => Consts::DEFAULT_FRAGMENTS_USE_VIEW_TRANSITIONS,
-      Consts::ONLY_IF_MISSING_DATALINE_LITERAL => Consts::DEFAULT_MERGE_SIGNALS_ONLY_IF_MISSING,
+      Consts::MODE_DATALINE_LITERAL => Consts::DEFAULT_ELEMENT_PATCH_MODE,
+      Consts::USE_VIEW_TRANSITION_DATALINE_LITERAL => Consts::DEFAULT_ELEMENTS_USE_VIEW_TRANSITIONS,
+      Consts::ONLY_IF_MISSING_DATALINE_LITERAL => Consts::DEFAULT_PATCH_SIGNALS_ONLY_IF_MISSING,
     }.freeze
 
-    # ATTRIBUTE_DEFAULTS = {
-    #   'type' => 'module'
-    # }.freeze
-    ATTRIBUTE_DEFAULTS = Consts::DEFAULT_EXECUTE_SCRIPT_ATTRIBUTES
-      .split("\n")
-      .map { |attr| attr.split(' ') }
-      .to_h
-      .freeze
+    SIGNAL_SEPARATOR = '.'
 
     attr_reader :signals
 
@@ -46,59 +37,71 @@ module Datastar
       @stream << MSG_END
     end
 
-    def merge_fragments(fragments, options = BLANK_OPTIONS)
-      # Support Phlex components
-      # And Rails' #render_in interface
-      fragments = if fragments.respond_to?(:render_in)
-        fragments.render_in(view_context)
-      elsif fragments.respond_to?(:call)
-        fragments.call(view_context:)
-      else
-        fragments.to_s
+    def patch_elements(elements, options = BLANK_OPTIONS)
+      elements = Array(elements).compact
+      rendered_elements = elements.map do |element|
+        render_element(element)
       end
 
-      fragment_lines = fragments.to_s.split("\n")
+      element_lines = rendered_elements.flat_map do |el|
+        el.to_s.split("\n")
+      end
 
-      buffer = +"event: datastar-merge-fragments\n"
+      buffer = +"event: datastar-patch-elements\n"
       build_options(options, buffer)
-      fragment_lines.each { |line| buffer << "data: fragments #{line}\n" }
+      element_lines.each { |line| buffer << "data: #{Consts::ELEMENTS_DATALINE_LITERAL} #{line}\n" }
 
       write(buffer)
     end
 
-    def remove_fragments(selector, options = BLANK_OPTIONS)
-      buffer = +"event: datastar-remove-fragments\n"
-      build_options(options, buffer)
-      buffer << "data: selector #{selector}\n"
-      write(buffer)
+    def remove_elements(selector, options = BLANK_OPTIONS)
+      patch_elements(
+        nil, 
+        options.merge(
+          Consts::MODE_DATALINE_LITERAL => Consts::ElementPatchMode::REMOVE,
+          selector:
+        )
+      )
     end
 
-    def merge_signals(signals, options = BLANK_OPTIONS)
-      signals = JSON.dump(signals) unless signals.is_a?(String)
-
-      buffer = +"event: datastar-merge-signals\n"
+    def patch_signals(signals, options = BLANK_OPTIONS)
+      buffer = +"event: datastar-patch-signals\n"
       build_options(options, buffer)
-      buffer << "data: signals #{signals}\n"
+      case signals
+      when Hash
+        signals = JSON.dump(signals)
+        buffer << "data: signals #{signals}\n"
+      when String
+        multi_data_lines(signals, buffer, Consts::SIGNALS_DATALINE_LITERAL)
+      end
       write(buffer)
     end
 
     def remove_signals(paths, options = BLANK_OPTIONS)
       paths = [paths].flatten
+      signals = paths.each.with_object({}) do |path, acc|
+        parts = path.split(SIGNAL_SEPARATOR)
+        set_nested_value(acc, parts, nil)
+      end
 
-      buffer = +"event: datastar-remove-signals\n"
-      build_options(options, buffer)
-      paths.each { |path| buffer << "data: paths #{path}\n" }
-      write(buffer)
+      patch_signals(signals, options)
     end
 
     def execute_script(script, options = BLANK_OPTIONS)
-      buffer = +"event: datastar-execute-script\n"
-      build_options(options, buffer)
-      scripts = script.to_s.split("\n")
-      scripts.each do |sc|
-        buffer << "data: script #{sc}\n"
+      options = camelize_keys(options)
+      auto_remove = options.key?('autoRemove') ? options.delete('autoRemove') : true
+      attributes = options.delete('attributes') || BLANK_OPTIONS
+      script_tag = +"<script"
+      attributes.each do |k, v|
+        script_tag << %( #{camelize(k)}="#{v}")
       end
-      write(buffer)
+      script_tag << %( data-effect="el.remove()") if auto_remove
+      script_tag << ">#{script}</script>"
+
+      options[Consts::SELECTOR_DATALINE_LITERAL] = 'body'
+      options[Consts::MODE_DATALINE_LITERAL] = Consts::ElementPatchMode::APPEND
+
+      patch_elements(script_tag, options)
     end
 
     def redirect(url)
@@ -114,6 +117,18 @@ module Datastar
 
     attr_reader :view_context, :stream
 
+    # Support Phlex components
+    # And Rails' #render_in interface
+    def render_element(element)
+      if element.respond_to?(:render_in)
+        element.render_in(view_context)
+      elsif element.respond_to?(:call)
+        element.call(view_context:)
+      else
+        element
+      end
+    end
+
     def build_options(options, buffer)
       options.each do |k, v|
         k = camelize(k)
@@ -122,8 +137,13 @@ module Datastar
           buffer << "#{sse_key}: #{v}\n" unless v == default_value
         elsif v.is_a?(Hash)
           v.each do |kk, vv| 
-            default_value = ATTRIBUTE_DEFAULTS[kk.to_s]
-            buffer << "data: #{k} #{kk} #{vv}\n" unless vv == default_value
+            buffer << "data: #{k} #{kk} #{vv}\n"
+          end
+        elsif v.is_a?(Array)
+          if k == Consts::SELECTOR_DATALINE_LITERAL
+            buffer << "data: #{k} #{v.join(', ')}\n"
+          else
+            buffer << "data: #{k} #{v.join(' ')}\n"
           end
         else
           default_value = OPTION_DEFAULTS[k]
@@ -132,8 +152,34 @@ module Datastar
       end
     end
 
+    def camelize_keys(options)
+      options.each.with_object({}) do |(key, value), acc|
+        value = camelize_keys(value) if value.is_a?(Hash)
+        acc[camelize(key)] = value
+      end
+    end
+
     def camelize(str)
       str.to_s.split('_').map.with_index { |word, i| i == 0 ? word : word.capitalize }.join
     end
+
+    # Take a string, split it by newlines,
+    # and write each line as a separate data line
+    def multi_data_lines(data, buffer, key)
+      lines = data.to_s.split("\n")
+      lines.each do |line|
+        buffer << "data: #{key} #{line}\n"
+      end
+    end
+
+    def set_nested_value(hash, path, value)
+      # Navigate to the parent hash using all but the last segment
+      parent = path[0...-1].reduce(hash) do |current_hash, key|
+        current_hash[key] ||= {}
+      end
+
+      # Set the final key to the value
+      parent[path.last] = value
+    end
   end
 end

data/lib/datastar/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Datastar
-  VERSION = '1.0.0.beta.2'
+  VERSION = '1.0.0.pre.1'
 end

metadata

@@ -1,28 +1,56 @@
 --- !ruby/object:Gem::Specification
 name: datastar
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta.2
+  version: 1.0.0.pre.1
 platform: ruby
 authors:
 - Ismael Celis
 bindir: exe
 cert_chain: []
-date: 2025-02-12 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 3.1.14
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: 3.1.14
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 email:
 - ismaelct@gmail.com
 executables: []
@@ -64,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Ruby SDK for Datastar. Rack-compatible.
 test_files: []