duoruby 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f3074e802c24846379df300d0012092cd00a18513fe87bf1a62d757bb0d1fe4
-  data.tar.gz: 3603e0dbc7808566d8cec775a0513068438fe9456fd322aa6f53ca534d5c0142
+  metadata.gz: 340349cc6d514408915a76db23e509316ab458350cee20e45150ecf19d2e0801
+  data.tar.gz: a1314f3199d5a896408c522e830152565f54d2da6072ebcd8f5d3a59f1009ffb
 SHA512:
-  metadata.gz: f0cad5cb7f45d9801398bb6d3e2f945f35e3178407ebcf6a781aab081ca0d5b73ede700ce27ab656005b935e11c8ba782b130dc08eb7578daf0278bf1b2218f9
-  data.tar.gz: b5e8e428393c969a3aaf2e161ab0307efc965364230de19fb095c4cf93ba92adff574b2b861bdceaec1cd6d4326245b26e2d0ea83848635e7e87bd994f606638
+  metadata.gz: 92a4603982bff2d9ddc1c83f837dbb6a154a3adae7bb05f3a059ccb1b99f5ab97135a001f9ca9b69d6583d1c0258aacce918ea95ce8a9f3c3c29961feb2a53bf
+  data.tar.gz: 941b8c259f7917f95f7a24c8843f8f071e7dbb90b46527cd7411147d356cfeecfcf41e9e0329adc0fca02aaeef134c13b929ef33d71c0b333d54444acee6eeaf

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## v0.1.1 - 2026-05-17
+
+- Moved native launch ownership onto `DuoRuby::Server#launch`; `duoruby launch` now builds the application server and launches that instance.
+- Removed the separate `DuoRuby::Launcher` API.
+- Reversed launch process ownership so the main process runs the server and the forked child owns the native webview.
+- Added block-style channel namespaces for `on` and `send`, including both `channel(:name) { ... }` and yielded `channel(:name) { |namespace| ... }` forms.
+- Stopped tracking `Gemfile.lock` files in the gem and examples.
+
+## v0.1.0 - 2026-05-17
+
+- Initial prerelease.

data/lib/duoruby/channel/handler_methods.rb

@@ -23,8 +23,8 @@ module DuoRuby
         remove_handler(handlers, event, handler || block)
       end
 
-      def channel(name)
-        Namespace.new(self, name)
+      def channel(name, &block)
+        Namespace.call(self, name, &block)
       end
 
       def included(receiver)

data/lib/duoruby/channel/namespace.rb

@@ -3,6 +3,14 @@
 module DuoRuby
   class Channel
     class Namespace
+      def self.call(target, name, &block)
+        namespace = new(target, name)
+        return namespace unless block
+        return block.call(namespace) if block.arity.positive?
+
+        namespace.instance_exec(&block)
+      end
+
       def initialize(target, name)
         @target = target
         @name = name.to_s

data/lib/duoruby/channel.rb

@@ -95,8 +95,8 @@ module DuoRuby
       handlers.delete(event) if handlers[event]&.empty?
     end
 
-    def channel(name)
-      Namespace.new(self, name)
+    def channel(name, &block)
+      Namespace.call(self, name, &block)
     end
 
     # Returns a Proc wrapping the first registered handler for +event+, bound

data/lib/duoruby/cli.rb

@@ -78,9 +78,12 @@ module DuoRuby
       options = launch_options
       return 1 unless options
 
-      require "duoruby/launcher"
+      require "duoruby/server"
+
+      server_config = server_options(options)
+      server_config[:port] ||= free_port(server_config.fetch(:host, "127.0.0.1"))
 
-      DuoRuby::Launcher.new(**options).run(output: @output)
+      DuoRuby::Server.build(**server_config).launch(**window_options(options), output: @output)
       0
     end
 
@@ -115,6 +118,23 @@ module DuoRuby
       options
     end
 
+    def server_options(options)
+      options.slice(:root, :host, :port)
+    end
+
+    def window_options(options)
+      options.slice(:title)
+    end
+
+    def free_port(host)
+      require "socket"
+
+      server = TCPServer.new(host, 0)
+      server.addr[1]
+    ensure
+      server&.close
+    end
+
     # Parses the options that follow the +serve+ command.
     #
     # @return [Hash, nil] option hash on success, +nil+ on parse failure

data/lib/duoruby/client.rb

@@ -75,8 +75,8 @@ module DuoRuby
       @writer.call(Message.coerce(message).to_h)
     end
 
-    def channel(name)
-      Channel::Namespace.new(self, name)
+    def channel(name, &block)
+      Channel::Namespace.call(self, name, &block)
     end
 
     def resolve_call(message)

data/lib/duoruby/group.rb

@@ -28,8 +28,8 @@ module DuoRuby
         self
       end
 
-      def channel(name)
-        Channel::Namespace.new(self, name)
+      def channel(name, &block)
+        Channel::Namespace.call(self, name, &block)
       end
 
       private
@@ -96,8 +96,8 @@ module DuoRuby
       self
     end
 
-    def channel(name)
-      Channel::Namespace.new(self, name)
+    def channel(name, &block)
+      Channel::Namespace.call(self, name, &block)
     end
 
     # Sends +event+ with +params+ to every current member.

data/lib/duoruby/server.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "socket"
 require "uri"
 require "async"
 require "async/http/endpoint"
@@ -26,6 +27,9 @@ module DuoRuby
   #
   # @example Starting the server from application code
   #   DuoRuby::Server.build(root: __dir__, port: 3000).run
+  #
+  # @example Starting the server and opening a native window
+  #   DuoRuby::Server.build(root: __dir__).launch
   class Server < Channel
     require "duoruby/server/frontend_compiler"
 
@@ -112,6 +116,31 @@ module DuoRuby
       end
     end
 
+    # Forks a native browser window into a child process, then runs this server
+    # in the main process. Blocks until the server exits or the window closes.
+    #
+    # @param output [IO] where to print the launch banner (default: +$stdout+)
+    # @param title [String, nil] native window title; +nil+ uses +DuoRuby.config.title+
+    # @param width [Integer] native window width in pixels
+    # @param height [Integer] native window height in pixels
+    def launch(output: $stdout, title: nil, width: 1280, height: 800)
+      output.puts "launching http://#{host}:#{port}"
+
+      browser_pid = fork_process { run_browser(title: title, width: width, height: height) }
+      browser_watchdog = start_browser_watchdog(browser_pid)
+
+      null_output = File.open(File::NULL, "w")
+      run(output: null_output)
+    rescue Interrupt
+      nil
+    ensure
+      null_output&.close
+      if browser_pid
+        browser_watchdog&.kill
+        terminate_process(browser_pid)
+      end
+    end
+
     # Compiles the Opal frontend to a JavaScript string.
     #
     # Resets Opal's global path state, adds configured frontend gems, then
@@ -201,6 +230,48 @@ module DuoRuby
       }
     end
 
+    # Runs the browser in the child process.
+    def run_browser(title:, width:, height:)
+      wait_for_server
+
+      require "webview_util"
+
+      window_title = title || DuoRuby.config.title
+      window = WebviewUtil::Window.new(title: window_title, width: width, height: height)
+      window.navigate("http://#{host}:#{port}")
+      window.run
+    end
+
+    # Polls until the server is accepting TCP connections.
+    def wait_for_server
+      loop do
+        TCPSocket.new(host, port).close
+        break
+      rescue Errno::ECONNREFUSED
+        sleep 0.05
+      end
+    end
+
+    def fork_process(&block) = fork(&block)
+
+    def start_browser_watchdog(browser_pid)
+      Thread.new do
+        wait_process(browser_pid)
+        interrupt_server
+      rescue Errno::ECHILD
+        nil
+      end
+    end
+
+    def terminate_process(pid)
+      Process.kill(:TERM, pid) rescue nil
+      wait_process(pid) rescue nil
+    end
+
+    def wait_process(pid) = Process.waitpid(pid)
+
+    def interrupt_server = Thread.main.raise(Interrupt)
+
     # Returns the HTML shell response.
     def html
       body = <<~HTML

data/lib/duoruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DuoRuby
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: duoruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - DuoRuby contributors
@@ -172,6 +172,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE.txt
 - README.md
 - exe/duoruby
@@ -184,7 +185,6 @@ files:
 - lib/duoruby/client.rb
 - lib/duoruby/config.rb
 - lib/duoruby/group.rb
-- lib/duoruby/launcher.rb
 - lib/duoruby/message.rb
 - lib/duoruby/reply_error.rb
 - lib/duoruby/reply_promise.rb

data/lib/duoruby/launcher.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-require "socket"
-require "duoruby/config"
-require "webview_util"
-
-module DuoRuby
-  # Starts the server in a child process and opens a native webview window
-  # on the main process's main thread.
-  #
-  # GTK requires all calls on the thread that called gtk_init (the OS main
-  # thread). The Async/Falcon server runs in a forked child process so each
-  # has full ownership of its own event loop. When the window is closed the
-  # child is terminated; when the child dies unexpectedly the window closes.
-  #
-  # The window title defaults to +DuoRuby.config.title+, which the application
-  # can set in its +duoruby.rb+ config file:
-  #
-  #   DuoRuby.configure { |c| c.title = "My App" }
-  #
-  # @example
-  #   DuoRuby::Launcher.new(root: __dir__).run
-  class Launcher
-    # @param root   [String]       application root directory
-    # @param host   [String]       server host (default: +"127.0.0.1"+)
-    # @param port   [Integer, nil] server port; +nil+ picks a free port automatically
-    # @param title  [String, nil]  window title; +nil+ uses +DuoRuby.config.title+
-    # @param width  [Integer]      window width in pixels (default: +1280+)
-    # @param height [Integer]      window height in pixels (default: +800+)
-    def initialize(root: Dir.pwd, host: "127.0.0.1", port: nil,
-                   title: nil, width: 1280, height: 800)
-      @root   = File.expand_path(root)
-      @host   = host
-      @port   = port || free_port
-      @title  = title
-      @width  = width
-      @height = height
-    end
-
-    # Forks the Async server into a child process, then opens the native
-    # window on the main thread. Blocks until the window is closed, then
-    # terminates the server child.
-    #
-    # @param output [IO] where to print the launch banner (default: +$stdout+)
-    def run(output: $stdout)
-      output.puts "launching http://#{@host}:#{@port}"
-
-      server_pid = fork { run_server }
-
-      wait_for_server
-
-      title = @title || DuoRuby.config.title
-      window = WebviewUtil::Window.new(title: title, width: @width, height: @height)
-      window.navigate("http://#{@host}:#{@port}")
-      window.run
-    ensure
-      if server_pid
-        Process.kill(:TERM, server_pid) rescue nil
-        Process.waitpid(server_pid) rescue nil
-      end
-    end
-
-    private
-
-    # Runs the server in the child process.
-    def run_server
-      require "console"
-      require "duoruby/server"
-      Console.logger.fatal!
-      Server.build(root: @root, host: @host, port: @port)
-            .run(output: File.open(File::NULL, "w"))
-    end
-
-    # Allocates a free TCP port by binding to port 0 and reading the assigned port.
-    def free_port
-      server = TCPServer.new(@host, 0)
-      server.addr[1]
-    ensure
-      server&.close
-    end
-
-    # Polls until the server is accepting TCP connections.
-    def wait_for_server
-      loop do
-        TCPSocket.new(@host, @port).close
-        break
-      rescue Errno::ECONNREFUSED
-        sleep 0.05
-      end
-    end
-  end
-end