pocketbook 0.1.0

data/lib/pocketbook/cli/watch_command.rb

@@ -0,0 +1,275 @@
+require "listen"
+require "set"
+require "uri"
+require "rbconfig"
+require_relative "../book"
+require_relative "../core_stylesheet"
+require_relative "../theme"
+
+module Pocketbook
+  module CLI
+    class Watcher
+      WATCHABLE_EXTENSIONS = %w[.md .css .erb .yml .yaml].freeze
+      STOP_POLL_INTERVAL = 0.1
+
+      class ChangeBuffer
+        def initialize(debounce_seconds:, poll_interval:, clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
+          @debounce_seconds = debounce_seconds
+          @poll_interval = poll_interval
+          @clock = clock
+          @pending_paths = Set.new
+          @stopped = false
+          @last_change_at = nil
+          @mutex = Mutex.new
+          @condition = ConditionVariable.new
+        end
+
+        def add(paths)
+          normalized = paths.map { |path| File.expand_path(path) }.uniq
+          return if normalized.empty?
+
+          @mutex.synchronize do
+            normalized.each { |path| @pending_paths << path }
+            @last_change_at = @clock.call
+            @condition.broadcast
+          end
+        end
+
+        def next_batch
+          @mutex.synchronize do
+            while !@stopped && @pending_paths.empty?
+              @condition.wait(@mutex, @poll_interval)
+            end
+
+            return nil if @stopped
+
+            loop do
+              break if @stopped
+
+              elapsed = @clock.call - @last_change_at
+              remaining = @debounce_seconds - elapsed
+              break if remaining <= 0
+
+              @condition.wait(@mutex, [remaining, @poll_interval].min)
+            end
+
+            return nil if @stopped
+
+            paths = @pending_paths.to_a.sort
+            @pending_paths.clear
+            paths
+          end
+        end
+
+        def stop!
+          @mutex.synchronize do
+            return if @stopped
+
+            @stopped = true
+            @condition.broadcast
+          end
+        end
+
+        def wait_until_stopped
+          @mutex.synchronize do
+            @condition.wait(@mutex, @poll_interval) until @stopped
+          end
+        end
+      end
+
+      def initialize(request:, stdout: $stdout, stderr: $stderr)
+        @request = request
+        @stdout = stdout
+        @stderr = stderr
+        @changes = ChangeBuffer.new(
+          debounce_seconds: @request.debounce_ms.to_f / 1000.0,
+          poll_interval: STOP_POLL_INTERVAL
+        )
+        @theme_root = nil
+        @watch_directories = []
+      end
+
+      def run
+        theme = build_theme
+        @theme_root = theme.root_path
+        @watch_directories = compute_watch_directories
+
+        print_watch_banner
+        render(reason: "initial build", preloaded_theme: theme, open_output: @request.open_output)
+
+        listener = ::Listen.to(*@watch_directories) do |modified, added, removed|
+          register_changes(modified + added + removed)
+        end
+
+        worker = Thread.new { worker_loop }
+
+        with_signal_traps do
+          listener.start
+          @changes.wait_until_stopped
+        end
+      ensure
+        @changes.stop!
+        listener&.stop
+        worker&.join
+        @stdout.puts("[pocketbook] Watch stopped.")
+      end
+
+      private
+
+      def render(reason:, preloaded_theme: nil, open_output: false)
+        start_time = monotonic_time
+        output_path = build_book(theme: preloaded_theme).render_to(@request.output_path)
+        duration = monotonic_time - start_time
+        absolute_output = File.expand_path(output_path)
+
+        @stdout.puts("[pocketbook] Build succeeded in #{format('%.2f', duration)}s (#{reason}).")
+        @stdout.puts("[pocketbook] PDF: #{file_uri(absolute_output)}")
+        @stdout.puts("[pocketbook] Open: #{open_command(absolute_output)}")
+        if open_output
+          if open_with_default_viewer(absolute_output)
+            @stdout.puts("[pocketbook] Opened in default viewer.")
+          else
+            @stderr.puts("[pocketbook] Warning: could not open PDF automatically.")
+          end
+        end
+      rescue StandardError => e
+        @stderr.puts("[pocketbook] Build failed (#{reason}): #{e.message}")
+      end
+
+      def build_book(theme: nil)
+        Book.new(
+          inputs: @request.inputs,
+          theme: theme || build_theme,
+          metadata: @request.metadata
+        )
+      end
+
+      def build_theme
+        Theme.new(
+          theme_path: @request.theme_path,
+          style: @request.style,
+          template_override: @request.template_override
+        )
+      end
+
+      def compute_watch_directories
+        dirs = Set.new
+        @request.inputs.each do |path|
+          dirs << File.dirname(File.expand_path(path))
+        end
+        dirs << @theme_root if @theme_root
+        CoreStylesheet.watch_directories.each { |directory| dirs << directory }
+
+        dirs.to_a.select { |dir| Dir.exist?(dir) }.sort
+      end
+
+      def register_changes(paths)
+        changed_paths = paths.map { |path| File.expand_path(path) }.uniq
+        changed_paths.select! { |path| watchable_path?(path) }
+        @changes.add(changed_paths)
+      end
+
+      def watchable_path?(path)
+        WATCHABLE_EXTENSIONS.include?(File.extname(path).downcase)
+      end
+
+      def worker_loop
+        loop do
+          changed_paths = @changes.next_batch
+          break if changed_paths.nil?
+
+          render(reason: build_reason(changed_paths))
+        end
+      end
+
+      def build_reason(changed_paths)
+        if changed_paths.length == 1
+          "change detected in #{display_path(changed_paths.first)}"
+        else
+          "#{changed_paths.length} files changed"
+        end
+      end
+
+      def display_path(path)
+        absolute = File.expand_path(path)
+        cwd = File.expand_path(Dir.pwd)
+        if absolute.start_with?("#{cwd}/")
+          absolute[(cwd.length + 1)..]
+        else
+          absolute
+        end
+      end
+
+      def with_signal_traps
+        previous_int = trap_signal("INT")
+        previous_term = trap_signal("TERM")
+
+        yield
+      ensure
+        restore_signal("INT", previous_int)
+        restore_signal("TERM", previous_term)
+      end
+
+      def trap_signal(signal_name)
+        Signal.trap(signal_name) { request_stop_from_signal }
+      rescue ArgumentError
+        nil
+      end
+
+      def restore_signal(signal_name, previous_handler)
+        return if previous_handler.nil?
+
+        Signal.trap(signal_name, previous_handler)
+      rescue ArgumentError
+        nil
+      end
+
+      def request_stop_from_signal
+        @changes.stop!
+      end
+
+      def file_uri(path)
+        "file://#{URI::DEFAULT_PARSER.escape(path)}"
+      end
+
+      def open_with_default_viewer(path)
+        host_os = RbConfig::CONFIG["host_os"]
+
+        if host_os =~ /darwin/
+          system("open", path)
+        elsif host_os =~ /mswin|mingw|cygwin/
+          system("cmd", "/c", "start", "", path)
+        else
+          system("xdg-open", path)
+        end
+      end
+
+      def open_command(path)
+        host_os = RbConfig::CONFIG["host_os"]
+        if host_os =~ /darwin/
+          "open \"#{path}\""
+        elsif host_os =~ /mswin|mingw|cygwin/
+          "cmd /c start \"\" \"#{path}\""
+        else
+          "xdg-open \"#{path}\""
+        end
+      end
+
+      def monotonic_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def print_watch_banner
+        @stdout.puts("[pocketbook] Watch mode enabled.")
+        @stdout.puts("[pocketbook] Debounce window: #{@request.debounce_ms}ms")
+        @stdout.puts("[pocketbook] Watching #{@watch_directories.length} directories:")
+        @watch_directories.each do |directory|
+          @stdout.puts("[pocketbook]   - #{display_path(directory)}")
+        end
+        @stdout.puts("[pocketbook] Press Ctrl+C to stop.")
+      end
+    end
+
+    WatchCommand = Watcher
+  end
+end

data/lib/pocketbook/cli.rb

@@ -0,0 +1,12 @@
+require_relative "cli/options_parser"
+require_relative "cli/runner"
+
+module Pocketbook
+  module CLI
+    module_function
+
+    def run(argv = ARGV, stdout: $stdout, stderr: $stderr)
+      Runner.new(stdout: stdout, stderr: stderr).run(argv)
+    end
+  end
+end

data/lib/pocketbook/core_stylesheet.rb

@@ -0,0 +1,20 @@
+module Pocketbook
+  class CoreStylesheet
+    CORE_DIRECTORY = File.expand_path("styles/core", __dir__)
+
+    def self.load
+      paths = css_paths
+      raise ArgumentError, "No core stylesheets found in #{CORE_DIRECTORY}" if paths.empty?
+
+      paths.map { |path| File.read(path) }.join("\n\n")
+    end
+
+    def self.watch_directories
+      css_paths.map { |path| File.dirname(path) }.uniq
+    end
+
+    def self.css_paths
+      Dir.glob(File.join(CORE_DIRECTORY, "*.css")).sort
+    end
+  end
+end

data/lib/pocketbook/pdf_document.rb

@@ -0,0 +1,96 @@
+require "hexapdf"
+
+module Pocketbook
+  class PdfDocument
+    def self.open(path)
+      new(document: HexaPDF::Document.open(path))
+    end
+
+    def initialize(document:)
+      @document = document
+    end
+
+    def page_count
+      @document.pages.count
+    end
+
+    def toc_page_numbers(anchor_ids)
+      return {} if anchor_ids.empty?
+
+      page_number_by_reference = extract_page_numbers
+      destination_reference_by_id = named_destinations
+
+      anchor_ids.each_with_object({}) do |anchor_id, output|
+        page_reference = destination_reference_by_id[anchor_id]
+        next if page_reference.nil?
+
+        page_number = page_number_by_reference[page_reference]
+        next if page_number.nil?
+
+        output[anchor_id] = page_number
+      end
+    end
+
+    def named_destinations
+      {}.tap do |output|
+        extract_old_style_destinations(output)
+        extract_name_tree_destinations(output)
+      end
+    end
+
+    private
+
+    def extract_page_numbers
+      @document.pages.each_with_index.each_with_object({}) do |(page, index), output|
+        output[[page.oid, page.gen]] = index + 1
+      end
+    end
+
+    def extract_old_style_destinations(output)
+      return unless @document.catalog.key?(:Dests)
+
+      @document.catalog[:Dests].each do |target, destination|
+        target_id = normalize_destination_id(target)
+        page_reference = destination_page_reference(destination)
+        next if target_id.nil? || page_reference.nil?
+
+        output[target_id] ||= page_reference
+      end
+    end
+
+    def extract_name_tree_destinations(output)
+      names = @document.catalog[:Names]
+      return if names.nil? || !names.key?(:Dests)
+
+      names[:Dests].each_entry do |target, destination|
+        target_id = normalize_destination_id(target)
+        page_reference = destination_page_reference(destination)
+        next if target_id.nil? || page_reference.nil?
+
+        output[target_id] ||= page_reference
+      end
+    end
+
+    def normalize_destination_id(target)
+      return target.to_s if target.is_a?(Symbol)
+      return target if target.is_a?(String)
+
+      nil
+    end
+
+    def destination_page_reference(destination)
+      value = if destination.respond_to?(:key?) && destination.key?(:D)
+                destination[:D]
+              else
+                destination
+              end
+
+      return nil unless value.is_a?(Array)
+
+      page = value.first
+      return nil unless page.respond_to?(:oid) && page.respond_to?(:gen)
+
+      [page.oid, page.gen]
+    end
+  end
+end

data/lib/pocketbook/render_request.rb

@@ -0,0 +1,67 @@
+module Pocketbook
+  class RenderRequest
+    attr_reader :inputs, :theme_path, :style, :template_override, :output_path, :metadata, :debounce_ms, :diagnostics, :open_output
+
+    def initialize(
+      inputs:,
+      theme_path:,
+      style: nil,
+      template_override: nil,
+      output_path:,
+      metadata: {},
+      debounce_ms: 350,
+      diagnostics: false,
+      open_output: false
+    )
+      @inputs = normalize_inputs(inputs)
+      @theme_path = normalize_required_string(theme_path, "theme_path")
+      @style = normalize_optional_string(style)
+      @template_override = normalize_optional_string(template_override)
+      @output_path = normalize_required_string(output_path, "output_path")
+      @metadata = symbolize_keys(metadata || {}).freeze
+      @debounce_ms = normalize_debounce_ms(debounce_ms)
+      @diagnostics = !!diagnostics
+      @open_output = !!open_output
+
+      freeze
+    end
+
+    private
+
+    def normalize_inputs(values)
+      items = Array(values).map { |value| normalize_required_string(value, "inputs") }
+      raise ArgumentError, "At least one markdown input file is required" if items.empty?
+
+      items.freeze
+    end
+
+    def normalize_required_string(value, label)
+      normalized = value.to_s.strip
+      raise ArgumentError, "#{label} is required" if normalized.empty?
+
+      normalized
+    end
+
+    def normalize_optional_string(value)
+      return nil if value.nil?
+
+      normalized = value.to_s.strip
+      return nil if normalized.empty?
+
+      normalized
+    end
+
+    def normalize_debounce_ms(value)
+      normalized = Integer(value)
+      raise ArgumentError, "debounce_ms must be zero or positive" if normalized.negative?
+
+      normalized
+    end
+
+    def symbolize_keys(hash)
+      hash.each_with_object({}) do |(key, value), output|
+        output[key.to_sym] = value
+      end
+    end
+  end
+end

data/lib/pocketbook/styles/core/01_tokens.css

@@ -0,0 +1,11 @@
+:root {
+  --book-size: 6in 9in;
+  --paper: #ffffff;
+  --text-color: #161616;
+  --folio-color: #5f5f5f;
+  --cover-bg: #151515;
+  --cover-fg: #f5f5f5;
+  --accent: #b88539;
+  --font-body: "Iowan Old Style", "Palatino Linotype", serif;
+  --font-display: "Avenir Next", "Helvetica Neue", sans-serif;
+}

data/lib/pocketbook/styles/core/02_pages.css

@@ -0,0 +1,72 @@
+@page {
+  size: var(--book-size);
+  background: var(--paper);
+  margin-top: 18mm;
+  margin-right: 16mm;
+  margin-bottom: 22mm;
+  margin-left: 16mm;
+}
+
+@page :left {
+  background: var(--paper);
+  margin-left: 20mm;
+  margin-right: 14mm;
+
+  @top-left {
+    content: var(--book-title-label);
+    font-family: var(--font-display);
+    font-size: 8.5pt;
+    letter-spacing: 0.04em;
+    color: var(--folio-color);
+  }
+
+  @bottom-left {
+    content: var(--publisher-label);
+    font-family: var(--font-display);
+    font-size: 8.5pt;
+    color: var(--folio-color);
+  }
+
+  @bottom-right {
+    content: counter(page);
+    font-family: var(--font-display);
+    font-size: 8.5pt;
+    color: var(--folio-color);
+  }
+}
+
+@page :right {
+  background: var(--paper);
+  margin-left: 14mm;
+  margin-right: 20mm;
+
+  @top-right {
+    content: var(--book-title-label);
+    font-family: var(--font-display);
+    font-size: 8.5pt;
+    letter-spacing: 0.04em;
+    color: var(--folio-color);
+  }
+
+  @bottom-left {
+    content: var(--publisher-label);
+    font-family: var(--font-display);
+    font-size: 8.5pt;
+    color: var(--folio-color);
+  }
+
+  @bottom-right {
+    content: counter(page);
+    font-family: var(--font-display);
+    font-size: 8.5pt;
+    color: var(--folio-color);
+  }
+}
+
+@page cover {
+  margin: 0;
+}
+
+@page backcover {
+  margin: 0;
+}

data/lib/pocketbook/styles/core/03_layout.css

@@ -0,0 +1,162 @@
+* {
+  box-sizing: border-box;
+}
+
+html,
+body {
+  margin: 0;
+  padding: 0;
+  color: var(--text-color);
+  background: var(--paper);
+  font-family: var(--font-body);
+  font-size: 11pt;
+  line-height: 1.55;
+}
+
+.cover,
+.backcover {
+  min-height: 100vh;
+  display: grid;
+  position: relative;
+  z-index: 30;
+}
+
+.cover {
+  page: cover;
+  break-after: page;
+  color: var(--cover-fg);
+  background: var(--cover-bg);
+}
+
+.backcover {
+  page: backcover;
+  break-before: page;
+  color: var(--cover-fg);
+  background: #222;
+}
+
+.cover-inner,
+.backcover-inner {
+  align-self: stretch;
+  display: grid;
+  gap: 0.8rem;
+  padding: 16mm;
+  align-content: center;
+}
+
+.cover-title {
+  margin: 0;
+  font-family: var(--font-display);
+  font-size: 2.1rem;
+  line-height: 1.1;
+  letter-spacing: 0.02em;
+}
+
+.cover-subtitle {
+  margin: 0;
+  opacity: 0.9;
+  font-size: 1rem;
+}
+
+.cover-author {
+  margin-top: 1rem;
+  margin-bottom: 0;
+  font-family: var(--font-display);
+  font-size: 0.95rem;
+  letter-spacing: 0.05em;
+  text-transform: uppercase;
+}
+
+.backcover-title {
+  margin: 0;
+  font-family: var(--font-display);
+  color: var(--accent);
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  font-size: 0.8rem;
+}
+
+.backcover-copy {
+  margin: 0;
+  font-size: 0.95rem;
+  opacity: 0.95;
+}
+
+.toc {
+  break-before: page;
+  break-after: page;
+}
+
+.toc,
+.chapter {
+  padding: 0;
+}
+
+@media screen {
+  html,
+  body {
+    min-height: 100%;
+  }
+
+  html {
+    scroll-snap-type: y mandatory;
+  }
+
+  .cover,
+  .toc,
+  .book-content,
+  .chapter,
+  .backcover,
+  [data-pocketbook-page-spacer],
+  [data-pocketbook-flow-spacer] {
+    scroll-snap-align: start;
+  }
+
+  [data-pocketbook-page-spacer],
+  [data-pocketbook-flow-spacer] {
+    scroll-snap-stop: always;
+  }
+
+  :root {
+    --pocketbook-screen-left-margin: 16mm;
+    --pocketbook-screen-right-margin: 16mm;
+  }
+
+  :root[data-pocketbook-page-parity="left"] {
+    --pocketbook-screen-left-margin: 20mm;
+    --pocketbook-screen-right-margin: 14mm;
+  }
+
+  :root[data-pocketbook-page-parity="right"] {
+    --pocketbook-screen-left-margin: 14mm;
+    --pocketbook-screen-right-margin: 20mm;
+  }
+
+  .toc,
+  .chapter {
+    /* Screen preview uses fixed running header/footer overlays. */
+    padding-top: 24mm;
+    padding-right: var(--pocketbook-screen-right-margin);
+    padding-bottom: 28mm;
+    padding-left: var(--pocketbook-screen-left-margin);
+    min-height: 100vh;
+  }
+
+  .running-header,
+  .running-footer {
+    padding-left: var(--pocketbook-screen-left-margin);
+    padding-right: var(--pocketbook-screen-right-margin);
+  }
+
+  :root[data-pocketbook-page-parity="left"] .running-header {
+    justify-content: flex-start;
+  }
+
+  :root[data-pocketbook-page-parity="right"] .running-header {
+    justify-content: flex-end;
+  }
+
+  .running-header-chapter {
+    display: none;
+  }
+}