hadar 0.1.0

data/lib/hadar/slot.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Hadar
+  class Slot
+    attr_reader :name, :nodes, :document, :slide_index
+
+    def initialize(name:, nodes:, document:, deck:, slide_index:)
+      @name = name.to_sym
+      @nodes = nodes.freeze
+      @document = document
+      @deck, @slide_index = deck, slide_index
+      freeze
+    end
+
+    def empty? = nodes.empty?
+
+    def markdown
+      nodes.map { |node| document.source.byteslice(node.range) }.join("\n")
+    end
+
+    def text
+      nodes.map { |node| plain_text(node) }.reject(&:empty?).join("\n")
+    end
+
+    def text_for(node)
+      raise TypeError, "node must be a Beid::Node" unless node.is_a?(Beid::Node)
+      raise Error, "node is not part of this slot" unless nodes.include?(node)
+
+      plain_text(node)
+    end
+
+    def table_rows(table: 0)
+      node = table_nodes.fetch(valid_index!(table, "table")) do
+        raise IndexError, "table index is outside the slot"
+      end
+      node.children.filter_map do |row|
+        row.children.map { |cell| plain_text(cell) } if row.type == :table_row
+      end
+    end
+
+    def image_path
+      return if nodes.empty?
+      raise Error, "image_path requires a slot containing exactly one image" unless nodes.one? && nodes.first.type == :image
+
+      destination = nodes.first.attributes.fetch(:destination)
+      destination.match?(/\Ahttps?:\/\//i) ? destination : URI::DEFAULT_PARSER.unescape(destination)
+    end
+
+    def resolved_image_path
+      path = image_path
+      path && @deck.resolve_image_path(path)
+    end
+
+    def replace_text(text)
+      @deck.replace_text(self, text)
+    end
+
+    def rich_text(editable: true)
+      value = RichTextProjection.new(self).build(editable: editable)
+      return value unless editable
+
+      deck, slide_index, name, source_document = @deck, @slide_index, @name, @document
+      value.on_change do |_text, rich_text|
+        raise Error, "rich text editor is stale; rebuild it from the current slot" unless deck.document.equal?(source_document)
+
+        deck.slide(slide_index).slot(name).replace_rich_text(rich_text)
+        source_document = deck.document
+      end
+      value
+    end
+
+    def replace_rich_text(value)
+      @deck.replace_rich_text(self, value)
+    end
+
+    def replace_image(path)
+      @deck.replace_image(self, path)
+    end
+
+    def insert_image(path, alt: nil)
+      @deck.insert_image(self, path, alt: alt)
+    end
+
+    def replace_table_cell(row:, column:, value:, table: 0)
+      @deck.replace_table_cell(self, row: row, column: column, value: value, table: table)
+    end
+
+    def replace_code(text, block: 0)
+      @deck.replace_code(self, text, block: block)
+    end
+
+    def owned_by?(deck) = @deck.equal?(deck)
+
+    private
+
+    def table_nodes = nodes.select { |node| node.type == :table }
+
+    def valid_index!(index, name)
+      raise TypeError, "#{name} index must be an Integer" unless index.is_a?(Integer)
+      raise IndexError, "#{name} index must not be negative" if index.negative?
+
+      index
+    end
+
+    def plain_text(node)
+      case node.type
+      when :text, :code_span then node.attributes.fetch(:text, "")
+      when :image then node.attributes.fetch(:label, "")
+      when :break, :softbreak then "\n"
+      when :task_checkbox then ""
+      when :code_block then code_block_text(node)
+      when :html_block then node.attributes.fetch(:text, "")
+      when :ordered_list, :list
+        node.children.each_with_index.map { |item, index| list_item_text(item, index) }.join("\n")
+      when :table
+        node.children.map { |row| plain_text(row) }.join("\n")
+      when :table_row
+        node.children.map { |cell| plain_text(cell) }.join(" | ")
+      when :block_quote
+        node.children.map { |child| plain_text(child) }.join("\n")
+      else node.children.map { |child| plain_text(child) }.join
+      end
+    end
+
+    def list_item_text(node, index)
+      marker = if node.attributes[:task]
+        node.attributes[:checked] ? "☑ " : "☐ "
+      elsif node.attributes[:ordered]
+        "#{node.attributes[:start] || index + 1}. "
+      else
+        "• "
+      end
+      marker + node.children.map { |child| plain_text(child) }.reject(&:empty?).join("\n")
+    end
+
+    def code_block_text(node)
+      lines = document.source.byteslice(node.range).to_s.scan(/.*?(?:\r\n|\r|\n|\z)/m).reject(&:empty?)
+      if node.attributes[:fence]
+        lines.shift
+        lines.pop if node.attributes[:closed]
+        lines.join
+      else
+        lines.map { |line| line.sub(/\A(?:    |\t)/, "") }.join
+      end
+    end
+  end
+end

data/lib/hadar/theme.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# APP-SPECIFIC: theme schema and loading remain local; Q6 found no shared three-app contract.
+module Hadar
+  class Theme
+    DEFAULTS = {
+      "name" => "Minimal",
+      "colors" => {"background" => "#ffffff", "text" => "#18212b", "muted" => "#5c6875", "accent" => "#315b7c"},
+      "font" => {"family" => "sans-serif", "title_size" => 44, "body_size" => 26},
+      "spacing" => {"margin" => 64, "gap" => 24}
+    }.freeze
+    COLOR_KEYS = %w[background text muted accent].freeze
+    FONT_KEYS = %w[family title_size body_size].freeze
+    SPACING_KEYS = %w[margin gap].freeze
+
+    attr_reader :name, :colors, :font, :spacing
+
+    def self.default = builtin("minimal")
+
+    def self.builtin(name)
+      key = name.to_s.downcase
+      raise Error, "unknown built-in theme: #{name.inspect}" unless %w[minimal dark warm].include?(key)
+
+      load(File.expand_path("../../assets/themes/#{key}.jsonc", __dir__))
+    end
+
+    def self.load(path)
+      raise Error, "theme exceeds 256 KiB" if File.size(path) > 262_144
+
+      document = Kochab.parse(File.read(path, encoding: "UTF-8"))
+      raise Error, "invalid theme JSONC: #{document.errors.map(&:message).join('; ')}" unless document.valid?
+      raise Error, "theme must be a JSON object" unless document.value.is_a?(Hash)
+
+      new(document.value)
+    rescue Kochab::ParseError, SystemCallError => error
+      raise Error, error.message
+    end
+
+    def initialize(value)
+      raise TypeError, "theme must be a Hash" unless value.is_a?(Hash)
+
+      data = DEFAULTS.merge(value)
+      reject_unknown!(data, DEFAULTS.keys, "theme")
+      @name = data.fetch("name")
+      raise Error, "theme name must be a non-empty String" unless @name.is_a?(String) && !@name.strip.empty?
+      @name = @name.dup.freeze
+      @colors = section(data, "colors", COLOR_KEYS)
+      COLOR_KEYS.each do |key|
+        color = @colors.fetch(key)
+        raise Error, "invalid theme color #{key.inspect}" unless color.is_a?(String) && color.match?(/\A#[0-9a-fA-F]{6}(?:[0-9a-fA-F]{2})?\z/)
+      end
+      @font = section(data, "font", FONT_KEYS)
+      raise Error, "font family must be a String" unless @font.fetch("family").is_a?(String) && !@font.fetch("family").empty?
+      %w[title_size body_size].each do |key|
+        value = @font.fetch(key)
+        raise Error, "#{key} must be between 8 and 160" unless value.is_a?(Numeric) && value.finite? && value.between?(8, 160)
+      end
+      @spacing = section(data, "spacing", SPACING_KEYS)
+      SPACING_KEYS.each do |key|
+        value = @spacing.fetch(key)
+        raise Error, "#{key} must be between 0 and 512" unless value.is_a?(Numeric) && value.finite? && value.between?(0, 512)
+      end
+      [@colors, @font, @spacing].each do |section|
+        section.each { |key, value| section[key] = value.dup.freeze if value.is_a?(String) }
+        section.freeze
+      end
+      freeze
+    end
+
+    private
+
+    def section(data, key, allowed)
+      value = data.fetch(key, {})
+      raise Error, "#{key} must be a JSON object" unless value.is_a?(Hash)
+
+      reject_unknown!(value, allowed, key)
+      DEFAULTS.fetch(key).merge(value)
+    end
+
+    def reject_unknown!(hash, allowed, section)
+      unknown = hash.keys - allowed
+      raise Error, "unknown #{section} keys: #{unknown.join(', ')}" unless unknown.empty?
+    end
+  end
+end

data/lib/hadar/version.rb

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

data/lib/hadar.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "hadar/version"
+
+require "beid"
+require "antares"
+require "kochab"
+require "okab"
+require "xamidimura"
+require "zaniah"
+require "zaniah/ui"
+
+require_relative "hadar/layout"
+require_relative "hadar/slot"
+require_relative "hadar/rich_text_projection"
+require_relative "hadar/rich_text_writeback"
+require_relative "hadar/slide"
+require_relative "hadar/theme"
+require_relative "hadar/deck"
+require_relative "hadar/deck_watcher"
+require_relative "hadar/renderer"
+require_relative "hadar/slide_list"
+require_relative "hadar/presenter"
+require_relative "hadar/application"
+
+module Hadar
+  class Error < StandardError; end
+end
+
+require_relative "hadar/export/pdf"
+require_relative "hadar/export/png_sequence"

data/sig/hadar.rbs

@@ -0,0 +1,221 @@
+module Hadar
+  VERSION: String
+
+  class Error < StandardError
+  end
+
+  module Layout
+    class Definition
+      attr_reader name: Symbol
+      attr_reader slots: Array[Symbol]
+    end
+
+    NAMES: Array[Symbol]
+
+    def self.fetch: (String | Symbol name) -> Definition
+    def self.select: (Array[Beid::Node] nodes, ?requested: String | Symbol | nil) -> Symbol
+  end
+
+  class Slot
+    attr_reader name: Symbol
+    attr_reader nodes: Array[Beid::Node]
+    attr_reader document: Beid::Document
+    attr_reader slide_index: Integer
+
+    def initialize: (name: String | Symbol, nodes: Array[Beid::Node], document: Beid::Document,
+      deck: Deck, slide_index: Integer) -> void
+    def empty?: () -> bool
+    def markdown: () -> String
+    def text: () -> String
+    def text_for: (Beid::Node node) -> String
+    def image_path: () -> String?
+    def resolved_image_path: () -> String?
+    def table_rows: (?table: Integer) -> Array[Array[String]]
+    def replace_text: (String text) -> Slot
+    def rich_text: (?editable: bool) -> Zaniah::UI::RichText
+    def replace_rich_text: (Zaniah::UI::RichText value) -> Slot
+    def replace_image: (String path) -> Slot
+    def insert_image: (String path, ?alt: String?) -> Slot
+    def replace_table_cell: (row: Integer, column: Integer, value: String, ?table: Integer) -> Slot
+    def replace_code: (String text, ?block: Integer) -> Slot
+    def owned_by?: (Deck deck) -> bool
+  end
+
+  class Slide
+    attr_reader index: Integer
+    attr_reader document: Beid::Document
+    attr_reader nodes: Array[Beid::Node]
+    attr_reader layout: Symbol
+    attr_reader slots: Hash[Symbol, Slot]
+    attr_reader theme: Theme
+    attr_reader notes: String?
+
+    def initialize: (index: Integer, document: Beid::Document, nodes: Array[Beid::Node],
+      ?layout: String | Symbol | nil, theme: Theme, deck: Deck) -> void
+    def slot: (String | Symbol name) -> Slot
+    def title: () -> String
+  end
+
+  class Deck
+    attr_reader document: Beid::Document
+    attr_reader slides: Array[Slide]
+    attr_reader theme: Theme
+    attr_reader source_path: String?
+
+    def initialize: (Beid::Document document, ?theme: Theme | String | nil,
+      ?source_path: String?) -> void
+    def self.parse: (String markdown, ?theme: Theme | String | nil) -> Deck
+    def self.open: (String path, ?theme: Theme | String | nil) -> Deck
+    def self.from_document: (Beid::Document document, ?theme: Theme | String | nil) -> Deck
+    def slide: (Integer index) -> Slide
+    def replace_text: (Slot slot, String text) -> Slot
+    def replace_rich_text: (Slot slot, Zaniah::UI::RichText value) -> Slot
+    def replace_table_cell: (Slot slot, row: Integer, column: Integer, value: String, ?table: Integer) -> Slot
+    def replace_code: (Slot slot, String text, ?block: Integer) -> Slot
+    def replace_image: (Slot slot, String path) -> Slot
+    def insert_image: (Slot slot, String path, ?alt: String?) -> Slot
+    def resolve_image_path: (String path) -> String
+    def save: (?String path, ?overwrite: bool) -> Deck
+    def external_change?: () -> bool
+    def reload_if_changed: () -> bool
+    def reload: () -> bool
+    def watch: (?latency: Numeric, ?on_reload: ^(Deck) -> untyped) -> DeckWatcher
+    def length: () -> Integer
+    alias size length
+    def empty?: () -> bool
+  end
+
+  class DeckWatcher
+    attr_reader deck: Deck
+
+    def initialize: (Deck deck, ?latency: Numeric, ?on_reload: ^(Deck) -> untyped) -> void
+    def poll: (?timeout: Numeric) -> bool
+    def close: () -> untyped
+  end
+
+  class Presenter
+    attr_reader deck: Deck
+    attr_reader current_index: Integer?
+    attr_reader started_at: Numeric?
+
+    def initialize: (Deck deck, ?renderer: Renderer, ?clock: ^() -> Numeric) -> void
+    def start: (?index: Integer?) -> Presenter
+    def stop: () -> Presenter
+    def go_to: (Integer index) -> Presenter
+    def started?: () -> bool
+    def current_slide: () -> Slide?
+    def next_slide: () -> Slide?
+    def notes: () -> String?
+    def elapsed_seconds: () -> Numeric
+    def elapsed_text: () -> String
+    def slide_view: () -> Zaniah::Element
+    def presenter_view: () -> Zaniah::Element
+    def reconcile!: () -> Presenter
+  end
+
+  class Application
+    attr_reader deck: Deck
+    attr_reader renderer: Renderer
+    attr_reader presenter: Presenter
+    attr_reader selected_index: Integer?
+    attr_reader selected_slot_name: Symbol?
+    attr_reader slide_list: SlideList
+    attr_reader keymap: Zaniah::Input::Keymap
+    attr_reader body_editor: Zaniah::UI::RichText?
+
+    def self.presenter_display: (Array[Zaniah::Platform::Display]) -> Zaniah::Platform::Display?
+    def self.default_keymap: (?clock: ^() -> Numeric) -> Zaniah::Input::Keymap
+    def initialize: (Deck deck, ?renderer: Renderer, ?clock: ^() -> Numeric, ?watch: bool,
+      ?keymap: Zaniah::Input::Keymap) -> void
+    def attach: (main_window: untyped, ?presenter_window: untyped) -> Application
+    def main_view: (width: Numeric, height: Numeric) -> Zaniah::Element
+    def command_palette: () -> CommandPalette?
+    def export_png_sequence: (String directory, ?width: Integer, ?height: Integer) -> Array[String]
+    def save: (?String path, ?overwrite: bool) -> Deck
+    def selected_slot: () -> Slot?
+    def select_slot: (String | Symbol name) -> Slot
+    def select_table_cell: (table: Integer, row: Integer, column: Integer) -> Array[Integer]
+    def select_code_block: (Integer index) -> Beid::Node
+    def insert_or_replace_selected_image: (String path) -> Slot
+    def replace_selected_table_cell: (String value) -> Slot
+    def replace_selected_code: (String text) -> Slot
+    def select_slide: (Integer index) -> Slide
+    def next_slide: () -> Slide?
+    def previous_slide: () -> Slide?
+    def first_slide: () -> Slide?
+    def last_slide: () -> Slide?
+    def toggle_fullscreen: (?window: :main | :presenter) -> bool
+    def fullscreen?: (?window: :main | :presenter) -> bool
+    def start_presentation: (?index: Integer?) -> Presenter
+    def stop_presentation: () -> Presenter
+    def tick: () -> bool
+    def run: () -> Application
+    def close: () -> Application
+    def stop: () -> Application
+  end
+
+  class CommandPalette
+    attr_reader query: String
+
+    def initialize: (Hash[String, ^(*untyped) -> untyped] commands) -> void
+    def query=: (String value) -> String
+    def matches: (?Integer limit) -> Array[Spica::Match]
+    def choose: (String label, ?untyped event, ?untyped context) -> untyped
+  end
+
+  class Theme
+    DEFAULTS: Hash[String, untyped]
+    COLOR_KEYS: Array[String]
+    FONT_KEYS: Array[String]
+    SPACING_KEYS: Array[String]
+
+    attr_reader name: String
+    attr_reader colors: Hash[String, String]
+    attr_reader font: Hash[String, String | Numeric]
+    attr_reader spacing: Hash[String, Numeric]
+
+    def self.default: () -> Theme
+    def self.builtin: (String name) -> Theme
+    def self.load: (String path) -> Theme
+    def initialize: (Hash[String, untyped] value) -> void
+  end
+
+  class Renderer
+    def initialize: () -> void
+    def describe: (Slide slide) -> Zaniah::Describe::Node
+    def build: (Slide slide) -> Zaniah::Element
+    def surface: (Slide slide) -> Zaniah::Describe::Surface
+  end
+
+  class SlideList
+    DEFAULT_ROW_HEIGHT: Integer
+
+    attr_reader deck: Deck
+    attr_reader element: Zaniah::UniformList
+    attr_reader selected_index: Integer?
+
+    def initialize: (Deck deck, ?renderer: Renderer, ?selected: Integer?, ?row_height: Numeric,
+      ?on_select: ^(Slide, Integer) -> untyped) -> void
+    def build: (width: Numeric, height: Numeric) -> Zaniah::UniformList
+    def select: (Integer index) -> Slide
+  end
+
+  module Export
+    class PNGSequence
+      MAX_PIXELS: Integer
+
+      def self.write: (Deck deck, String directory, ?renderer: Renderer,
+        ?width: Integer, ?height: Integer) -> Array[String]
+    end
+
+    class PDF
+      WIDTH: Integer
+      HEIGHT: Integer
+
+      def self.render: (Deck deck, ?font: String | Okab::Font | Alhena::Font | nil) -> String
+      def self.write: (Deck deck, String path, ?font: String | Okab::Font | Alhena::Font | nil) -> String
+      def initialize: (Deck deck, ?font: String | Okab::Font | Alhena::Font | nil) -> void
+      def render: () -> String
+    end
+  end
+end

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification
+name: hadar
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: beid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: antares
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+- !ruby/object:Gem::Dependency
+  name: kochab
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: okab
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: spica
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: xamidimura
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: zaniah
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+description: Projects Beid Markdown ASTs into template-based slide decks, edits supported
+  source-backed text, and exports PDF or PNG.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- assets/themes/dark.jsonc
+- assets/themes/minimal.jsonc
+- assets/themes/warm.jsonc
+- docs/adr/001-template-layouts.md
+- lib/hadar.rb
+- lib/hadar/application.rb
+- lib/hadar/command_palette.rb
+- lib/hadar/deck.rb
+- lib/hadar/deck_watcher.rb
+- lib/hadar/export/pdf.rb
+- lib/hadar/export/png_sequence.rb
+- lib/hadar/layout.rb
+- lib/hadar/presenter.rb
+- lib/hadar/renderer.rb
+- lib/hadar/rich_text_projection.rb
+- lib/hadar/rich_text_writeback.rb
+- lib/hadar/slide.rb
+- lib/hadar/slide_list.rb
+- lib/hadar/slot.rb
+- lib/hadar/theme.rb
+- lib/hadar/version.rb
+- sig/hadar.rbs
+homepage: https://github.com/noxdea/hadar
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  source_code_uri: https://github.com/noxdea/hadar/tree/main
+  changelog_uri: https://github.com/noxdea/hadar/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Markdown-backed presentation editor and preview
+test_files: []