zaniah 0.1.0

data/lib/zaniah/image.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Zaniah
+  class Image < Element
+    def initialize(path)
+      super()
+      width, height, pixels = PNG.decode(File.binread(path))
+      @texture = GPU::Texture.new(width, height, data: pixels)
+    end
+
+    def request_layout(_cx)
+      @layout_node = Layout::Node.new(style: @style, measure: ->(_width, _height) { [@texture.width, @texture.height] })
+    end
+
+    def paint(bounds, _state, _prepaint, cx)
+      cx.scene.sprite(bounds.x, bounds.y, bounds.width, bounds.height, texture: @texture)
+    end
+  end
+end

data/lib/zaniah/input/action_registry.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Input
+    class ActionRegistry
+      def initialize = @actions = {}
+      def register(name, description: name, &block) = @actions[name.to_s] = [description, block]
+      def call(name, *args) = @actions.fetch(name.to_s)[1].call(*args)
+      def entries = @actions.transform_values(&:first).freeze
+    end
+  end
+end

data/lib/zaniah/input/composition.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Input
+    Composition = Data.define(:text, :selection)
+  end
+end

data/lib/zaniah/input/context_predicate.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "json"
+require "strscan"
+
+module Zaniah
+  module Input
+    # Parse a deliberately small predicate grammar. Settings never become Ruby code.
+    class ContextPredicate
+      def initialize(source)
+        @tokens = []
+        scanner = StringScanner.new(source.to_s)
+        until scanner.eos?
+          next if scanner.scan(/\s+/)
+          token = scanner.scan(/&&|\|\||==|!=|[!()]|[\w.:-]+|"(?:\\.|[^"\\])*"/)
+          raise ArgumentError, "invalid context expression at #{scanner.pos}" unless token
+          @tokens << token
+        end
+        @position = 0
+        @tree = @tokens.empty? ? [:literal, true] : expression
+        raise ArgumentError, "unexpected context token" unless @position == @tokens.length
+      end
+
+      def call(context) = !!evaluate(@tree, context)
+
+      private
+
+      def peek = @tokens[@position]
+      def take = @tokens[@position].tap { @position += 1 }
+
+      def expression
+        left = conjunction
+        while peek == "||"
+          take
+          left = [:or, left, conjunction]
+        end
+        left
+      end
+
+      def conjunction
+        left = atom
+        while peek == "&&"
+          take
+          left = [:and, left, atom]
+        end
+        left
+      end
+
+      def atom
+        if peek == "!"
+          take
+          return [:not, atom]
+        end
+        if peek == "("
+          take
+          node = expression
+          raise ArgumentError, "unclosed context group" unless take == ")"
+          return node
+        end
+        name = take
+        raise ArgumentError, "context identifier expected" unless name && name.match?(/\A[\w.:-]+\z/)
+        if ["==", "!="].include?(peek)
+          operator, operand = take, take
+          raise ArgumentError, "context value expected" unless operand && operand.match?(/\A(?:[\w.:-]+|".*")\z/)
+          value = operand.start_with?('"') ? JSON.parse(operand) : operand
+          [operator.to_sym, name, value]
+        else
+          [:id, name]
+        end
+      end
+
+      def evaluate(node, context)
+        kind, a, b = node
+        lookup = ->(name) { context.key?(name) ? context[name] : context[name.to_sym] }
+        case kind
+        when :literal then a
+        when :id then a == "true" || (a != "false" && lookup.call(a))
+        when :and then evaluate(a, context) && evaluate(b, context)
+        when :or then evaluate(a, context) || evaluate(b, context)
+        when :not then !evaluate(a, context)
+        when :== then lookup.call(a).to_s == b
+        when :!= then lookup.call(a).to_s != b
+        end
+      end
+    end
+  end
+end

data/lib/zaniah/input/dispatcher.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Input
+    class Dispatcher
+      attr_reader :focused
+
+      def initialize(keymap: Keymap.new)
+        @keymap, @hits = keymap, []
+      end
+
+      def focus(handle)
+        return if @focused == handle
+        @focused&.on_focus&.call(false)
+        @focused = handle
+        handle&.on_focus&.call(true)
+      end
+
+      def key(key)
+        chain = @focused ? @focused.ancestors : []
+        context = chain.reverse.each_with_object({}) { |handle, result| result.merge!(handle.context) }
+        action = @keymap.dispatch(key, context: context)
+        return action if action.nil? || action == :pending
+        chain.each { |handle| break if handle.on_action&.call(action) }
+        action
+      end
+
+      def clear_hits = @hits.clear
+
+      def hit(bounds, clip: nil, &handler)
+        bounds = bounds.intersect(@clip) if @clip
+        @hits << [clip ? bounds.intersect(clip) : bounds, handler]
+      end
+
+      def clip(bounds)
+        previous = @clip
+        @clip = previous ? previous.intersect(bounds) : bounds
+        yield
+      ensure
+        @clip = previous
+      end
+
+      def mouse(event)
+        if @capture
+          @capture.call(event)
+          @capture = nil if event.is_a?(MouseUp)
+          return true
+        end
+        @hits.reverse_each do |bounds, handler|
+          next unless bounds.contains?(event.position)
+          handled = handler.call(event)
+          @capture = handler if handled == :capture && event.is_a?(MouseDown)
+          return true if handled
+        end
+        false
+      end
+    end
+  end
+end

data/lib/zaniah/input/file_drop.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Input
+    FileDrop = Data.define(:paths, :position)
+  end
+end

data/lib/zaniah/input/focus_handle.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Input
+    class FocusHandle
+      attr_reader :parent, :children, :context
+      attr_accessor :on_action, :on_focus
+
+      def initialize(parent: nil, context: {})
+        @parent, @context, @children = parent, context, []
+        parent&.children&.push(self)
+      end
+
+      def ancestors
+        list, current = [], self
+        while current
+          list << current
+          current = current.parent
+        end
+        list
+      end
+    end
+  end
+end

data/lib/zaniah/input/key_down.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Input
+    KeyDown = Data.define(:keystroke, :is_held)
+  end
+end

data/lib/zaniah/input/key_up.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Input
+    KeyUp = Data.define(:keystroke)
+  end
+end

data/lib/zaniah/input/keymap/binding.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Input
+    class Keymap
+      Binding = Data.define(:keys, :predicate, :action)
+    end
+  end
+end

data/lib/zaniah/input/keymap.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "keystroke"
+require_relative "context_predicate"
+
+module Zaniah
+  module Input
+    class Keymap
+      def initialize(timeout: 1.0)
+        @bindings, @pending, @last_time, @timeout = [], [], 0, timeout
+      end
+
+      def bind(keys, action, context: "")
+        @bindings << Binding.new(keys.split.map { |key| Keystroke.normalize(key) }, ContextPredicate.new(context), action)
+        self
+      end
+
+      def load_json(text)
+        JSON.parse(text).each do |group|
+          group.fetch("bindings").each { |key, action| bind(key, action, context: group.fetch("context", "")) }
+        end
+        self
+      end
+
+      def dispatch(key, context: {}, now: Process.clock_gettime(Process::CLOCK_MONOTONIC))
+        @pending.clear if now - @last_time > @timeout
+        @last_time = now
+        key = Keystroke.normalize(key)
+        @pending << key
+        candidates = @bindings.reverse.select { |binding| binding.predicate.call(context) && binding.keys.first(@pending.length) == @pending }
+        if candidates.empty? && @pending.length > 1
+          @pending.replace([key])
+          candidates = @bindings.reverse.select { |binding| binding.predicate.call(context) && binding.keys.first(1) == @pending }
+        end
+        # The newest matching prefix also overrides an older complete binding.
+        # Otherwise a default ctrl-k action makes a later ctrl-k ctrl-s unusable.
+        match = candidates.first
+        if match && match.keys.length == @pending.length
+          @pending.clear
+          match.action
+        elsif candidates.empty?
+          @pending.clear
+          nil
+        else
+          :pending
+        end
+      end
+
+      def bindings = @bindings.dup.freeze
+    end
+  end
+end
+
+require_relative "keymap/binding"

data/lib/zaniah/input/keystroke.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Input
+    module Keystroke
+      ORDER = %w[ctrl alt shift cmd].freeze
+      ALIASES = {"control" => "ctrl", "option" => "alt", "meta" => "cmd", "super" => "cmd",
+                 "return" => "enter", "escape" => "esc", " " => "space"}.freeze
+
+      def self.normalize(value)
+        words = value.downcase.split("-")
+        key = value.end_with?("--") ? "-" : words.pop
+        key = "-" if key.nil? || key.empty?
+        modifiers = words.map { |word| ALIASES.fetch(word, word) }
+        raise ArgumentError, "unknown key modifier" unless (modifiers - ORDER).empty?
+        (ORDER.select { |modifier| modifiers.include?(modifier) } << ALIASES.fetch(key, key)).join("-")
+      end
+    end
+  end
+end

data/lib/zaniah/input/mouse_down.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Input
+    MouseDown = Data.define(:position, :button, :modifiers, :click_count)
+  end
+end

data/lib/zaniah/input/mouse_move.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Input
+    MouseMove = Data.define(:position, :modifiers)
+  end
+end

data/lib/zaniah/input/mouse_up.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Input
+    MouseUp = Data.define(:position, :button, :modifiers)
+  end
+end

data/lib/zaniah/input/scroll_wheel.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Input
+    ScrollWheel = Data.define(:position, :delta, :phase, :modifiers)
+  end
+end

data/lib/zaniah/input/text_input.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Input
+    TextInput = Data.define(:text)
+  end
+end

data/lib/zaniah/input.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "input/key_down"
+require_relative "input/key_up"
+require_relative "input/text_input"
+require_relative "input/mouse_down"
+require_relative "input/mouse_up"
+require_relative "input/mouse_move"
+require_relative "input/scroll_wheel"
+require_relative "input/composition"
+require_relative "input/file_drop"
+require_relative "input/keystroke"
+require_relative "input/context_predicate"
+require_relative "input/keymap"
+require_relative "input/focus_handle"
+require_relative "input/dispatcher"
+require_relative "input/action_registry"

data/lib/zaniah/layout/available_space.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Layout
+    AvailableSpace = Data.define(:kind, :value) do
+      def self.definite(value) = new(:definite, value)
+      def self.min_content = new(:min_content, nil)
+      def self.max_content = new(:max_content, nil)
+    end
+  end
+end

data/lib/zaniah/layout/engine.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Layout
+    class Engine
+      def initialize(rem: 16) = @rem = rem
+
+      def compute(root, width:, height:, x: 0, y: 0)
+        layout(root, x, y, width, height, width, height)
+        root.bounds
+      end
+      def measure(node, width:, height:) = natural_size(node, width, height)
+
+      private
+
+      def resolve_length(length, available, fallback = nil)
+        return fallback if length.nil? || length == :auto
+        length.is_a?(Length) ? length.resolve(available || 0, rem: @rem) : Float(length)
+      end
+
+      def resolve_edges(style, name, available)
+        input = style[name]
+        input = input.to_h.values if input.is_a?(Edges)
+        input = [input] unless input.is_a?(Array)
+        input = case input.length
+        when 1 then input * 4
+        when 2 then [input[0], input[1], input[0], input[1]]
+        when 3 then [input[0], input[1], input[2], input[1]]
+        when 4 then input
+        else raise ArgumentError, "invalid #{name}"
+        end
+        %i[top right bottom left].each_with_index.map do |side, i|
+          val = style["#{name}_#{side}".to_sym] || input[i]
+          val == :auto ? :auto : resolve_length(val, available, 0)
+        end
+      end
+
+      def clamp_size(node, dimension, size, available)
+        min = resolve_length(node.style["min_#{dimension}".to_sym], available, 0)
+        max = resolve_length(node.style["max_#{dimension}".to_sym], available, Float::INFINITY)
+        size.clamp(min, [min, max].max)
+      end
+
+      def natural_size(node, available_w, available_h)
+        s = node.style
+        return [0, 0] if s[:display] == :none
+        p = resolve_edges(s, :padding, available_w).map { |v| v == :auto ? 0 : v }
+        b = resolve_edges(s, :border, available_w).map { |v| v == :auto ? 0 : v }
+        padding_w, padding_h = p[1] + p[3] + b[1] + b[3], p[0] + p[2] + b[0] + b[2]
+        w = resolve_length(s[:width], available_w)
+        h = resolve_length(s[:height], available_h)
+        if node.measure
+          measured = node.measure.call([available_w - padding_w, 0].max, [available_h - padding_h, 0].max)
+          w ||= measured[0] + padding_w
+          h ||= measured[1] + padding_h
+          node.baseline = measured[2] || measured[1]
+        elsif !node.children.empty?
+          sizes = node.children.reject { |c| c.style[:position] == :absolute || c.style[:display] == :none }.map { |c| natural_size(c, available_w, available_h) }
+          row = s[:flex_direction].to_s.start_with?("row")
+          gap = resolve_length(s[:gap], available_w, 0) * [sizes.length - 1, 0].max
+          w ||= (row ? sizes.sum(&:first) + gap : sizes.map(&:first).max || 0) + padding_w
+          h ||= (row ? sizes.map(&:last).max || 0 : sizes.sum(&:last) + gap) + padding_h
+        end
+        [clamp_size(node, :width, w || padding_w, available_w), clamp_size(node, :height, h || padding_h, available_h)]
+      end
+
+      def layout(node, x, y, width, height, available_w, available_h)
+        key = [node.generation, x, y, width, height, available_w, available_h]
+        return if node.cache[key]
+        if node.style[:display] == :none
+          node.bounds = Bounds.new(x, y, 0, 0)
+          node.children.each { |child| hide(child, x, y) }
+          return
+        end
+        width = clamp_size(node, :width, width, available_w)
+        height = clamp_size(node, :height, height, available_h)
+        node.bounds = Bounds.new(x, y, width, height)
+        content = content_bounds(node)
+        flow, absolute = node.children.partition { |child| child.style[:position] != :absolute }
+        layout_flow_children(node, content, flow)
+        layout_absolute_children(absolute, content)
+        node.cache.shift if node.cache.length >= 5
+        node.cache[key] = true
+      end
+
+      def content_bounds(node)
+        padding = resolve_edges(node.style, :padding, node.bounds.width).map { |v| v == :auto ? 0 : v }
+        border = resolve_edges(node.style, :border, node.bounds.width).map { |v| v == :auto ? 0 : v }
+        node.bounds.inset(Edges.new(*padding.zip(border).map(&:sum)))
+      end
+
+      def layout_flow_children(node, content, flow)
+        s = node.style
+        row = s[:flex_direction].to_s.start_with?("row")
+        reverse = s[:flex_direction].to_s.end_with?("reverse")
+        main_size, cross_size = row ? [content.width, content.height] : [content.height, content.width]
+        before, after, cross_before, cross_after = row ? [3, 1, 0, 2] : [0, 2, 3, 1]
+        main_dimension, cross_dimension = row ? [:width, :height] : [:height, :width]
+        gap = resolve_length(s[:gap], main_size, 0)
+        flow = flow.reject { |child| child.style[:display] == :none && hide(child, node.bounds.x, node.bounds.y) }
+        items = flow.map do |child|
+          nw, nh = natural_size(child, content.width, content.height)
+          base = resolve_length(child.style[:flex_basis], main_size, row ? nw : nh)
+          margins = resolve_edges(child.style, :margin, content.width)
+          {node: child, base: base, size: clamp_size(child, main_dimension, base, main_size),
+           cross: row ? nh : nw, margins: margins}
+        end
+        lines = [[]]
+        occupied = 0
+        items.each do |item|
+          margin = item[:margins].values_at(before, after).sum { |v| v == :auto ? 0 : v }
+          required = item[:size] + margin
+          if s[:flex_wrap] == :wrap && !lines.last.empty? && occupied + gap + required > main_size
+            lines << []
+            occupied = 0
+          end
+          occupied += (lines.last.empty? ? 0 : gap) + required
+          lines.last << item
+        end
+        cross_cursor = 0
+        lines.each do |line|
+          next if line.empty?
+          fixed_margin = line.sum { |i| i[:margins].values_at(before, after).sum { |v| v == :auto ? 0 : v } }
+          distribute_space(line, main_size - gap * (line.length - 1) - fixed_margin, main_dimension)
+          free = main_size - line.sum { |i| i[:size] } - fixed_margin - gap * (line.length - 1)
+          autos = line.sum { |i| i[:margins].values_at(before, after).count(:auto) }
+          auto_margin = autos.positive? ? [free, 0].max / autos : 0
+          free = 0 if autos.positive?
+          leading, spacing = case s[:justify_content]
+          when :end then [free, gap]
+          when :center then [free / 2.0, gap]
+          when :space_between then [0, gap + (line.length > 1 ? [free, 0].max / (line.length - 1) : 0)]
+          when :space_around then [[free, 0].max / line.length / 2.0, gap + [free, 0].max / line.length]
+          when :space_evenly then [[free, 0].max / (line.length + 1), gap + [free, 0].max / (line.length + 1)]
+          else [0, gap]
+          end
+          line_cross = lines.length == 1 ? cross_size : line.map { |i| i[:cross] + i[:margins].values_at(cross_before, cross_after).sum { |v| v == :auto ? 0 : v } }.max
+          baseline = line.map { |i| i[:node].baseline }.max || 0
+          cursor = leading
+          line.each do |item|
+            child, margins = item.values_at(:node, :margins)
+            mb, ma = margins.values_at(before, after).map { |v| v == :auto ? auto_margin : v }
+            cb, ca = margins.values_at(cross_before, cross_after).map { |v| v == :auto ? 0 : v }
+            align = child.style[:align_self] == :auto ? s[:align_items] : child.style[:align_self]
+            cross = item[:cross]
+            cross = [line_cross - cb - ca, 0].max if align == :stretch && child.style[cross_dimension] == :auto
+            cross = clamp_size(child, cross_dimension, cross, cross_size)
+            cross_free = line_cross - cross - cb - ca
+            cross_offset = case align
+            when :end then cross_free
+            when :center then cross_free / 2.0
+            when :baseline then baseline - child.baseline
+            else 0
+            end
+            cross_autos = margins.values_at(cross_before, cross_after).count(:auto)
+            if cross_autos.positive?
+              cross_offset = margins[cross_before] == :auto ? [cross_free, 0].max / cross_autos : 0
+            end
+            cursor += mb
+            main_position = reverse ? main_size - cursor - item[:size] : cursor
+            cross_position = cross_cursor + cb + cross_offset
+            cx, cy = row ? [content.x + main_position, content.y + cross_position] : [content.x + cross_position, content.y + main_position]
+            cw, ch = row ? [item[:size], cross] : [cross, item[:size]]
+            cx += resolve_length(child.style[:left], content.width, 0) - resolve_length(child.style[:right], content.width, 0)
+            cy += resolve_length(child.style[:top], content.height, 0) - resolve_length(child.style[:bottom], content.height, 0)
+            layout(child, cx, cy, cw, ch, content.width, content.height)
+            cursor += item[:size] + ma + spacing
+          end
+          cross_cursor += line_cross + gap
+        end
+      end
+
+      def layout_absolute_children(children, content)
+        children.each do |child|
+          nw, nh = natural_size(child, content.width, content.height)
+          cs = child.style
+          left, right = resolve_length(cs[:left], content.width), resolve_length(cs[:right], content.width)
+          top, bottom = resolve_length(cs[:top], content.height), resolve_length(cs[:bottom], content.height)
+          cw = resolve_length(cs[:width], content.width, left && right ? content.width - left - right : nw)
+          ch = resolve_length(cs[:height], content.height, top && bottom ? content.height - top - bottom : nh)
+          cx = content.x + (left || (right ? content.width - right - cw : 0))
+          cy = content.y + (top || (bottom ? content.height - bottom - ch : 0))
+          layout(child, cx, cy, cw, ch, content.width, content.height)
+        end
+      end
+
+      def hide(node, x, y)
+        node.bounds = Bounds.new(x, y, 0, 0)
+        node.children.each { |child| hide(child, x, y) }
+        true
+      end
+
+      def distribute_space(line, available, dimension)
+        growing = line.sum { |i| i[:base] } < available
+        active = line.dup
+        remaining = available
+        until active.empty?
+          factor = active.sum { |i| growing ? i[:node].style[:flex_grow] : i[:node].style[:flex_shrink] * i[:base] }
+          free = remaining - active.sum { |i| i[:base] }
+          frozen = []
+          active.each do |item|
+            weight = growing ? item[:node].style[:flex_grow] : item[:node].style[:flex_shrink] * item[:base]
+            proposed = item[:base] + (factor.positive? ? free * weight / [factor, growing ? 1 : factor].max : 0)
+            item[:size] = clamp_size(item[:node], dimension, proposed, available)
+            frozen << item if (item[:size] - proposed).abs > 0.00001 || weight.zero?
+          end
+          break if frozen.empty?
+          frozen.each { |item| remaining -= item[:size]; active.delete(item) }
+        end
+      end
+    end
+
+  end
+end

data/lib/zaniah/layout/node.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Layout
+    class Node
+      attr_reader :style, :children, :generation, :cache
+      attr_accessor :bounds, :parent, :measure, :baseline
+
+      def initialize(style: Style.new, children: [], measure: nil)
+        @style = style.is_a?(Hash) ? Style.new(**style) : style
+        @children, @generation, @cache, @measure = [], 0, {}, measure
+        @bounds, @baseline = Bounds.new(0, 0, 0, 0), 0
+        children.each { |child| add(child) }
+      end
+
+      def add(child)
+        raise ArgumentError, "node already has a parent" if child.parent
+        child.parent = self
+        @children << child
+        touch
+        child
+      end
+
+      def style=(style)
+        @style = style.is_a?(Hash) ? Style.new(**style) : style
+        touch
+      end
+
+      def touch
+        @generation += 1
+        @cache.clear
+        parent&.touch
+      end
+    end
+  end
+end

data/lib/zaniah/layout/style.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Layout
+    class Style
+      DEFAULTS = {display: :flex, flex_direction: :column, flex_wrap: :nowrap,
+        justify_content: :start, align_items: :stretch, align_self: :auto,
+        flex_grow: 0, flex_shrink: 1, flex_basis: :auto, width: :auto, height: :auto,
+        min_width: 0, min_height: 0, max_width: Float::INFINITY, max_height: Float::INFINITY,
+        padding: 0, margin: 0, border: 0, gap: 0, position: :relative,
+        overflow: :visible}.freeze
+
+      def initialize(**properties) = @values = DEFAULTS.merge(properties).freeze
+      def [](name) = @values[name]
+      def merge(**properties) = Style.new(**@values.merge(properties))
+      def to_h = @values
+    end
+  end
+end