pocketbook 0.1.0

data/lib/pocketbook/book_renderer.rb

@@ -0,0 +1,140 @@
+require "erb"
+require "fileutils"
+require "tmpdir"
+require_relative "book_template"
+require_relative "core_stylesheet"
+require_relative "book_renderer/front_matter"
+require_relative "book_renderer/chapter"
+require_relative "book_renderer/metadata"
+require_relative "book_renderer/toc"
+require_relative "book_renderer/pdf"
+
+module Pocketbook
+  class BookRenderer
+    DEFAULT_METADATA = Metadata::DEFAULT_VALUES
+
+    def initialize(inputs:, theme:, output_path: nil, metadata: {})
+      @inputs = inputs
+      @theme = theme
+      @output_path = output_path
+      @cli_metadata = symbolize_keys(metadata)
+    end
+
+    def render
+      raise ArgumentError, "Output PDF path is required" if blank?(@output_path)
+
+      validate_paths!
+
+      chapters, front_matter = chapter_compiler.compile(inputs: @inputs)
+      metadata = resolved_metadata(front_matter)
+
+      toc_targets = toc_builder.targets(chapters: chapters)
+      html_without_toc_pages = build_document_html(chapters, metadata, toc_page_numbers: {})
+      toc_page_numbers = resolve_toc_page_numbers(html_without_toc_pages, toc_targets)
+      html = build_document_html(chapters, metadata, toc_page_numbers: toc_page_numbers)
+
+      FileUtils.mkdir_p(File.dirname(@output_path))
+      generate_pdf_to_path(html, @output_path)
+
+      @output_path
+    end
+
+    def render_html
+      validate_paths!
+
+      chapters, front_matter = chapter_compiler.compile(inputs: @inputs)
+      metadata = resolved_metadata(front_matter)
+
+      build_document_html(chapters, metadata, toc_page_numbers: {})
+    end
+
+    private
+
+    def validate_paths!
+      raise ArgumentError, "At least one markdown input file is required" if @inputs.empty?
+
+      @inputs.each do |path|
+        raise ArgumentError, "Input markdown file not found: #{path}" unless File.exist?(path)
+      end
+    end
+
+    def build_document_html(chapters, metadata, toc_page_numbers:)
+      template = BookTemplate.new(template_source: @theme.template_source)
+      template.render(
+        body_html: build_body_html(chapters),
+        toc_html: build_toc_html(chapters, toc_page_numbers: toc_page_numbers),
+        styles_css: @theme.styles_css,
+        core_css: core_css,
+        metadata: metadata,
+        escape_html: method(:h)
+      )
+    end
+
+    def build_body_html(chapters)
+      chapters.map { |chapter| chapter.article_html(escape_html: method(:h)) }.join("\n")
+    end
+
+    def build_toc_html(chapters, toc_page_numbers:)
+      toc_builder.build(chapters: chapters, escape_html: method(:h), page_numbers: toc_page_numbers)
+    end
+
+    def generate_pdf_to_path(html, output_path)
+      pdf_writer.write(html: html, output_path: output_path)
+    end
+
+    def resolve_toc_page_numbers(html, toc_targets)
+      return {} if toc_targets.empty?
+
+      Dir.mktmpdir("pocketbook-toc") do |dir|
+        temp_pdf_path = File.join(dir, "toc-pass.pdf")
+        generate_pdf_to_path(html, temp_pdf_path)
+        pdf_writer.toc_page_numbers(pdf_path: temp_pdf_path, toc_targets: toc_targets)
+      end
+    rescue StandardError
+      {}
+    end
+
+    def resolved_metadata(front_matter)
+      metadata_resolver.resolve(
+        theme_defaults: @theme.defaults_metadata,
+        cli_metadata: @cli_metadata,
+        front_matter: front_matter,
+        first_input_path: @inputs.first
+      )
+    end
+
+    def h(value)
+      ERB::Util.html_escape(value.to_s)
+    end
+
+    def core_css
+      CoreStylesheet.load
+    end
+
+    def chapter_compiler
+      @chapter_compiler ||= Chapter.new
+    end
+
+    def metadata_resolver
+      @metadata_resolver ||= Metadata.new
+    end
+
+    def toc_builder
+      @toc_builder ||= Toc.new
+    end
+
+    def pdf_writer
+      @pdf_writer ||= Pdf.new
+    end
+
+    def blank?(value)
+      value.nil? || value.to_s.strip.empty?
+    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/book_template.rb

@@ -0,0 +1,40 @@
+require "erb"
+
+module Pocketbook
+  class BookTemplate
+    Context = Struct.new(
+      :body_html,
+      :toc_html,
+      :styles_css,
+      :core_css,
+      :metadata,
+      :escape_html,
+      keyword_init: true
+    ) do
+      def h(value)
+        escape_html.call(value)
+      end
+
+      def get_binding
+        binding
+      end
+    end
+
+    def initialize(template_source:)
+      @template = ERB.new(template_source, trim_mode: "-")
+    end
+
+    def render(body_html:, toc_html:, styles_css:, core_css:, metadata:, escape_html:)
+      context = Context.new(
+        body_html: body_html,
+        toc_html: toc_html,
+        styles_css: styles_css,
+        core_css: core_css,
+        metadata: metadata,
+        escape_html: escape_html
+      )
+
+      @template.result(context.get_binding)
+    end
+  end
+end

data/lib/pocketbook/cli/options_parser.rb

@@ -0,0 +1,344 @@
+require "optparse"
+require_relative "../render_request"
+
+module Pocketbook
+  module CLI
+    class OptionsParser
+      DEFAULT_DEBOUNCE_MS = 350
+      DEFAULT_THEME_NAME = "classic"
+      DEFAULT_THEME_PATH = Pocketbook.bundled_theme_path(DEFAULT_THEME_NAME)
+      DEFAULT_THEME_DIRECTORY = Pocketbook.user_themes_path
+
+      class ParsedOptions
+        attr_reader :inputs, :theme_path, :style, :template_override, :output_path, :metadata, :debounce_ms, :diagnostics, :open_output
+
+        def initialize
+          @inputs = []
+          @theme_path = DEFAULT_THEME_PATH
+          @style = nil
+          @template_override = nil
+          @output_path = "output/book.pdf"
+          @metadata = {}
+          @debounce_ms = DEFAULT_DEBOUNCE_MS
+          @diagnostics = false
+          @open_output = false
+        end
+
+        def add_inputs(path_value)
+          path_value.to_s.split(",").each do |value|
+            normalized = value.strip
+            next if normalized.empty?
+
+            @inputs << normalized
+          end
+        end
+
+        def theme_path=(value)
+          @theme_path = value
+        end
+
+        def style=(value)
+          @style = value
+        end
+
+        def template_override=(value)
+          @template_override = value
+        end
+
+        def output_path=(value)
+          @output_path = value
+        end
+
+        def metadata_value(key, value)
+          @metadata[key] = value
+        end
+
+        def debounce_ms=(value)
+          raise OptionParser::InvalidArgument, "--debounce-ms must be zero or positive" if value.negative?
+
+          @debounce_ms = value
+        end
+
+        def diagnostics!
+          @diagnostics = true
+        end
+
+        def open_output!
+          @open_output = true
+        end
+
+        def validate!
+          raise OptionParser::MissingArgument, "at least one markdown input file is required" if @inputs.empty?
+        end
+
+        def to_request
+          Pocketbook::RenderRequest.new(
+            inputs: @inputs,
+            theme_path: @theme_path,
+            style: @style,
+            template_override: @template_override,
+            output_path: @output_path,
+            metadata: @metadata,
+            debounce_ms: @debounce_ms,
+            diagnostics: @diagnostics,
+            open_output: @open_output
+          )
+        end
+      end
+
+      ThemeNewRequest = Struct.new(:name, :target_root, :with_template, :force, keyword_init: true)
+      ThemeResolveRequest = Struct.new(:theme_path, :style, keyword_init: true)
+      ThemeGetRequest = Struct.new(:url, :name, :into, :force, :dry_run, :ref, keyword_init: true)
+
+      def initialize(stdout: $stdout)
+        @stdout = stdout
+      end
+
+      def parse(argv)
+        args = argv.dup
+        command = resolve_command(args)
+
+        case command
+        when :build
+          request, parse_status = parse_render_options(args, watch: false)
+          [:build, request, parse_status]
+        when :watch
+          request, parse_status = parse_render_options(args, watch: true)
+          [:watch, request, parse_status]
+        when :theme
+          parse_theme_options(args)
+        else
+          raise OptionParser::InvalidArgument, "Unknown command '#{command}'"
+        end
+      end
+
+      private
+
+      def resolve_command(args)
+        first = args.first
+        return :build if first.nil? || first.start_with?("-")
+
+        case first
+        when "build"
+          args.shift
+          :build
+        when "watch"
+          args.shift
+          :watch
+        when "theme"
+          args.shift
+          :theme
+        else
+          :build
+        end
+      end
+
+      def parse_render_options(args, watch: false)
+        options = ParsedOptions.new
+
+        parser = OptionParser.new do |opts|
+          opts.banner = if watch
+                          "Usage: pocketbook watch FILE.md [MORE.md ...] [options]"
+                        else
+                          "Usage: pocketbook build FILE.md [MORE.md ...] [options]"
+                        end
+
+          unless watch
+            opts.separator ""
+            opts.separator "Commands:"
+            opts.separator "    build                           Build a PDF (default command)"
+            opts.separator "    watch                           Rebuild PDF on file changes"
+            opts.separator "    theme new                       Scaffold a new theme"
+            opts.separator "    theme validate                  Validate a theme reference"
+            opts.separator "    theme inspect                   Show resolved theme assets"
+            opts.separator "    theme get                       Download theme from GitHub manifest URL"
+          end
+
+          opts.on("-t", "--theme NAME_OR_PATH", "Theme name, directory, or theme.yml (default: bundled #{DEFAULT_THEME_NAME} theme)") { |path| options.theme_path = path }
+          opts.on("-s", "--style NAME", "Style variant inside the selected theme") { |value| options.style = value }
+          opts.on("--template PATH", "Template ERB override file") { |path| options.template_override = path }
+          opts.on("-o", "--output PATH", "Output PDF path (default: output/book.pdf)") { |path| options.output_path = path }
+          opts.on("--diagnostics", "Print resolved configuration diagnostics after build") { options.diagnostics! }
+          opts.on("--open", "Open the generated PDF with the OS default viewer") { options.open_output! }
+
+          opts.on("--title TEXT", "Book title") { |value| options.metadata_value(:title, value) }
+          opts.on("--subtitle TEXT", "Book subtitle") { |value| options.metadata_value(:subtitle, value) }
+          opts.on("--author TEXT", "Book author") { |value| options.metadata_value(:author, value) }
+          opts.on("--publisher TEXT", "Publisher label") { |value| options.metadata_value(:publisher, value) }
+          opts.on("--backcover TEXT", "Backcover copy") { |value| options.metadata_value(:backcover_text, value) }
+          opts.on("--size TEXT", "Book size (CSS format, ex: 6in 9in or 6inx9in)") { |value| options.metadata_value(:size, value) }
+
+          if watch
+            opts.on("--debounce-ms INTEGER", Integer, "Debounce window in milliseconds before rebuild (default: #{DEFAULT_DEBOUNCE_MS})") do |value|
+              options.debounce_ms = value
+            end
+          end
+
+          opts.on("-v", "--version", "Print version") do
+            @stdout.puts("Pocketbook #{Pocketbook::VERSION}")
+            return [nil, :exit]
+          end
+
+          opts.on("-h", "--help", "Print this help") do
+            @stdout.puts(opts)
+            return [nil, :exit]
+          end
+        end
+
+        parser.parse!(args)
+        args.each { |path| options.add_inputs(path) }
+
+        options.validate!
+        [options.to_request, :ok]
+      end
+
+      def parse_theme_options(args)
+        command = args.shift
+        case command
+        when "new"
+          parse_theme_new(args)
+        when "validate"
+          parse_theme_validate(args)
+        when "inspect"
+          parse_theme_inspect(args)
+        when "get"
+          parse_theme_get(args)
+        when nil, "-h", "--help", "help"
+          print_theme_help
+          [nil, nil, :exit]
+        else
+          raise OptionParser::InvalidArgument, "Unknown theme command '#{command}'"
+        end
+      end
+
+      def parse_theme_new(args)
+        options = {
+          target_root: DEFAULT_THEME_DIRECTORY,
+          with_template: false,
+          force: false
+        }
+
+        parser = OptionParser.new do |opts|
+          opts.banner = "Usage: pocketbook theme new NAME [options]"
+          opts.separator ""
+          opts.separator "Options:"
+          opts.on("--path DIR", "Theme directory root (default: #{DEFAULT_THEME_DIRECTORY})") { |value| options[:target_root] = value }
+          opts.on("--with-template", "Create template.html.erb scaffold") { options[:with_template] = true }
+          opts.on("--force", "Overwrite scaffold files when they already exist") { options[:force] = true }
+          opts.on("-h", "--help", "Print this help") do
+            @stdout.puts(opts)
+            return [nil, nil, :exit]
+          end
+        end
+
+        parser.parse!(args)
+
+        name = args.shift
+        raise OptionParser::MissingArgument, "theme name is required" if blank?(name)
+        raise OptionParser::InvalidArgument, "Unexpected arguments: #{args.join(' ')}" unless args.empty?
+
+        request = ThemeNewRequest.new(
+          name: name.to_s.strip,
+          target_root: options[:target_root].to_s.strip,
+          with_template: options[:with_template],
+          force: options[:force]
+        )
+        [:theme_new, request, :ok]
+      end
+
+      def parse_theme_validate(args)
+        parse_theme_resolve(args, :theme_validate, "Usage: pocketbook theme validate [THEME_NAME_OR_PATH] [--style NAME]")
+      end
+
+      def parse_theme_inspect(args)
+        parse_theme_resolve(args, :theme_inspect, "Usage: pocketbook theme inspect [THEME_NAME_OR_PATH] [--style NAME]")
+      end
+
+      def parse_theme_get(args)
+        options = {
+          name: nil,
+          into: DEFAULT_THEME_DIRECTORY,
+          force: false,
+          dry_run: false,
+          ref: nil
+        }
+
+        parser = OptionParser.new do |opts|
+          opts.banner = "Usage: pocketbook theme get GITHUB_THEME_YML_URL [options]"
+          opts.on("--name NAME", "Destination theme name override") { |value| options[:name] = value }
+          opts.on("--into DIR", "Destination theme directory root (default: #{DEFAULT_THEME_DIRECTORY})") { |value| options[:into] = value }
+          opts.on("--ref REF", "Git reference override (branch/tag/sha)") { |value| options[:ref] = value }
+          opts.on("--force", "Overwrite existing destination theme directory") { options[:force] = true }
+          opts.on("--dry-run", "Print planned downloads without writing files") { options[:dry_run] = true }
+          opts.on("-h", "--help", "Print this help") do
+            @stdout.puts(opts)
+            return [nil, nil, :exit]
+          end
+        end
+
+        parser.parse!(args)
+        url = args.shift
+        raise OptionParser::MissingArgument, "theme manifest URL is required" if blank?(url)
+        raise OptionParser::InvalidArgument, "Unexpected arguments: #{args.join(' ')}" unless args.empty?
+
+        request = ThemeGetRequest.new(
+          url: url.to_s.strip,
+          name: normalize_optional_string(options[:name]),
+          into: options[:into].to_s.strip,
+          force: options[:force],
+          dry_run: options[:dry_run],
+          ref: normalize_optional_string(options[:ref])
+        )
+
+        [:theme_get, request, :ok]
+      end
+
+      def parse_theme_resolve(args, command, usage)
+        options = {
+          style: nil
+        }
+
+        parser = OptionParser.new do |opts|
+          opts.banner = usage
+          opts.on("-s", "--style NAME", "Style variant to resolve") { |value| options[:style] = value }
+          opts.on("-h", "--help", "Print this help") do
+            @stdout.puts(opts)
+            return [nil, nil, :exit]
+          end
+        end
+
+        parser.parse!(args)
+        theme_path = args.shift || DEFAULT_THEME_NAME
+        raise OptionParser::InvalidArgument, "Unexpected arguments: #{args.join(' ')}" unless args.empty?
+
+        request = ThemeResolveRequest.new(theme_path: theme_path, style: options[:style])
+        [command, request, :ok]
+      end
+
+      def print_theme_help
+        @stdout.puts <<~TEXT
+          Usage: pocketbook theme <command> [options]
+
+          Commands:
+            new NAME             Scaffold a new theme directory
+            validate [THEME]     Validate that a theme resolves correctly
+            inspect [THEME]      Print resolved theme details
+            get URL              Download a theme from a GitHub theme.yml URL
+        TEXT
+      end
+
+      def normalize_optional_string(value)
+        return nil if value.nil?
+
+        normalized = value.to_s.strip
+        return nil if normalized.empty?
+
+        normalized
+      end
+
+      def blank?(value)
+        value.nil? || value.to_s.strip.empty?
+      end
+    end
+  end
+end