zui 0.0.1

data/lib/zui/scheduler.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Zui
+  class Task
+    attr_reader :kind, :interval, :block
+
+    def initialize(kind:, interval:, immediate:, block:)
+      @kind = kind
+      @interval = interval
+      @immediate = immediate
+      @block = block
+      @mutex = Mutex.new
+      @condition = ConditionVariable.new
+      @cancelled = false
+      @thread = nil
+    end
+
+    def start(evaluator, on_error)
+      @mutex.synchronize do
+        return self if @cancelled || @thread
+        if Object.const_defined?(:Thread)
+          @thread = Thread.new { run(evaluator, on_error) }
+          @thread.name = "zui-#{kind}" if @thread.respond_to?(:name=)
+        else
+          @thread = :cooperative
+          @evaluator = evaluator
+          @on_error = on_error
+          @next_due = Time.now.to_f + ((kind == :async || @immediate) ? 0 : interval)
+        end
+      end
+      self
+    end
+
+    def cancel
+      @mutex.synchronize do
+        @cancelled = true
+        @condition.broadcast
+      end
+      self
+    end
+
+    def join(timeout = nil)
+      thread = @mutex.synchronize { @thread }
+      thread.join(timeout) if thread && thread != :cooperative
+      self
+    end
+
+    def tick(now = Time.now.to_f)
+      return unless @thread == :cooperative || !Object.const_defined?(:Thread)
+      return if cancelled? || now < @next_due
+      invoke(@evaluator, @on_error)
+      if kind == :every
+        @next_due = now + interval
+      else
+        cancel
+      end
+    end
+
+    def cancelled?
+      @mutex.synchronize { @cancelled }
+    end
+
+    private
+
+    def run(evaluator, on_error)
+      case kind
+      when :async then invoke(evaluator, on_error)
+      when :after then invoke(evaluator, on_error) if wait(interval)
+      when :every
+        invoke(evaluator, on_error) if @immediate && !cancelled?
+        while wait(interval)
+          invoke(evaluator, on_error)
+        end
+      end
+    end
+
+    def wait(seconds)
+      @mutex.synchronize do
+        @condition.wait(@mutex, seconds) unless @cancelled
+        !@cancelled
+      end
+    end
+
+    def invoke(evaluator, on_error)
+      evaluator.call(block) unless cancelled?
+    rescue StandardError => error
+      on_error.call(error)
+    end
+  end
+
+  class Scheduler
+    def initialize(evaluator:, on_error:)
+      @evaluator = evaluator
+      @on_error = on_error
+      @tasks = []
+      @lock = Mutex.new
+      @started = false
+    end
+
+    def schedule(kind, interval: 0, immediate: false, &block)
+      raise ArgumentError, "task requires a block" unless block
+      seconds = Float(interval)
+      raise ArgumentError, "task interval must be positive" if kind != :async && !seconds.positive?
+      task = Task.new(kind:, interval: seconds, immediate:, block:)
+      @lock.synchronize do
+        @tasks << task
+        task.start(@evaluator, @on_error) if @started
+      end
+      task
+    end
+
+    def start
+      @lock.synchronize do
+        @started = true
+        @tasks.each { |task| task.start(@evaluator, @on_error) }
+      end
+      self
+    end
+
+    def stop
+      tasks = @lock.synchronize do
+        @started = false
+        @tasks.dup
+      end
+      tasks.each(&:cancel)
+      tasks.each { |task| task.join(1) }
+      self
+    end
+
+    def tick(now = Time.now.to_f)
+      tasks = @lock.synchronize { @tasks.dup }
+      tasks.each { |task| task.tick(now) }
+      self
+    end
+  end
+end

data/lib/zui/source_bundle.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Zui
+  class SourceBundle
+    REQUIRE_RELATIVE = /\A\s*require_relative\s*(?:\(\s*)?["']([^"']+)["']\s*\)?\s*(?:#.*)?\z/
+
+    def initialize(entrypoint, root: File.dirname(entrypoint), embedded_frameworks: ["zui"])
+      @entrypoint = File.expand_path(entrypoint)
+      @root = File.expand_path(root)
+      frameworks = Array(embedded_frameworks).map(&:to_s)
+      raise ArgumentError, "embedded framework names cannot be empty" if frameworks.any?(&:empty?)
+
+      names = frameworks.map { |name| Regexp.escape(name) }.join("|")
+      @embedded_framework_require = /\A\s*require\s*(?:\(\s*)?["'](?:#{names})["']\s*\)?\s*(?:#.*)?\z/
+      @loaded = {}
+      @loading = []
+    end
+
+    def call
+      expand(@entrypoint)
+    end
+
+    private
+
+    def expand(path)
+      path = ruby_path(File.expand_path(path))
+      ensure_inside_root!(path)
+      return "" if @loaded[path]
+      raise ArgumentError, "circular require_relative: #{relative(path)}" if @loading.include?(path)
+      raise ArgumentError, "required Ruby file not found: #{relative(path)}" unless File.file?(path)
+
+      @loading << path
+      source = File.readlines(path, chomp: true).map do |line|
+        match = REQUIRE_RELATIVE.match(line)
+        if match
+          expand(File.expand_path(match[1], File.dirname(path)))
+        elsif @embedded_framework_require.match?(line)
+          ""
+        else
+          line
+        end
+      end.join("\n")
+      @loaded[path] = true
+      "# source: #{relative(path)}\n#{source}\n"
+    ensure
+      @loading.pop if @loading.last == path
+    end
+
+    def ruby_path(path)
+      File.extname(path).empty? ? "#{path}.rb" : path
+    end
+
+    def ensure_inside_root!(path)
+      return if path == @root || path.start_with?("#{@root}#{File::SEPARATOR}")
+
+      raise ArgumentError, "require_relative escapes the application directory: #{path}"
+    end
+
+    def relative(path)
+      path.delete_prefix("#{@root}#{File::SEPARATOR}")
+    end
+  end
+end

data/lib/zui/state_store.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Zui
+  class StateStore
+    def initialize(on_change)
+      @values = {}
+      @on_change = on_change
+      @lock = Mutex.new
+      @transaction_depth = 0
+      @pending = {}
+    end
+
+    def define(name, initial)
+      key = name.to_sym
+      @lock.synchronize do
+        raise ArgumentError, "state already defined: #{key}" if @values.key?(key)
+        @values[key] = initial
+      end
+    end
+
+    def [](name)
+      @lock.synchronize { @values.fetch(name.to_sym) }
+    end
+
+    def []=(name, value)
+      write(name.to_sym, value)
+    end
+
+    def update(name)
+      raise ArgumentError, "update requires a block" unless block_given?
+      key = name.to_sym
+      change, value = @lock.synchronize do
+        raise NoMethodError, "unknown state: #{key}" unless @values.key?(key)
+        next_value = yield(@values[key])
+        [store_locked(key, next_value), next_value]
+      end
+      @on_change.call(*change) if change
+      value
+    end
+
+    def method_missing(name, *arguments)
+      raw = name.to_s
+      if raw.end_with?("=")
+        raise ArgumentError, "expected one value" unless arguments.length == 1
+
+        return write(raw.delete_suffix("=").to_sym, arguments.first)
+      end
+      if arguments.empty?
+        found, value = @lock.synchronize { [@values.key?(name), @values[name]] }
+        return value if found
+      end
+
+      super
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      key = name.to_s.delete_suffix("=").to_sym
+      @lock.synchronize { @values.key?(key) } || super
+    end
+
+    def transaction
+      raise ArgumentError, "transaction requires a block" unless block_given?
+      @lock.synchronize { @transaction_depth += 1 }
+      yield self
+    ensure
+      changes = @lock.synchronize do
+        @transaction_depth -= 1
+        next [] unless @transaction_depth.zero?
+        flushed = @pending.values
+        @pending.clear
+        flushed
+      end
+      changes.each { |change| @on_change.call(*change) }
+    end
+
+    private
+
+    def write(key, value)
+      change = @lock.synchronize do
+        raise NoMethodError, "unknown state: #{key}" unless @values.key?(key)
+        store_locked(key, value)
+      end
+      @on_change.call(*change) if change
+      value
+    end
+
+    def store_locked(key, value)
+      return nil if @values[key] == value
+      previous = @values[key]
+      @values[key] = value
+      if @transaction_depth.positive?
+        @pending[key] ||= [key, previous, value]
+        @pending[key][2] = value
+        nil
+      else
+        [key, previous, value]
+      end
+    end
+  end
+end

data/lib/zui/value.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Zui
+  module Value
+    MAX_DEPTH = 32
+    MAX_ITEMS = 10_000
+    def normalize(value, property: nil, depth: 0, seen: {}, count: [0])
+      raise ArgumentError, "property value exceeds #{MAX_DEPTH} levels: #{property}" if depth > MAX_DEPTH
+      count[0] += 1
+      raise ArgumentError, "property value exceeds #{MAX_ITEMS} items: #{property}" if count[0] > MAX_ITEMS
+
+      case value
+      when Symbol then value.to_s
+      when String, TrueClass, FalseClass, NilClass, Integer then value
+      when Float
+        raise ArgumentError, "property number must be finite: #{property}" unless value.finite?
+        value
+      when Array
+        guard_cycle(value, property, seen) do
+          value.map { |item| normalize(item, property:, depth: depth + 1, seen:, count:) }
+        end
+      when Hash
+        guard_cycle(value, property, seen) do
+          value.each_with_object({}) do |(key, item), result|
+            result[key.to_s] = normalize(item, property:, depth: depth + 1, seen:, count:)
+          end
+        end
+      else
+        raise ArgumentError, "unsupported property value for #{property}: #{value.class}"
+      end
+    end
+
+    def guard_cycle(value, property, seen)
+      identity = value.object_id
+      raise ArgumentError, "cyclic property value: #{property}" if seen[identity]
+      seen[identity] = true
+      yield
+    ensure
+      seen.delete(identity)
+    end
+
+    module_function :normalize, :guard_cycle
+  end
+end

data/lib/zui.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "zui/protocol"
+require_relative "zui/value"
+require_relative "zui/state_store"
+require_relative "zui/node"
+require_relative "zui/animation"
+require_relative "zui/scheduler"
+require_relative "zui/command"
+require_relative "zui/component_registry"
+require_relative "zui/components"
+require_relative "zui/builder"
+require_relative "zui/application"
+require_relative "zui/source_bundle"
+require_relative "zui/platform"
+require_relative "zui/runtime"
+require_relative "zui/host"
+require_relative "zui/runner"
+require_relative "zui/generator"
+require_relative "zui/distribution"
+
+module Zui
+  VERSION = "0.0.1"
+  FRAMEWORK_ROOT = File.expand_path("..", __dir__)
+
+  def self.app(&definition)
+    Application.new(&definition).run
+  end
+
+  class << self
+    alias application app
+  end
+end

data/native/CMakeLists.txt

@@ -0,0 +1,45 @@
+cmake_minimum_required(VERSION 3.21)
+project(zui-host VERSION 0.1.0 LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_AUTOMOC ON)
+
+find_package(Qt6 6.8 REQUIRED COMPONENTS
+  Core
+  Gui
+  Multimedia
+  Qml
+  Quick
+  QuickControls2
+  QuickVectorImage
+)
+find_package(Qt6 6.8 QUIET COMPONENTS WebEngineQuick)
+
+qt_add_executable(zui-host
+  main.cpp
+  ZuiClipboard.cpp
+  ZuiClipboard.h
+  ZuiProcess.cpp
+  ZuiProcess.h
+)
+
+target_link_libraries(zui-host PRIVATE
+  Qt6::Core
+  Qt6::Gui
+  Qt6::Multimedia
+  Qt6::Qml
+  Qt6::Quick
+  Qt6::QuickControls2
+  Qt6::QuickVectorImage
+)
+
+if(TARGET Qt6::WebEngineQuick)
+  target_link_libraries(zui-host PRIVATE Qt6::WebEngineQuick)
+  target_compile_definitions(zui-host PRIVATE ZUI_HAS_WEBENGINE=1)
+endif()
+
+install(TARGETS zui-host
+  BUNDLE DESTINATION .
+  RUNTIME DESTINATION bin
+)

data/native/ZuiClipboard.cpp

@@ -0,0 +1,16 @@
+#include "ZuiClipboard.h"
+
+#include <QGuiApplication>
+#include <QClipboard>
+
+ZuiClipboard::ZuiClipboard(QObject *parent) : QObject(parent) {
+  connect(QGuiApplication::clipboard(), &QClipboard::dataChanged, this, &ZuiClipboard::textChanged);
+}
+
+QString ZuiClipboard::text() const { return QGuiApplication::clipboard()->text(); }
+
+void ZuiClipboard::setText(const QString &text) {
+  if (this->text() == text)
+    return;
+  QGuiApplication::clipboard()->setText(text);
+}

data/native/ZuiClipboard.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <QObject>
+
+class ZuiClipboard final : public QObject {
+  Q_OBJECT
+  Q_PROPERTY(QString text READ text WRITE setText NOTIFY textChanged)
+
+public:
+  explicit ZuiClipboard(QObject *parent = nullptr);
+  QString text() const;
+  void setText(const QString &text);
+
+signals:
+  void textChanged();
+};

data/native/ZuiProcess.cpp

@@ -0,0 +1,84 @@
+#include "ZuiProcess.h"
+
+#include <QProcessEnvironment>
+#include <QTimer>
+
+ZuiProcess::ZuiProcess(QObject *parent) : QObject(parent) {
+  connect(&m_process, &QProcess::stateChanged, this, [this] { emit runningChanged(); });
+  connect(&m_process, &QProcess::readyReadStandardOutput, this, [this] {
+    m_stdoutBuffer += m_process.readAllStandardOutput();
+    consume(m_stdoutBuffer, false);
+  });
+  connect(&m_process, &QProcess::readyReadStandardError, this, [this] {
+    m_stderrBuffer += m_process.readAllStandardError();
+    consume(m_stderrBuffer, true);
+  });
+  connect(&m_process, &QProcess::errorOccurred, this, [this](QProcess::ProcessError) {
+    emit errorLineReceived(m_process.errorString());
+  });
+  connect(&m_process, qOverload<int, QProcess::ExitStatus>(&QProcess::finished), this,
+          [this](int exitCode, QProcess::ExitStatus) {
+            m_stdoutBuffer += m_process.readAllStandardOutput();
+            m_stderrBuffer += m_process.readAllStandardError();
+            flush(m_stdoutBuffer, false);
+            flush(m_stderrBuffer, true);
+            emit exited(exitCode);
+          });
+}
+
+ZuiProcess::~ZuiProcess() { stop(); }
+
+bool ZuiProcess::running() const { return m_process.state() != QProcess::NotRunning; }
+
+void ZuiProcess::start(const QString &executable, const QString &program,
+                       const QString &workingDirectory, const QString &loadPath) {
+  if (running() || executable.isEmpty() || program.isEmpty())
+    return;
+
+  QProcessEnvironment environment = QProcessEnvironment::systemEnvironment();
+  environment.insert(QStringLiteral("ZUI_PROJECT_DIR"), workingDirectory);
+  m_process.setProcessEnvironment(environment);
+  m_process.setWorkingDirectory(workingDirectory);
+  m_process.setProcessChannelMode(QProcess::SeparateChannels);
+
+  QStringList arguments;
+  if (!loadPath.isEmpty())
+    arguments << QStringLiteral("-I") << loadPath;
+  arguments << program;
+  m_process.start(executable, arguments, QIODevice::ReadWrite);
+}
+
+void ZuiProcess::write(const QString &data) {
+  if (!running())
+    return;
+  m_process.write(data.toUtf8());
+}
+
+void ZuiProcess::stop() {
+  if (!running())
+    return;
+  m_process.closeWriteChannel();
+  m_process.terminate();
+  if (!m_process.waitForFinished(1000)) {
+    m_process.kill();
+    m_process.waitForFinished(1000);
+  }
+}
+
+void ZuiProcess::consume(QByteArray &buffer, bool errorStream) {
+  qsizetype newline = -1;
+  while ((newline = buffer.indexOf('\n')) >= 0) {
+    const QString line = QString::fromUtf8(buffer.left(newline));
+    buffer.remove(0, newline + 1);
+    errorStream ? emit errorLineReceived(line) : emit lineReceived(line);
+  }
+}
+
+void ZuiProcess::flush(QByteArray &buffer, bool errorStream) {
+  consume(buffer, errorStream);
+  if (buffer.isEmpty())
+    return;
+  const QString line = QString::fromUtf8(buffer);
+  buffer.clear();
+  errorStream ? emit errorLineReceived(line) : emit lineReceived(line);
+}

data/native/ZuiProcess.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <QObject>
+#include <QProcess>
+
+class ZuiProcess final : public QObject {
+  Q_OBJECT
+  Q_PROPERTY(bool running READ running NOTIFY runningChanged)
+
+public:
+  explicit ZuiProcess(QObject *parent = nullptr);
+  ~ZuiProcess() override;
+
+  bool running() const;
+
+  Q_INVOKABLE void start(const QString &executable, const QString &program,
+                         const QString &workingDirectory, const QString &loadPath);
+  Q_INVOKABLE void write(const QString &data);
+  Q_INVOKABLE void stop();
+
+signals:
+  void runningChanged();
+  void lineReceived(const QString &line);
+  void errorLineReceived(const QString &line);
+  void exited(int exitCode);
+
+private:
+  void consume(QByteArray &buffer, bool errorStream);
+  void flush(QByteArray &buffer, bool errorStream);
+
+  QProcess m_process;
+  QByteArray m_stdoutBuffer;
+  QByteArray m_stderrBuffer;
+};

data/native/main.cpp

@@ -0,0 +1,64 @@
+#include "ZuiClipboard.h"
+#include "ZuiProcess.h"
+
+#include <QCommandLineParser>
+#include <QDir>
+#include <QFileInfo>
+#include <QGuiApplication>
+#include <QQmlApplicationEngine>
+#include <QQmlContext>
+#include <QQuickStyle>
+
+#ifdef ZUI_HAS_WEBENGINE
+#include <QtWebEngineQuick/qtwebenginequickglobal.h>
+#endif
+
+int main(int argc, char *argv[]) {
+#ifdef ZUI_HAS_WEBENGINE
+  QtWebEngineQuick::initialize();
+#endif
+  QGuiApplication application(argc, argv);
+  QCoreApplication::setApplicationName(QStringLiteral("Zui"));
+  QCoreApplication::setOrganizationName(QStringLiteral("Zui"));
+  QQuickStyle::setStyle(QStringLiteral("Fusion"));
+
+  QCommandLineParser parser;
+  parser.setApplicationDescription(QStringLiteral("Zui cross-platform Qt host"));
+  parser.addHelpOption();
+  parser.addOption({QStringLiteral("qml-root"), QStringLiteral("Zui QML runtime directory"), QStringLiteral("path")});
+  parser.addOption({QStringLiteral("project"), QStringLiteral("Application project directory"), QStringLiteral("path")});
+  parser.addOption({QStringLiteral("program"), QStringLiteral("Ruby application entrypoint"), QStringLiteral("path")});
+  parser.addOption({QStringLiteral("ruby"), QStringLiteral("Ruby executable"), QStringLiteral("path"), QStringLiteral("ruby")});
+  parser.addOption({QStringLiteral("load-path"), QStringLiteral("Ruby framework load path"), QStringLiteral("path")});
+  parser.addOption({QStringLiteral("name"), QStringLiteral("Application name"), QStringLiteral("name"), QStringLiteral("Zui Application")});
+  parser.process(application);
+
+  const QString qmlRootValue = parser.value(QStringLiteral("qml-root"));
+  const QString projectValue = parser.value(QStringLiteral("project"));
+  const QString programValue = parser.value(QStringLiteral("program"));
+  const QString qmlRoot = QFileInfo(qmlRootValue).absoluteFilePath();
+  const QString project = QFileInfo(projectValue).absoluteFilePath();
+  const QString program = QFileInfo(programValue).absoluteFilePath();
+  const QFileInfo desktopFile(QDir(qmlRoot).filePath(QStringLiteral("Desktop.qml")));
+  if (qmlRootValue.isEmpty() || projectValue.isEmpty() || programValue.isEmpty()
+      || !desktopFile.isFile() || !QFileInfo(project).isDir() || !QFileInfo(program).isFile())
+    parser.showHelp(64);
+
+  ZuiProcess process;
+  ZuiClipboard clipboard;
+  QQmlApplicationEngine engine;
+  engine.rootContext()->setContextProperty(QStringLiteral("zuiProcess"), &process);
+  engine.rootContext()->setContextProperty(QStringLiteral("zuiClipboard"), &clipboard);
+  engine.rootContext()->setContextProperty(QStringLiteral("zuiProjectDir"), project);
+  engine.rootContext()->setContextProperty(QStringLiteral("zuiComponentDir"), QDir(qmlRoot).filePath(QStringLiteral("Components/Builtins")));
+  engine.rootContext()->setContextProperty(QStringLiteral("zuiRubyExecutable"), parser.value(QStringLiteral("ruby")));
+  engine.rootContext()->setContextProperty(QStringLiteral("zuiRubyProgram"), program);
+  engine.rootContext()->setContextProperty(QStringLiteral("zuiRubyLoadPath"), parser.value(QStringLiteral("load-path")));
+  engine.rootContext()->setContextProperty(QStringLiteral("zuiApplicationName"), parser.value(QStringLiteral("name")));
+  engine.addImportPath(qmlRoot);
+
+  QObject::connect(&engine, &QQmlApplicationEngine::objectCreationFailed, &application,
+                   [] { QCoreApplication::exit(1); }, Qt::QueuedConnection);
+  engine.load(QUrl::fromLocalFile(QDir(qmlRoot).filePath(QStringLiteral("Desktop.qml"))));
+  return application.exec();
+}

data/vendor/host/linux-x86_64/PROVENANCE.md

@@ -0,0 +1,15 @@
+# Zui Linux host provenance
+
+- Target: Linux x86-64
+- Source: `native/` in this repository
+- Framework version: Zui 0.1.0
+- Compiler: GNU C++ 16.2.1
+- Qt: 6.11.2
+- Build type: CMake `Release`
+
+The binary is reproducible from the checked-in C++ sources with:
+
+```bash
+cmake -S native -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build --parallel
+```

data/vendor/host/linux-x86_64/zui-host.sha256

@@ -0,0 +1 @@
+de446bb598f922a7a58fe30127d88cae9602cf54bd819aa2b5c84447a51da7a4  zui-host