datastar 1.0.0.beta.3 → 1.0.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55282db68817596fd27726daa87179e08fcddb3b8deaea5826161d54f7a850cb
-  data.tar.gz: '0864d609f3afa0c950d357f396973b7882c6f834f56c112e4765e3dfc7add400'
+  metadata.gz: cc457ac67196befbcb6a6c1510b970e81e728261dff0987d42d7760e358ad7fe
+  data.tar.gz: 5dcf48dc09ee9adb4c08f53d2ef63df316a34929ca6d3bcf0d15cf0d27083540
 SHA512:
-  metadata.gz: 1712f02ea8b4d5def9d04381062f35135eb3213863b63536a35d8322b3880efb917acfb5dde900be7181ea2576b825791b301bd392a649bd799784aa93fbf28d
-  data.tar.gz: 4e268347627b41ec8c7506891adbf7c95f32d10d16c4ed3f5e33192f624660456d9a1712dee71921af18390c7998f1755a48a2cc73701a298036fce8ab1a48de
+  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`
@@ -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/consts.rb

@@ -4,63 +4,54 @@
 module Datastar
   module Consts
     DATASTAR_KEY = 'datastar'
-    VERSION = '1.0.0-beta.11'
+    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 elements be patched using the ViewTransition API?
+    DEFAULT_ELEMENTS_USE_VIEW_TRANSITIONS = false
 
-    # Should a given set of signals merge if they are missing?
-    DEFAULT_MERGE_SIGNALS_ONLY_IF_MISSING = false
+    # Should a given set of signals patch if they are missing?
+    DEFAULT_PATCH_SIGNALS_ONLY_IF_MISSING = false
 
-    # Should script element remove itself after execution?
-    DEFAULT_EXECUTE_SCRIPT_AUTO_REMOVE = true
+    module ElementPatchMode
 
-    # 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 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'
-    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/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,20 +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::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
 
@@ -45,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)
@@ -113,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)
@@ -121,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]
@@ -131,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.3'
+  VERSION = '1.0.0.pre.1'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: datastar
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta.3
+  version: 1.0.0.pre.1
 platform: ruby
 authors:
 - Ismael Celis
 bindir: exe
 cert_chain: []
-date: 2025-06-02 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -23,6 +23,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         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: []