lilac-async 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 74b33ed4f34980024dd25d7c7c0a615ff6f54ab2e0ce2576791b9f2d27892865
+  data.tar.gz: 6fa9799812eff39b4fb269a7f170f06f6187a2faa9573a09cd54e6825e11a2fd
+SHA512:
+  metadata.gz: f4d9aa41670489ba75dbeebd69b5dc7833570596437e8afe50f7d7da1abf94352adaadab63a4ee17feb0713ce52e4f3c4070b53cbaef5fff662ea924880865de
+  data.tar.gz: a8db560ce4e68567207f1216be1de7ad3e8a503b1054c3b9656f26865b5467dfb298c33acb1eba3e8d710fdecc03815e3ced2e2a0775faed2c2a98168f5ffe82

data/lilac-async.gemspec

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |spec|
+  spec.name = "lilac-async"
+  spec.version = "0.2.0"
+  spec.authors = ["takahashim"]
+
+  spec.summary = "Lilac package: async data primitives (Fetchy, Lilac::Resource, selector helpers)"
+  spec.description = "Provides the `Fetchy` HTTP client, `Lilac::Resource` " \
+                     "(signal-backed async data source), and selector " \
+                     "helpers (`selector` / `select`). Designed for the " \
+                     "lilac-compiled wasm variant; lilac-full already links " \
+                     "the async gem in. Picked up automatically by " \
+                     "`lilac build` via Bundler when the gem appears in the " \
+                     "project's Gemfile."
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2.0"
+
+  # See lilac-extras.gemspec for the mrblib source distribution rationale.
+  spec.files = Dir["mrblib/**/*.rb", "*.gemspec"]
+
+  spec.metadata = {
+    "lilac_package"         => "true",
+    "source_code_uri"       => "https://github.com/takahashim/lilac",
+    "rubygems_mfa_required" => "true",
+  }
+end

data/mrblib/fetchy.rb

@@ -0,0 +1,394 @@
+# Fetchy v2 — small HTTP DSL for Lilac / resource loaders.
+#
+# Callback API is intentionally not supported. The primary forms are:
+#
+#   data = Fetchy.json("/api/items")
+#
+#   user = resource(initial: nil) do |r|
+#     Fetchy.get("/api/users/#{@user_id.value}", signal: r.abort_signal).json
+#   end
+#
+# A block, when given, configures the request builder:
+#
+#   Fetchy.get("/api/items") do |f|
+#     f.timeout 5000
+#     f.header "Accept", "application/json"
+#   end.json
+class Fetchy
+  class Error < StandardError; end
+  class AbortError < Error; end
+  class TimeoutError < Error; end
+  class ParseError < Error; end
+
+  class HTTPError < Error
+    attr_reader :status, :status_text, :url, :response
+
+    def initialize(status, status_text, url, response = nil)
+      @status = status
+      @status_text = status_text
+      @url = url
+      @response = response
+      super("HTTP #{status}: #{status_text}")
+    end
+  end
+
+  class Builder
+    attr_reader :options
+
+    def initialize(opts = {})
+      @options = {
+        params: {},
+        headers: {},
+      }
+      apply(opts)
+    end
+
+    def param(name, value)
+      @options[:params][name.to_s] = value
+      self
+    end
+
+    def params(hash)
+      (hash || {}).each { |k, v| param(k, v) }
+      self
+    end
+
+    def header(name, value)
+      @options[:headers][name.to_s] = value
+      self
+    end
+
+    def headers(hash)
+      (hash || {}).each { |k, v| header(k, v) }
+      self
+    end
+
+    def json(value)
+      @options[:json] = value
+      self
+    end
+
+    def body(value)
+      @options[:body] = value
+      self
+    end
+
+    def timeout(ms)
+      @options[:timeout] = ms
+      self
+    end
+
+    def signal(abort_signal)
+      @options[:signal] = abort_signal
+      self
+    end
+
+    def base(url)
+      @options[:base] = url
+      self
+    end
+
+    def accept(type)
+      header("Accept", type)
+    end
+
+    def content_type(type)
+      header("Content-Type", type)
+    end
+
+    private
+
+    def apply(opts)
+      opts = opts.dup
+      params(opts.delete(:params))
+      headers(opts.delete(:headers))
+      json(opts.delete(:json)) if opts.key?(:json)
+      body(opts.delete(:body)) if opts.key?(:body)
+      timeout(opts.delete(:timeout)) if opts.key?(:timeout)
+      if opts.key?(:signal)
+        signal(opts.delete(:signal))
+      elsif (run = Lilac::Resource.current_run)
+        signal(run.abort_signal)
+      end
+      base(opts.delete(:base)) if opts.key?(:base)
+      accept(opts.delete(:accept)) if opts.key?(:accept)
+      content_type(opts.delete(:content_type)) if opts.key?(:content_type)
+      opts.each { |k, v| @options[k] = v }
+    end
+  end
+
+  class Response
+    def initialize(js_response, url)
+      @js_response = js_response
+      @url = url
+      @headers = nil
+    end
+
+    def status
+      @js_response[:status].to_i
+    end
+
+    def ok?
+      @js_response[:ok].js_bool
+    end
+
+    def url
+      u = @js_response[:url]
+      return @url if u.js_null? || u.to_s.empty?
+      u.to_s
+    end
+
+    def headers
+      return @headers if @headers
+      pairs = JS.global[:Array].call(:from, @js_response[:headers].call(:entries)).to_ruby
+      @headers = {}
+      pairs.each do |k, v|
+        @headers[k] = v
+        @headers[canonical_header_name(k)] ||= v
+      end
+      @headers
+    end
+
+    def text
+      @js_response.call(:text).await.to_s
+    end
+
+    def json
+      @js_response.call(:json).await.to_ruby
+    rescue JS::Error => e
+      raise ParseError, e.message
+    end
+
+    def body
+      @js_response[:body]
+    end
+
+    def bytes
+      @js_response.call(:arrayBuffer).await
+    end
+
+    private
+
+    def canonical_header_name(name)
+      name.to_s.split("-").map { |part| part[0] ? part[0].upcase + part[1..-1] : part }.join("-")
+    end
+  end
+
+  class Request
+    attr_reader :timeout_ms
+
+    def initialize(url, method:, options:)
+      @url = url.to_s
+      @method = method.to_s.upcase
+      @options = options
+      validate_options!
+      @controller = nil
+      @timeout_ms = @options[:timeout]
+      @aborted = false
+      @timed_out = false
+      @completed = false
+      @started = false
+      @settled_response = nil
+      @settled_error = nil
+    end
+
+    def abort
+      return if @aborted || @timed_out || @completed
+      @aborted = true
+      @controller&.call(:abort)
+      self
+    end
+
+    def aborted?
+      @aborted
+    end
+
+    def timed_out?
+      @timed_out
+    end
+
+    def completed?
+      @completed
+    end
+
+    def response
+      perform unless @started
+      raise @settled_error if @settled_error
+      @settled_response
+    end
+
+    def json
+      response.json
+    end
+
+    def text
+      response.text
+    end
+
+    def bytes
+      response.bytes
+    end
+
+    private
+
+    def perform
+      @started = true
+      url = build_url
+      controller_ctor = JS.global[:AbortController]
+      @controller = controller_ctor.js_null? ? nil : controller_ctor.new
+      @controller&.call(:abort) if @aborted
+      timer = wire_timeout
+      external = wire_external_signal
+
+      begin
+        response = JS.global.fetch(url, JS.object(build_init_hash)).await
+        wrapped = Response.new(response, url)
+        unless wrapped.ok?
+          raise HTTPError.new(wrapped.status, response[:statusText].to_s, wrapped.url, wrapped)
+        end
+        @settled_response = wrapped
+      rescue => e
+        @settled_error = classify_error(e, url)
+      ensure
+        clear_timeout(timer)
+        clear_external_signal(external)
+        @completed = true
+      end
+    end
+
+    def validate_options!
+      return unless @options.key?(:json) && @options.key?(:body)
+      raise ArgumentError, "Fetchy: pass either :json or :body, not both"
+    end
+
+    def build_url
+      url = @url
+      base = @options[:base]
+      if base && !base.empty? && !url.start_with?("http://", "https://", "//")
+        base = base.end_with?("/") ? base[0..-2] : base
+        tail = url.start_with?("/") ? url : "/#{url}"
+        url = base + tail
+      end
+
+      params = @options[:params] || {}
+      return url if params.empty?
+      encoded = params.map do |k, v|
+        "#{JS.encode_uri_component(k)}=#{JS.encode_uri_component(v)}"
+      end.join("&")
+      sep = url.include?("?") ? "&" : "?"
+      url + sep + encoded
+    end
+
+    def build_init_hash
+      headers = (@options[:headers] || {}).dup
+      init_h = { method: @method }
+
+      if @options.key?(:json)
+        init_h[:body] = Lilac::JSON.generate(@options[:json])
+        headers["Content-Type"] = "application/json" unless has_header?(headers, "content-type")
+      elsif @options.key?(:body)
+        init_h[:body] = @options[:body]
+      end
+
+      init_h[:headers] = headers unless headers.empty?
+      init_h[:signal] = @controller[:signal] if @controller
+      init_h
+    end
+
+    def has_header?(headers, name)
+      headers.keys.any? { |k| k.to_s.downcase == name }
+    end
+
+    def wire_timeout
+      return nil unless @timeout_ms
+      callback = JS.callback do
+        @timed_out = true
+        @controller&.call(:abort)
+      end
+      id = JS.global.call(:setTimeout, callback, @timeout_ms).to_i
+      [id, callback]
+    end
+
+    def clear_timeout(timer)
+      return unless timer
+      id, callback = timer
+      JS.global.call(:clearTimeout, id)
+      JS.release_callback(callback)
+    end
+
+    def wire_external_signal
+      signal = @options[:signal]
+      return nil if signal.nil? || signal.js_null? || @controller.nil?
+      callback = JS.callback do
+        @aborted = true
+        @controller.call(:abort)
+      end
+      signal.call(:addEventListener, "abort", callback)
+      if signal[:aborted].js_bool
+        @aborted = true
+        @controller.call(:abort)
+      end
+      [signal, callback]
+    end
+
+    def clear_external_signal(external)
+      return unless external
+      signal, callback = external
+      signal.call(:removeEventListener, "abort", callback)
+      JS.release_callback(callback)
+    end
+
+    def classify_error(err, url)
+      return TimeoutError.new("timeout after #{@timeout_ms}ms") if @timed_out
+      return AbortError.new("aborted") if @aborted
+      return err if err.is_a?(HTTPError)
+      if err.is_a?(JS::Error) && err.message.to_s.include?("AbortError")
+        return AbortError.new("aborted")
+      end
+      err
+    end
+  end
+
+  class << self
+    def get(url, **opts, &builder)
+      request(url, method: "GET", **opts, &builder)
+    end
+
+    def post(url, **opts, &builder)
+      request(url, method: "POST", **opts, &builder)
+    end
+
+    def put(url, **opts, &builder)
+      request(url, method: "PUT", **opts, &builder)
+    end
+
+    def patch(url, **opts, &builder)
+      request(url, method: "PATCH", **opts, &builder)
+    end
+
+    def delete(url, **opts, &builder)
+      request(url, method: "DELETE", **opts, &builder)
+    end
+
+    def request(url, method:, **opts, &builder)
+      built = Builder.new(opts)
+      builder.call(built) if builder
+      Request.new(url, method: method, options: built.options)
+    end
+
+    def json(url, **opts, &builder)
+      method = opts.key?(:method) ? opts.delete(:method) : "GET"
+      request(url, method: method, **opts, &builder).json
+    end
+
+    def text(url, **opts, &builder)
+      method = opts.key?(:method) ? opts.delete(:method) : "GET"
+      request(url, method: method, **opts, &builder).text
+    end
+
+    def bytes(url, **opts, &builder)
+      method = opts.key?(:method) ? opts.delete(:method) : "GET"
+      request(url, method: method, **opts, &builder).bytes
+    end
+  end
+end

data/mrblib/lilac_async.rb

@@ -0,0 +1,322 @@
+# Lilac async extensions.
+#
+# Loaded after core `mruby-lilac`. Houses the optional async / data
+# layer so apps that only need the reactive component core can omit it.
+
+module Lilac
+  module AsyncExtensions
+    def resource(initial: nil, defer: false, keep_value: true, &block)
+      raise ArgumentError, "block required" unless block
+      r = Resource.new(initial: initial, defer: defer, keep_value: keep_value, &block)
+      register_disposable("resource", r)
+      r
+    end
+
+    def selector(source, equals: nil)
+      s = Selector.new(source, equals: equals)
+      register_disposable("selector", s)
+      s
+    end
+  end
+
+  class SelectorEntry
+    include Reactive::Subscribable
+
+    def initialize
+      @subs = Subscribers.new
+    end
+  end
+
+  class Selector
+    include Reactive::Observer
+
+    def initialize(source, equals: nil)
+      raise ArgumentError, "selector source must respond to #value" unless source.respond_to?(:value)
+      @source = source
+      @equals = equals
+      @deps = []
+      @entries = {}
+      @value = nil
+      recompute
+    end
+
+    def call(key)
+      if (obs = Reactive.current)
+        entry = entry_for(key)
+        entry.subscribe(obs)
+        obs.add_dep(entry)
+      end
+      selected?(key)
+    end
+
+    def selected?(key)
+      compare(@value, key)
+    end
+
+    def notify
+      prev = @value
+      recompute
+      return if compare(prev, @value)
+      notify_entry(prev)
+      notify_entry(@value)
+    end
+
+    def dispose
+      remove_all_deps
+      @entries.clear
+    end
+
+    private
+
+    def recompute
+      remove_all_deps
+      Reactive.track(self) do
+        @value = @source.value
+      end
+    end
+
+    def notify_entry(key)
+      entry = @entries[key]
+      entry&.notify_subscribers
+    end
+
+    def entry_for(key)
+      @entries[key] ||= SelectorEntry.new
+    end
+
+    def compare(a, b)
+      return @equals.call(a, b) if @equals.respond_to?(:call)
+      a == b
+    end
+  end
+
+  class ResourceObserver
+    include Reactive::Observer
+
+    def initialize(resource)
+      @resource = resource
+      @deps = []
+      @disposed = false
+    end
+
+    def notify
+      return if @disposed
+      @resource.__observer_notified__(self)
+    end
+
+    # Override Observer#add_dep to guard against deps being added
+    # after dispose (e.g. a stale fiber resuming).
+    def add_dep(dep)
+      return if @disposed
+      super
+    end
+
+    def dispose
+      return if @disposed
+      @disposed = true
+      remove_all_deps
+    end
+  end
+
+  class ResourceRun
+    def initialize
+      ctor = JS.global[:AbortController]
+      @controller = ctor.js_null? ? nil : ctor.new
+      @cancelled = false
+      @null_signal = nil
+    end
+
+    def abort_signal
+      return @controller[:signal] if @controller
+      @null_signal ||= JS.wrap(nil)
+    end
+
+    def cancelled?
+      @cancelled
+    end
+
+    def __cancel__!
+      return if @cancelled
+      @cancelled = true
+      @controller&.call(:abort)
+    end
+  end
+
+  class Resource
+    # Per-fiber currently-executing `ResourceRun`, set by `start_run`
+    # around the user block. Read by `Fetchy::Builder` to default
+    # `signal:` when not explicitly provided, so a `Fetchy.json(url)`
+    # call inside a `resource { }` block auto-aborts on resource
+    # cancellation. Fiber-id keyed (like `Reactive::TRACKER`) so
+    # concurrent fibers don't trample each other.
+    CURRENT_RUNS = {}
+
+    def self.current_run
+      CURRENT_RUNS[fiber_key]
+    end
+
+    def self.fiber_key
+      fiber = ::Fiber.current
+      fiber ? fiber.__id__ : :main
+    end
+
+    # Set `run` as the current run for the duration of `yield`, then
+    # restore the previous value (or remove the entry if none).
+    def self.with_current_run(run)
+      key = fiber_key
+      prev = CURRENT_RUNS[key]
+      CURRENT_RUNS[key] = run
+      yield
+    ensure
+      prev.nil? ? CURRENT_RUNS.delete(key) : CURRENT_RUNS[key] = prev
+    end
+
+    def initialize(initial:, defer:, keep_value:, &block)
+      raise ArgumentError, "block required" unless block
+      @block = block
+      @initial = initial
+      @keep_value = keep_value
+      @value_signal = Signal.new(initial)
+      @error_signal = Signal.new(nil)
+      @state_signal = Signal.new(:idle)
+      @has_value = false
+      @disposed = false
+      @current_observer = nil
+      @current_run = nil
+      start_run unless defer
+    end
+
+    def value
+      @value_signal.value
+    end
+
+    def error
+      @error_signal.value
+    end
+
+    def state
+      @state_signal.value
+    end
+
+    def loading?
+      s = @state_signal.value
+      s == :pending || s == :refreshing
+    end
+
+    def idle?
+      @state_signal.value == :idle
+    end
+
+    def ready?
+      @state_signal.value == :ready
+    end
+
+    def refreshing?
+      @state_signal.value == :refreshing
+    end
+
+    def errored?
+      @state_signal.value == :errored
+    end
+
+    def reload
+      start_run
+      self
+    end
+
+    def mutate(&block)
+      raise ArgumentError, "block required" unless block
+      ret = @value_signal.update(&block)
+      @has_value = true
+      ret
+    end
+
+    def reset
+      return if @disposed
+      cancel_current
+      Lilac.batch do
+        @value_signal.value = @initial
+        @error_signal.value = nil
+        @state_signal.value = :idle
+      end
+      @has_value = false
+      self
+    end
+
+    def dispose
+      return if @disposed
+      @disposed = true
+      cancel_current
+      @current_observer&.dispose
+      @current_observer = nil
+    end
+
+    def __observer_notified__(observer)
+      return observer.dispose if @disposed
+      return observer.dispose unless observer.equal?(@current_observer)
+      start_run
+    end
+
+    private
+
+    def start_run
+      return if @disposed
+      previous = @current_observer
+      previous&.dispose
+      cancel_current
+
+      observer = ResourceObserver.new(self)
+      run = ResourceRun.new
+      @current_observer = observer
+      @current_run = run
+
+      Lilac.batch do
+        @value_signal.value = @initial if !@keep_value || !@has_value
+        @error_signal.value = nil
+        @state_signal.value = (@keep_value && @has_value) ? :refreshing : :pending
+      end
+
+      JS.__run_in_fiber__ do
+        Resource.with_current_run(run) do
+          begin
+            result = Reactive.track(observer) { @block.call(run) }
+            settle_success(observer, run, result)
+          rescue => e
+            settle_error(observer, run, e)
+          end
+        end
+      end
+    end
+
+    def settle_success(observer, run, result)
+      return observer.dispose if stale_run?(observer, run)
+      @current_run = nil
+      Lilac.batch do
+        @value_signal.value = result
+        @error_signal.value = nil
+        @state_signal.value = :ready
+      end
+      @has_value = true
+    end
+
+    def settle_error(observer, run, error)
+      return observer.dispose if stale_run?(observer, run)
+      @current_run = nil
+      Lilac.batch do
+        @error_signal.value = error
+        @state_signal.value = :errored
+      end
+    end
+
+    def stale_run?(observer, run)
+      !observer.equal?(@current_observer) || !run.equal?(@current_run)
+    end
+
+    def cancel_current
+      @current_run&.__cancel__!
+      @current_run = nil
+    end
+  end
+
+  Component.include(AsyncExtensions)
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: lilac-async
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- takahashim
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Provides the `Fetchy` HTTP client, `Lilac::Resource` (signal-backed async
+  data source), and selector helpers (`selector` / `select`). Designed for the lilac-compiled
+  wasm variant; lilac-full already links the async gem in. Picked up automatically
+  by `lilac build` via Bundler when the gem appears in the project's Gemfile.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lilac-async.gemspec
+- mrblib/fetchy.rb
+- mrblib/lilac_async.rb
+licenses:
+- MIT
+metadata:
+  lilac_package: 'true'
+  source_code_uri: https://github.com/takahashim/lilac
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: 'Lilac package: async data primitives (Fetchy, Lilac::Resource, selector
+  helpers)'
+test_files: []