omarchy-ui 0.0.1-x86_64-linux

data/lib/omarchy_ui/scheduler.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module OmarchyUI
+  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 = "omarchy-ui-#{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/omarchy_ui/state_store.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module OmarchyUI
+  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/omarchy_ui/value.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module OmarchyUI
+  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/omarchy_ui.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "omarchy_ui/protocol"
+require_relative "omarchy_ui/value"
+require_relative "omarchy_ui/state_store"
+require_relative "omarchy_ui/node"
+require_relative "omarchy_ui/animation"
+require_relative "omarchy_ui/scheduler"
+require_relative "omarchy_ui/command"
+require_relative "omarchy_ui/component_registry"
+require_relative "omarchy_ui/components"
+require_relative "omarchy_ui/builder"
+require_relative "omarchy_ui/application"
+require_relative "omarchy_ui/project"
+require_relative "omarchy_ui/runtime"
+
+module OmarchyUI
+  VERSION = "0.0.1"
+  FRAMEWORK_ROOT = File.expand_path("..", __dir__)
+
+  def self.plugin(&definition)
+    Application.new(&definition).run
+  end
+
+  class << self
+    alias application plugin
+    alias app plugin
+  end
+end

data/manifest.json

@@ -0,0 +1,27 @@
+{
+  "schemaVersion": 1,
+  "id": "izeesoft.omarchy-ui-poc",
+  "name": "Omarchy UI Ruby Framework",
+  "version": "0.3.0",
+  "author": "Adam Moussa Ali",
+  "license": "MIT",
+  "description": "Persistent Ruby state and event handlers rendered by a generic Omarchy QML bridge.",
+  "kinds": [
+    "service",
+    "bar-widget",
+    "panel"
+  ],
+  "keepLoaded": true,
+  "entryPoints": {
+    "service": "Service.qml",
+    "barWidget": "BarWidget.qml",
+    "panel": "Panel.qml"
+  },
+  "barWidget": {
+    "displayName": "Ruby UI Framework",
+    "description": "Open the Ruby-driven counter panel.",
+    "category": "Development",
+    "allowMultiple": false,
+    "defaultSection": "right"
+  }
+}

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: omarchy-ui
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: x86_64-linux
+authors:
+- Adam Moussa Ali
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A persistent Ruby runtime, reactive UI model, and safe QML renderer for
+  Omarchy.
+executables:
+- omarchy_ui
+extensions: []
+extra_rdoc_files: []
+files:
+- App.qml
+- BarWidget.qml
+- Components/README.md
+- Components/Sparkline.qml
+- ControlNode.qml
+- LICENSE
+- Panel.qml
+- README.md
+- Service.qml
+- bin/omarchy_ui
+- lib/omarchy_ui.rb
+- lib/omarchy_ui/animation.rb
+- lib/omarchy_ui/application.rb
+- lib/omarchy_ui/builder.rb
+- lib/omarchy_ui/cli.rb
+- lib/omarchy_ui/command.rb
+- lib/omarchy_ui/component_registry.rb
+- lib/omarchy_ui/components.rb
+- lib/omarchy_ui/node.rb
+- lib/omarchy_ui/project.rb
+- lib/omarchy_ui/protocol.rb
+- lib/omarchy_ui/runtime.rb
+- lib/omarchy_ui/scheduler.rb
+- lib/omarchy_ui/state_store.rb
+- lib/omarchy_ui/value.rb
+- manifest.json
+- vendor/runtime/x86_64-linux/omarchy-ui-runtime
+homepage: https://github.com/AdamMusa/omarchy-ui
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/AdamMusa/omarchy-ui
+  documentation_uri: https://github.com/AdamMusa/omarchy-ui#readme
+  release_status: experimental
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.18
+specification_version: 4
+summary: Build native Omarchy plugins and applications in Ruby
+test_files: []