pocketbook 0.1.0

data/lib/pocketbook/styles/core/04_toc.css

@@ -0,0 +1,62 @@
+.toc-inner {
+  padding-top: 0;
+}
+
+.toc-heading {
+  margin-top: 0;
+  margin-bottom: 1.1rem;
+  font-family: var(--font-display);
+  font-size: 1.4rem;
+}
+
+.toc-list {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.toc-item + .toc-item {
+  margin-top: 0.45rem;
+}
+
+.toc-link {
+  color: inherit;
+  text-decoration: none;
+  display: flex;
+  align-items: baseline;
+  gap: 0.45rem;
+}
+
+.toc-title {
+  font-family: var(--font-display);
+}
+
+.toc-item-level-2 .toc-link,
+.toc-item-level-3 .toc-link {
+  font-size: 0.95em;
+}
+
+.toc-item-level-2 .toc-link {
+  padding-left: 0.9rem;
+}
+
+.toc-item-level-3 .toc-link {
+  padding-left: 1.8rem;
+  font-size: 0.9em;
+}
+
+.toc-item-level-2 .toc-title,
+.toc-item-level-3 .toc-title {
+  font-family: var(--font-body);
+}
+
+.toc-fill {
+  flex: 1;
+  border-bottom: 1px dotted rgba(0, 0, 0, 0.3);
+}
+
+.toc-page {
+  font-variant-numeric: tabular-nums;
+  min-width: 2ch;
+  text-align: right;
+}

data/lib/pocketbook/styles/core/05_content.css

@@ -0,0 +1,49 @@
+.book-content {
+  break-before: page;
+}
+
+.chapter + .chapter {
+  break-before: page;
+}
+
+.running-chapter-title {
+  margin: 0;
+  height: 0;
+  overflow: hidden;
+  font-size: 0;
+  line-height: 0;
+  position: running(chapter-title);
+}
+
+.chapter h1,
+.chapter h2,
+.chapter h3,
+.chapter h4 {
+  font-family: var(--font-display);
+  line-height: 1.2;
+}
+
+.chapter h1 {
+  string-set: chapter-title content(text);
+  font-size: 1.8rem;
+  margin-top: 0;
+  margin-bottom: 1.2rem;
+}
+
+.chapter h2 {
+  margin-top: 1.8rem;
+  margin-bottom: 0.6rem;
+  font-size: 1.3rem;
+}
+
+.chapter p,
+.chapter li {
+  widows: 2;
+  orphans: 2;
+}
+
+.chapter img {
+  max-width: 100%;
+  height: auto;
+  break-inside: avoid;
+}

data/lib/pocketbook/styles/core/06_running.css

@@ -0,0 +1,48 @@
+.running-header,
+.running-footer {
+  position: fixed;
+  left: 0;
+  right: 0;
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  font-family: var(--font-display);
+  font-size: 8.5pt;
+  letter-spacing: 0.04em;
+  color: var(--folio-color);
+  z-index: 20;
+}
+
+.running-header {
+  top: 6mm;
+  padding-left: var(--pocketbook-screen-left-margin, 16mm);
+  padding-right: var(--pocketbook-screen-right-margin, 16mm);
+}
+
+.running-header-chapter::after {
+  content: attr(data-fallback);
+}
+
+@supports (content: string(chapter-title)) {
+  .running-header-chapter::after {
+    content: string(chapter-title);
+  }
+}
+
+.running-footer {
+  bottom: 6mm;
+  padding-left: var(--pocketbook-screen-left-margin, 16mm);
+  padding-right: var(--pocketbook-screen-right-margin, 16mm);
+}
+
+.page-number::after {
+  content: counter(page);
+}
+
+.running-divider {
+  display: inline-block;
+  width: 16px;
+  height: 1px;
+  margin: 0 8px;
+  background: var(--folio-color);
+}

data/lib/pocketbook/styles/core/07_print.css

@@ -0,0 +1,12 @@
+@media print {
+  html,
+  body {
+    background: var(--paper);
+    color: var(--text-color);
+  }
+
+  .running-header,
+  .running-footer {
+    display: none;
+  }
+}

data/lib/pocketbook/theme/manifest.rb

@@ -0,0 +1,244 @@
+require "yaml"
+
+module Pocketbook
+  class Theme
+    class Manifest
+      OPTIONAL_FIELDS = %w[name version template styles defaults].freeze
+      SUPPORTED_FIELDS = OPTIONAL_FIELDS
+      DEFAULT_STYLE_NAME = "default"
+      SUPPORTED_DEFAULTS = %w[style title subtitle author publisher backcover_text size].freeze
+
+      class Defaults
+        def initialize(values, path)
+          @values = values
+          @path = path
+          validate!
+        end
+
+        def style_name
+          normalize_optional_string(fetch("style"))
+        end
+
+        def metadata
+          return {} if @values.nil?
+
+          @values.each_with_object({}) do |(key, value), output|
+            key_name = key.to_s
+            next if key_name == "style"
+
+            output[key_name.to_sym] = value
+          end
+        end
+
+        private
+
+        def validate!
+          return if @values.nil?
+
+          unless @values.is_a?(Hash)
+            raise ArgumentError, "Manifest defaults must be a YAML object in #{@path}"
+          end
+
+          unknown_defaults = @values.keys.map(&:to_s) - SUPPORTED_DEFAULTS
+          unless unknown_defaults.empty?
+            raise ArgumentError,
+                  "Unknown defaults keys in #{@path}: #{unknown_defaults.join(', ')}. Supported keys: #{SUPPORTED_DEFAULTS.join(', ')}"
+          end
+
+          style_default = fetch("style")
+          return if style_default.nil?
+
+          validate_non_empty_string!(style_default, "defaults.style")
+        end
+
+        def fetch(key)
+          return nil unless @values.is_a?(Hash)
+
+          @values[key] || @values[key.to_sym]
+        end
+
+        def validate_non_empty_string!(value, label)
+          unless value.is_a?(String) && !value.strip.empty?
+            raise ArgumentError, "Manifest #{label} must be a non-empty string in #{@path}"
+          end
+        end
+
+        def normalize_optional_string(value)
+          return nil if value.nil?
+
+          normalized = value.to_s.strip
+          return nil if normalized.empty?
+
+          normalized
+        end
+      end
+
+      class StyleCatalog
+        def initialize(styles, path)
+          @path = path
+          @style_map = normalize_style_map(styles)
+        end
+
+        def available_styles
+          @style_map.keys
+        end
+
+        def style?(style_name)
+          @style_map.key?(style_name)
+        end
+
+        def paths_for(style_name)
+          @style_map.fetch(style_name)
+        end
+
+        private
+
+        def normalize_style_map(styles)
+          return {} if styles.nil?
+
+          if styles.is_a?(String)
+            return { DEFAULT_STYLE_NAME => normalize_style_entries(styles, "styles") }
+          end
+
+          if styles.is_a?(Array)
+            return { DEFAULT_STYLE_NAME => normalize_style_entries(styles, "styles") }
+          end
+
+          unless styles.is_a?(Hash) && !styles.empty?
+            raise ArgumentError, "Manifest styles must be a string, a non-empty map, or a non-empty array in #{@path}"
+          end
+
+          styles.each_with_object({}) do |(style_name, entries), output|
+            style_key = style_name.to_s.strip
+            if style_key.empty?
+              raise ArgumentError, "Manifest styles map contains an empty style name in #{@path}"
+            end
+
+            output[style_key] = normalize_style_entries(entries, "styles.#{style_key}")
+          end
+        end
+
+        def normalize_style_entries(entries, label)
+          values = if entries.is_a?(String)
+                     [entries]
+                   elsif entries.is_a?(Array) && !entries.empty?
+                     entries
+                   else
+                     raise ArgumentError, "Manifest #{label} must be a string or a non-empty array in #{@path}"
+                   end
+
+          values.each_with_index do |value, index|
+            validate_non_empty_string!(value, "#{label}[#{index}]")
+          end
+
+          values
+        end
+
+        def validate_non_empty_string!(value, label)
+          unless value.is_a?(String) && !value.strip.empty?
+            raise ArgumentError, "Manifest #{label} must be a non-empty string in #{@path}"
+          end
+        end
+      end
+
+      attr_reader :path
+
+      def self.supported_fields
+        SUPPORTED_FIELDS
+      end
+
+      def self.supported_defaults
+        SUPPORTED_DEFAULTS
+      end
+
+      def initialize(path:)
+        @path = path
+        @values = load_manifest(path)
+        validate_manifest!
+        @defaults = Defaults.new(@values["defaults"], path)
+        @style_catalog = StyleCatalog.new(@values["styles"], path)
+      end
+
+      def name(default_name)
+        @values.fetch("name", default_name)
+      end
+
+      def version(default_version = "0.1.0")
+        @values.fetch("version", default_version)
+      end
+
+      def template_reference
+        normalize_optional_string(@values["template"])
+      end
+
+      def styles_declared?
+        !@style_catalog.available_styles.empty?
+      end
+
+      def available_styles
+        @style_catalog.available_styles
+      end
+
+      def style?(style_name)
+        @style_catalog.style?(style_name)
+      end
+
+      def style_paths_for(style_name)
+        @style_catalog.paths_for(style_name)
+      end
+
+      def default_style_name
+        @defaults.style_name
+      end
+
+      def defaults_metadata
+        @defaults.metadata
+      end
+
+      private
+
+      def load_manifest(manifest_path)
+        loaded = YAML.safe_load(File.read(manifest_path), aliases: true)
+        raise ArgumentError, "Manifest must contain a YAML object: #{manifest_path}" unless loaded.is_a?(Hash)
+
+        loaded.each_with_object({}) do |(key, value), output|
+          output[key.to_s] = value
+        end
+      rescue Psych::SyntaxError => e
+        raise ArgumentError, "Invalid theme manifest YAML in #{manifest_path}: #{e.message}"
+      end
+
+      def validate_manifest!
+        unknown_fields = @values.keys - SUPPORTED_FIELDS
+        unless unknown_fields.empty?
+          raise ArgumentError, "Unknown manifest keys in #{path}: #{unknown_fields.join(', ')}"
+        end
+
+        validate_optional_string!("template")
+        validate_optional_string!("name")
+        validate_optional_string!("version")
+      end
+
+      def validate_optional_string!(key)
+        return unless @values.key?(key)
+
+        validate_non_empty_string!(@values[key], key)
+      end
+
+      def validate_non_empty_string!(value, label)
+        unless value.is_a?(String) && !value.strip.empty?
+          raise ArgumentError, "Manifest #{label} must be a non-empty string in #{path}"
+        end
+      end
+
+      def normalize_optional_string(value)
+        return nil if value.nil?
+
+        normalized = value.to_s.strip
+        return nil if normalized.empty?
+
+        normalized
+      end
+    end
+  end
+end

data/lib/pocketbook/theme.rb

@@ -0,0 +1,268 @@
+require_relative "theme/manifest"
+
+module Pocketbook
+  class Theme
+    DEFAULT_MANIFEST = "theme.yml"
+    DEFAULT_TEMPLATE_CANDIDATES = ["template.html.erb", "layout.html.erb"].freeze
+
+    class Location
+      attr_reader :root_path, :manifest_path
+
+      def initialize(theme_reference:, cwd: Dir.pwd)
+        input_path = Theme.resolve_theme_path(theme_reference, cwd: cwd)
+        @root_path = resolve_root(input_path)
+
+        raise ArgumentError, "Theme directory not found: #{theme_reference}" unless Dir.exist?(@root_path)
+
+        @manifest_path = resolve_manifest_path(input_path)
+      end
+
+      private
+
+      def resolve_root(input_path)
+        return File.dirname(input_path) if File.file?(input_path)
+
+        input_path
+      end
+
+      def resolve_manifest_path(input_path)
+        return input_path if File.file?(input_path)
+
+        theme_manifest = File.join(@root_path, DEFAULT_MANIFEST)
+        return theme_manifest if File.file?(theme_manifest)
+
+        nil
+      end
+    end
+
+    class AssetPaths
+      attr_reader :template_path, :style_paths, :style_name, :available_styles
+
+      def initialize(root_path:, manifest:, style: nil, template_override: nil)
+        @root_path = root_path
+        @manifest = manifest
+        @style_map = build_style_map
+        @available_styles = @style_map.keys.sort
+
+        @template_path = resolve_template_path(template_override)
+        @style_name = resolve_style_name(style)
+        @style_paths = resolve_style_paths(@style_name)
+      end
+
+      private
+
+      def resolve_template_path(override_path)
+        if present?(override_path)
+          resolved_override = resolve_local_reference(override_path, "template")
+          return resolved_override if resolved_override
+
+          raise ArgumentError, "Theme template override file not found: #{override_path}"
+        end
+
+        manifest_template = @manifest&.template_reference
+        if present?(manifest_template)
+          resolved_manifest_template = resolve_local_reference(manifest_template, "template")
+          return resolved_manifest_template if resolved_manifest_template
+
+          raise ArgumentError, "Theme template file not found: #{manifest_template}"
+        end
+
+        DEFAULT_TEMPLATE_CANDIDATES.each do |relative_path|
+          candidate = File.expand_path(relative_path, @root_path)
+          return candidate if File.file?(candidate)
+        end
+
+        default_template_path
+      end
+
+      def resolve_local_reference(reference, label)
+        candidate = File.expand_path(reference, @root_path)
+        validate_inside_root!(candidate, label)
+
+        return candidate if File.file?(candidate)
+
+        nil
+      end
+
+      def default_template_path
+        File.join(Pocketbook.bundled_theme_path("basic"), "template.html.erb")
+      end
+
+      def resolve_style_name(requested_style)
+        explicit_style = normalize_optional_string(requested_style)
+        if explicit_style
+          return explicit_style if @style_map.key?(explicit_style)
+
+          raise ArgumentError,
+                "Unknown style '#{explicit_style}'. Available styles: #{available_styles.join(', ')}"
+        end
+
+        default_style = @manifest&.default_style_name
+        if default_style && @style_map.key?(default_style)
+          return default_style
+        end
+
+        return "default" if @style_map.key?("default")
+
+        available_styles.first
+      end
+
+      def resolve_style_paths(selected_style)
+        return [] if selected_style.nil?
+
+        @style_map.fetch(selected_style)
+      end
+
+      def build_style_map
+        if @manifest&.styles_declared?
+          return build_style_map_from_manifest
+        end
+
+        build_style_map_from_conventions
+      end
+
+      def build_style_map_from_manifest
+        @manifest.available_styles.each_with_object({}) do |style_name, output|
+          output[style_name] = @manifest.style_paths_for(style_name).map.with_index do |relative_path, index|
+            candidate = File.expand_path(relative_path, @root_path)
+
+            validate_inside_root!(candidate, "styles.#{style_name}[#{index}]")
+            unless File.extname(candidate).downcase == ".css"
+              raise ArgumentError, "Theme styles.#{style_name}[#{index}] must point to a .css file: #{relative_path}"
+            end
+
+            raise ArgumentError, "Theme style file not found: #{candidate}" unless File.file?(candidate)
+
+            candidate
+          end
+        end
+      end
+
+      def build_style_map_from_conventions
+        styles = {}
+
+        theme_css = File.expand_path("theme.css", @root_path)
+        styles["default"] = [theme_css] if File.file?(theme_css)
+
+        Dir.glob(File.join(@root_path, "styles", "*.css")).sort.each do |path|
+          style_name = File.basename(path, ".css")
+          styles[style_name] ||= [path]
+        end
+
+        Dir.glob(File.join(@root_path, "*.css")).sort.each do |path|
+          next if File.basename(path) == "theme.css"
+
+          style_name = File.basename(path, ".css")
+          styles[style_name] ||= [path]
+        end
+
+        styles
+      end
+
+      def validate_inside_root!(path, label)
+        expanded_root = File.expand_path(@root_path)
+        expanded_path = File.expand_path(path)
+
+        return if expanded_path == expanded_root || expanded_path.start_with?("#{expanded_root}/")
+
+        raise ArgumentError, "Theme #{label} path escapes theme root: #{path}"
+      end
+
+      def present?(value)
+        !value.nil? && !value.to_s.strip.empty?
+      end
+
+      def normalize_optional_string(value)
+        return nil if value.nil?
+
+        normalized = value.to_s.strip
+        return nil if normalized.empty?
+
+        normalized
+      end
+    end
+
+    attr_reader :root_path, :template_path, :style_paths, :style_name, :available_styles
+
+    def self.supported_manifest_fields
+      Manifest.supported_fields
+    end
+
+    def self.supported_manifest_defaults
+      Manifest.supported_defaults
+    end
+
+    def self.resolve_theme_path(theme_reference, cwd: Dir.pwd)
+      reference = theme_reference.to_s.strip
+      return File.expand_path(reference, cwd) if path_reference?(reference)
+
+      project_theme_path = File.expand_path(File.join("themes", reference), cwd)
+      return project_theme_path if theme_location_exists?(project_theme_path)
+
+      user_theme_path = Pocketbook.user_themes_path(reference)
+      return user_theme_path if theme_location_exists?(user_theme_path)
+
+      bundled_path = Pocketbook.bundled_theme_path(reference)
+      return bundled_path if theme_location_exists?(bundled_path)
+
+      File.expand_path(reference, cwd)
+    end
+
+    def initialize(theme_path:, style: nil, template_override: nil, cwd: Dir.pwd)
+      location = Location.new(theme_reference: theme_path, cwd: cwd)
+      @root_path = location.root_path
+      @manifest = location.manifest_path ? Manifest.new(path: location.manifest_path) : nil
+
+      assets = AssetPaths.new(
+        root_path: @root_path,
+        manifest: @manifest,
+        style: style,
+        template_override: template_override
+      )
+      @template_path = assets.template_path
+      @style_name = assets.style_name
+      @style_paths = assets.style_paths
+      @available_styles = assets.available_styles
+    end
+
+    def name
+      default_name = File.basename(root_path)
+      return default_name unless @manifest
+
+      @manifest.name(default_name)
+    end
+
+    def version
+      return "0.1.0" unless @manifest
+
+      @manifest.version
+    end
+
+    def defaults_metadata
+      return {} unless @manifest
+
+      @manifest.defaults_metadata
+    end
+
+    def template_source
+      File.read(template_path)
+    end
+
+    def styles_css
+      style_paths.map { |path| File.read(path) }.join("\n\n")
+    end
+
+    private
+
+    def self.path_reference?(value)
+      return true if value.start_with?("~", ".", "/")
+
+      separators = [File::SEPARATOR, File::ALT_SEPARATOR].compact.uniq
+      separators.any? { |separator| value.include?(separator) }
+    end
+
+    def self.theme_location_exists?(path)
+      File.directory?(path) || File.file?(path)
+    end
+  end
+end

data/lib/pocketbook/version.rb

@@ -0,0 +1,3 @@
+module Pocketbook
+  VERSION = "0.1.0"
+end