stream_weaver 0.3.0

data/lib/stream_weaver/opal_entry.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+# backtick_javascript: true
+# Browser-only require tree. Does NOT require Sinatra, Phlex, AlpineJS,
+# iTerm, service, service_client, admin, streamer, feed, or cli.
+
+require "stream_weaver/version"
+require "stream_weaver/utils"
+require "stream_weaver/css"   # layer_wrap, for per-component CSS injection
+require "stream_weaver/theme"
+require "stream_weaver/display_dsl"
+require "stream_weaver/app"
+require "stream_weaver/components"
+require "stream_weaver/adapter/base"
+# Phase 1 placeholders — implemented in subsequent tasks:
+require "stream_weaver/adapter/opal"
+require "stream_weaver/opal/renderer"
+require "stream_weaver/opal/runtime"
+require "stream_weaver/opal/bridge"
+require "stream_weaver/opal/string_bridge"
+
+# Opal-specific patches: fix methods that break in the browser.
+
+# App#button and DisplayDSL#button use block.source_location.join(':').
+# In Opal, source_location returns nil (no source maps in compiled JS).
+# Override button in App to use a counter-based stable_id instead.
+module StreamWeaver
+  module Opal
+    module AppButtonPatch
+      # Opal: source_location is nil — use counter-based IDs. Counter ids are
+      # already unique per render, so there is nothing to disambiguate here;
+      # id:/key: are still honored (same id: > key: > auto precedence) so a
+      # keyed button keeps its identity across rerenders, and so neither
+      # option leaks into the rendered element's attributes.
+      def button(label, key: nil, id: nil, **options, &block)
+        @button_counter += 1
+        identity = id || key
+        stable_id = identity ? "opal_#{identity}" : "opal_#{@button_counter}"
+        options[:modal_context] = @modal_context if @modal_context
+        @components << Components::Button.new(label, stable_id, **options, &block)
+      end
+    end
+  end
+end
+StreamWeaver::App.prepend StreamWeaver::Opal::AppButtonPatch
+
+module StreamWeaver
+  module Opal
+    module AppReactivePatch
+      def watch(key, &block)
+        rt = OpalRuntime.current
+        return unless rt && !rt.watchers_initialized?
+        rt.state.watch(key) do |val|
+          block.call(val)
+          rt.schedule_rerender
+        end
+      end
+
+      def on_start(&block)
+        OpalRuntime.current&.register_start_hook(block)
+      end
+
+      def after(seconds, &block)
+        return unless RUBY_ENGINE == "opal"
+        ms = (seconds * 1000).to_i
+        cb = block
+        # :nocov:
+        %x{ setTimeout(function() { #{cb.call} }, #{ms}) }
+        # :nocov:
+      end
+
+      def every(seconds, &block)
+        return unless RUBY_ENGINE == "opal"
+        ms = (seconds * 1000).to_i
+        cb = block
+        # :nocov:
+        %x{ setInterval(function() { #{cb.call} }, #{ms}) }
+        # :nocov:
+      end
+
+      def defer(&block)
+        return unless RUBY_ENGINE == "opal"
+        cb = block
+        # :nocov:
+        %x{ setTimeout(function() { #{cb.call} }, 0) }
+        # :nocov:
+      end
+    end
+  end
+end
+StreamWeaver::App.prepend StreamWeaver::Opal::AppReactivePatch
+
+# Opal-mode global `app` helper — replaces the Sinatra-wired StreamWeaver.app.
+# Creates an OpalRuntime with the DSL block, publishes it to JavaScript, and
+# returns the runtime.
+#
+# Two bridges, because the same compiled bundle runs in two hosts. OpalBridge
+# (window.SWRuntime: patching, event delegation) needs a DOM and installs only
+# when it finds one, so loading this bundle in Node no longer explodes on the
+# missing `window`. StringBridge (globalThis.SWRender) needs nothing and always
+# installs, which is what gives a Node process a way to render the doc to a
+# string. `app()` keeps its original signature so existing browser builds and
+# opal-build output are unaffected.
+module StreamWeaver
+  # App#initialize (app.rb) calls StreamWeaver.strict_ids? unconditionally
+  # to seed @strict_ids when the caller doesn't pass strict_ids: explicitly.
+  # The real definition (lib/stream_weaver.rb) checks an ivar + the
+  # SW_STRICT_IDS env var, but that file also requires server/service/cli/
+  # admin/iterm -- none of them Opal-compatible, which is exactly why this
+  # file (opal_entry.rb) requires app.rb directly and never requires
+  # lib/stream_weaver.rb itself. That left StreamWeaver.strict_ids?
+  # undefined in every Opal build (this extension, opal-build's standalone
+  # HTML output) the moment app.rb started calling it -- "undefined method
+  # `strict_ids?' for StreamWeaver", reproduced live against a rebuilt
+  # extension bundle. Always false here, not a stub of the real check: both
+  # Opal hosts only ever render a doc once, non-interactively (SWRuntime.
+  # start() is never called for the extension's static preview; opal-build's
+  # standalone HTML is likewise a one-shot render), so there is no
+  # interactive id-collision risk for strict mode to catch in either one.
+  def self.strict_ids?
+    false
+  end
+
+  module Opal
+    module Kernel
+      def app(title, **_opts, &block)
+        adapter = Adapter::Opal.new
+        runtime = OpalRuntime.new(adapter: adapter)
+        runtime.set_block(&block)
+        OpalBridge.new(runtime).install
+        StringBridge.new(runtime, title: title).install
+        runtime
+      end
+    end
+  end
+end
+include StreamWeaver::Opal::Kernel

data/lib/stream_weaver/org/inline.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module StreamWeaver
+  module Org
+    # Bidirectional inline markup conversion between markdown (as used inside
+    # `md "..."` DSL calls) and org-mode inline syntax. Boundary-aware: a
+    # delimiter only opens/closes a span when flanked the way org itself
+    # requires, so literal characters in file paths ("app/admin/cms/foo.rb")
+    # or "X / Y" phrasing are never misread as emphasis markers.
+    module Inline
+      PRE  = /(?:\A|[\s\("])/.source
+      POST = /(?:\z|[\s\.,;:!?\)"])/.source
+
+      # Lookaround (not capturing) so the boundary character is never
+      # "consumed" -- otherwise two adjacent spans sharing one space between
+      # them ("*a* *b*") corrupt into one mismatched span, since the shared
+      # space gets eaten as POST of the first match and is then unavailable
+      # as PRE for the second. Content also excludes the delimiter itself
+      # (not just the first/last char) -- this is what stops ITALIC_MD's
+      # single-"*" pattern from misreading BOLD_MD's doubled "**" markers as
+      # its own boundary (the second "*" of "**bold**" can never be content).
+      def self.span(delim)
+        d = Regexp.escape(delim)
+        /(?<=#{PRE})#{d}([^\s#{d}](?:[^#{d}]*?[^\s#{d}])?)#{d}(?=#{POST})/m
+      end
+
+      # Code/verbatim spans have no doubled-marker sibling to disambiguate
+      # against (unlike "*"/"**"), so unlike span() this allows the delimiter
+      # itself inside the content -- real code routinely contains "="
+      # (e.g. "queued=true"). The trailing group must be a LAZY optional
+      # (`??`, not `?`) -- a greedy optional always tries "include extra
+      # content" first, and backtracking from there finds the *last* valid
+      # closing delimiter on the line, bridging separate spans ("`a` `b`"
+      # -> content "a` `b"). Lazy-optional tries "no extra content" first,
+      # so it finds the *nearest* closing delimiter whose following
+      # character satisfies POST -- correct for both a single span whose
+      # content happens to contain the delimiter, and two adjacent spans.
+      def self.code_span(delim)
+        d = Regexp.escape(delim)
+        /(?<=#{PRE})#{d}([^\s](?:.*?[^\s])??)#{d}(?=#{POST})/m
+      end
+
+      BOLD_MD   = span("**")
+      ITALIC_MD = span("*")
+      CODE_MD   = code_span("`")
+      # Org's own [[target][text]] link is generic across target shapes --
+      # an internal #anchor, a relative path, an external URL, all render
+      # identically as a plain <a href> in a real org viewer (verified
+      # against org-ruby, the gem GitHub/markymark also use: stream_weaver-043f).
+      # No "#" requirement, so neither should this converter's match.
+      LINK_MD   = /\[([^\]]+)\]\(([^\)]+)\)/
+
+      BOLD_ORG   = span("*")
+      ITALIC_ORG = span("/")
+      CODE_ORG   = code_span("=")
+      LINK_ORG   = /\[\[([^\]]+)\]\[([^\]]+)\]\]/
+
+      PLACEHOLDER = "\x00CODE%d\x00"
+      PLACEHOLDER_RE = /\x00CODE(\d+)\x00/
+
+      def self.md_to_org(text)
+        text, protected_spans = extract(text, CODE_MD)
+        text = text.gsub(LINK_MD) { "[[#{$2}][#{$1}]]" }
+        text = text.gsub(ITALIC_MD) { "/#{$1}/" }
+        text = text.gsub(BOLD_MD) { "*#{$1}*" }
+        text = text.gsub(/~(?=\d)/, "≈")
+        restore(text, protected_spans) { |content| "=#{content}=" }
+      end
+
+      def self.org_to_md(text)
+        text, protected_spans = extract(text, CODE_ORG)
+        text = text.gsub(LINK_ORG) { "[#{$2}](#{$1})" }
+        text = text.gsub(BOLD_ORG) { "**#{$1}**" }
+        text = text.gsub(ITALIC_ORG) { "*#{$1}*" }
+        restore(text, protected_spans) { |content| "`#{content}`" }
+      end
+
+      # Replaces every code/verbatim span with a placeholder token so later
+      # passes (link/bold/italic/tilde) never see -- and can't corrupt --
+      # content that's supposed to stay literal.
+      def self.extract(text, code_pattern)
+        spans = []
+        replaced = text.gsub(code_pattern) do
+          spans << $1
+          PLACEHOLDER % (spans.length - 1)
+        end
+        [replaced, spans]
+      end
+
+      def self.restore(text, spans)
+        text.gsub(PLACEHOLDER_RE) { yield spans[$1.to_i] }
+      end
+    end
+  end
+end