pocketbook 0.1.0

data/lib/pocketbook/cli/runner.rb

@@ -0,0 +1,505 @@
+require "optparse"
+require "fileutils"
+require "rbconfig"
+require "net/http"
+require "uri"
+require "yaml"
+require "tmpdir"
+require_relative "../book"
+require_relative "../theme"
+require_relative "options_parser"
+require_relative "watch_command"
+
+module Pocketbook
+  module CLI
+    class Runner
+      GitHubThemeSource = Struct.new(:owner, :repo, :ref, :theme_directory, keyword_init: true) do
+        def with_ref(new_ref)
+          self.class.new(owner: owner, repo: repo, ref: new_ref, theme_directory: theme_directory)
+        end
+
+        def raw_base
+          "https://raw.githubusercontent.com/#{owner}/#{repo}/#{ref}"
+        end
+
+        def raw_manifest_url
+          raw_file_url("theme.yml")
+        end
+
+        def raw_file_url(relative_path)
+          joined = [theme_directory, relative_path].reject { |part| part.nil? || part.empty? || part == "." }.join("/")
+          "#{raw_base}/#{joined}"
+        end
+
+        def default_theme_name
+          File.basename(theme_directory)
+        end
+      end
+
+      def initialize(stdout: $stdout, stderr: $stderr, options_parser: nil, watcher_class: Watcher)
+        @stdout = stdout
+        @stderr = stderr
+        @options_parser = options_parser || OptionsParser.new(stdout: @stdout)
+        @watcher_class = watcher_class
+      end
+
+      def run(argv = ARGV)
+        command, request, parse_status = @options_parser.parse(argv)
+        return if parse_status == :exit
+
+        case command
+        when :build
+          run_build_command(request)
+        when :watch
+          build_watcher(request).run
+        when :theme_new
+          scaffold_theme(request)
+        when :theme_validate
+          validate_theme(request)
+        when :theme_inspect
+          inspect_theme(request)
+        when :theme_get
+          get_theme(request)
+        else
+          raise OptionParser::InvalidArgument, "Unknown command '#{command}'"
+        end
+      rescue OptionParser::ParseError, ArgumentError => e
+        @stderr.puts("Error: #{e.message}")
+        @stderr.puts("Run with --help for usage.")
+        exit(1)
+      end
+
+      private
+
+      def run_build_command(request)
+        started_at = monotonic_time
+        theme = build_theme(request)
+        output_path = build_book(request, theme: theme).render_to(request.output_path)
+        elapsed = monotonic_time - started_at
+
+        print_build_success(output_path, elapsed)
+        maybe_open_output(output_path) if request.open_output
+        print_next_step_hint(request)
+        print_build_diagnostics(request, theme, output_path, elapsed) if request.diagnostics
+      end
+
+      def build_book(request, theme: nil)
+        Book.new(
+          inputs: request.inputs,
+          theme: theme || build_theme(request),
+          metadata: request.metadata
+        )
+      end
+
+      def build_theme(request)
+        Theme.new(
+          theme_path: request.theme_path,
+          style: request.style,
+          template_override: request.template_override
+        )
+      end
+
+      def build_watcher(request)
+        @watcher_class.new(request: request, stdout: @stdout, stderr: @stderr)
+      end
+
+      def scaffold_theme(request)
+        target_root = File.expand_path(request.target_root)
+        raise ArgumentError, "Theme target root is required" if blank?(target_root)
+
+        theme_root = File.join(target_root, request.name)
+        if File.exist?(theme_root) && !request.force
+          raise ArgumentError, "Theme directory already exists: #{theme_root} (use --force to overwrite scaffold files)"
+        end
+
+        FileUtils.mkdir_p(theme_root)
+
+        css_path = File.join(theme_root, "theme.css")
+        write_if_allowed(
+          css_path,
+          default_theme_css(request.name),
+          force: request.force
+        )
+
+        if request.with_template
+          template_path = File.join(theme_root, "template.html.erb")
+          write_if_allowed(
+            template_path,
+            default_theme_template,
+            force: request.force
+          )
+        end
+
+        @stdout.puts("Created theme scaffold at #{theme_root}")
+        @stdout.puts("- #{css_path}")
+        @stdout.puts("- #{File.join(theme_root, 'template.html.erb')}") if request.with_template
+      end
+
+      def validate_theme(request)
+        theme = Theme.new(theme_path: request.theme_path, style: request.style)
+        @stdout.puts("Theme is valid: #{theme.name}")
+        @stdout.puts("- root: #{theme.root_path}")
+        @stdout.puts("- template: #{theme.template_path}")
+        if theme.style_name
+          @stdout.puts("- style: #{theme.style_name}")
+          theme.style_paths.each { |path| @stdout.puts("  - #{path}") }
+        else
+          @stdout.puts("- style: (none)")
+        end
+      end
+
+      def inspect_theme(request)
+        theme = Theme.new(theme_path: request.theme_path, style: request.style)
+        @stdout.puts("Theme: #{theme.name}")
+        @stdout.puts("Version: #{theme.version}")
+        @stdout.puts("Root: #{theme.root_path}")
+        @stdout.puts("Template: #{theme.template_path}")
+        @stdout.puts("Selected style: #{theme.style_name || '(none)'}")
+
+        if theme.available_styles.empty?
+          @stdout.puts("Available styles: (none)")
+        else
+          @stdout.puts("Available styles: #{theme.available_styles.join(', ')}")
+        end
+
+        @stdout.puts("Style files:")
+        if theme.style_paths.empty?
+          @stdout.puts("  (none)")
+        else
+          theme.style_paths.each { |path| @stdout.puts("  - #{path}") }
+        end
+      end
+
+      def get_theme(request)
+        source = parse_github_theme_source(request.url)
+        source = source.with_ref(request.ref) if request.ref
+
+        manifest_text = http_get(source.raw_manifest_url)
+        manifest_values = parse_manifest_values(manifest_text, source.raw_manifest_url)
+        required_files = required_theme_files(manifest_values)
+
+        theme_name = resolve_downloaded_theme_name(request.name, manifest_values, source)
+        destination_root = File.expand_path(request.into)
+        destination_theme_root = File.join(destination_root, theme_name)
+
+        if request.dry_run
+          print_theme_get_plan(source: source, destination_theme_root: destination_theme_root, files: required_files)
+          return
+        end
+
+        if File.exist?(destination_theme_root)
+          unless request.force
+            raise ArgumentError, "Destination theme already exists: #{destination_theme_root} (use --force to overwrite)"
+          end
+
+          FileUtils.rm_rf(destination_theme_root)
+        end
+
+        downloaded_theme_root = download_theme_to_temp(source: source, manifest_text: manifest_text, files: required_files, theme_name: theme_name)
+
+        begin
+          Theme.new(theme_path: downloaded_theme_root)
+
+          FileUtils.mkdir_p(destination_root)
+          FileUtils.mv(downloaded_theme_root, destination_theme_root)
+
+          @stdout.puts("Downloaded theme '#{theme_name}' to #{destination_theme_root}")
+          @stdout.puts("Use it with: pocketbook build book.md --theme #{theme_name}")
+        ensure
+          FileUtils.rm_rf(downloaded_theme_root) if File.exist?(downloaded_theme_root)
+        end
+      end
+
+      def download_theme_to_temp(source:, manifest_text:, files:, theme_name:)
+        temp_root = Dir.mktmpdir("pocketbook-theme-get")
+        theme_root = File.join(temp_root, theme_name)
+        FileUtils.mkdir_p(theme_root)
+
+        File.write(File.join(theme_root, "theme.yml"), manifest_text)
+
+        files.each do |relative_path|
+          next if relative_path == "theme.yml"
+
+          body = http_get(source.raw_file_url(relative_path))
+          destination = File.join(theme_root, relative_path)
+          ensure_safe_destination!(theme_root, destination)
+          FileUtils.mkdir_p(File.dirname(destination))
+          File.write(destination, body)
+        end
+
+        theme_root
+      end
+
+      def parse_github_theme_source(url)
+        uri = URI.parse(url)
+        unless uri.is_a?(URI::HTTPS)
+          raise ArgumentError, "Theme URL must use https"
+        end
+
+        case uri.host
+        when "github.com"
+          parse_github_blob_url(uri)
+        when "raw.githubusercontent.com"
+          parse_github_raw_url(uri)
+        else
+          raise ArgumentError, "Unsupported theme URL host: #{uri.host}"
+        end
+      rescue URI::InvalidURIError => e
+        raise ArgumentError, "Invalid theme URL: #{e.message}"
+      end
+
+      def parse_github_blob_url(uri)
+        segments = uri.path.split("/").reject(&:empty?)
+        unless segments.length >= 6 && segments[2] == "blob"
+          raise ArgumentError, "GitHub URL must look like https://github.com/<org>/<repo>/blob/<ref>/.../theme.yml"
+        end
+
+        owner = segments[0]
+        repo = segments[1]
+        ref = segments[3]
+        manifest_path = segments[4..].join("/")
+
+        build_github_source(owner: owner, repo: repo, ref: ref, manifest_path: manifest_path)
+      end
+
+      def parse_github_raw_url(uri)
+        segments = uri.path.split("/").reject(&:empty?)
+        unless segments.length >= 5
+          raise ArgumentError, "Raw GitHub URL must look like https://raw.githubusercontent.com/<org>/<repo>/<ref>/.../theme.yml"
+        end
+
+        owner = segments[0]
+        repo = segments[1]
+        ref = segments[2]
+        manifest_path = segments[3..].join("/")
+
+        build_github_source(owner: owner, repo: repo, ref: ref, manifest_path: manifest_path)
+      end
+
+      def build_github_source(owner:, repo:, ref:, manifest_path:)
+        unless File.basename(manifest_path) == "theme.yml"
+          raise ArgumentError, "Theme URL must point to a theme.yml file"
+        end
+
+        theme_directory = File.dirname(manifest_path)
+        theme_directory = "." if theme_directory.nil? || theme_directory.empty?
+
+        GitHubThemeSource.new(owner: owner, repo: repo, ref: ref, theme_directory: theme_directory)
+      end
+
+      def required_theme_files(manifest_values)
+        files = ["theme.yml"]
+
+        template_path = manifest_values["template"]
+        files << template_path if template_path.is_a?(String) && !template_path.strip.empty?
+
+        styles = manifest_values["styles"]
+        style_entries = collect_style_entries(styles)
+        files.concat(style_entries)
+
+        normalized = files.map { |path| normalize_relative_path(path) }.uniq.sort
+        normalized
+      end
+
+      def collect_style_entries(styles)
+        return [] if styles.nil?
+
+        case styles
+        when String
+          [styles]
+        when Array
+          styles
+        when Hash
+          styles.values.flat_map do |entry|
+            case entry
+            when String
+              [entry]
+            when Array
+              entry
+            else
+              raise ArgumentError, "Manifest style entries must be strings or arrays"
+            end
+          end
+        else
+          raise ArgumentError, "Manifest styles must be a string, array, or object"
+        end
+      end
+
+      def normalize_relative_path(path)
+        normalized = path.to_s.strip
+        raise ArgumentError, "Manifest contains an empty file path" if normalized.empty?
+        raise ArgumentError, "Manifest file path must be relative: #{normalized}" if normalized.start_with?("/")
+
+        segments = normalized.split("/")
+        if segments.any? { |segment| segment.nil? || segment.empty? || segment == "." || segment == ".." }
+          raise ArgumentError, "Manifest file path is not safe: #{normalized}"
+        end
+
+        normalized
+      end
+
+      def ensure_safe_destination!(theme_root, destination)
+        expanded_root = File.expand_path(theme_root)
+        expanded_destination = File.expand_path(destination)
+
+        return if expanded_destination.start_with?("#{expanded_root}/")
+
+        raise ArgumentError, "Resolved download path escapes theme root: #{destination}"
+      end
+
+      def parse_manifest_values(text, source_url)
+        values = YAML.safe_load(text, aliases: true)
+        raise ArgumentError, "Manifest at #{source_url} must be a YAML object" unless values.is_a?(Hash)
+
+        values.each_with_object({}) do |(key, value), output|
+          output[key.to_s] = value
+        end
+      rescue Psych::SyntaxError => e
+        raise ArgumentError, "Manifest YAML is invalid at #{source_url}: #{e.message}"
+      end
+
+      def resolve_downloaded_theme_name(requested_name, manifest_values, source)
+        name = requested_name
+        name = manifest_values["name"] if blank?(name)
+        name = source.default_theme_name if blank?(name)
+
+        normalized = name.to_s.strip
+        if normalized.empty? || normalized.include?("/") || normalized.include?("\\")
+          raise ArgumentError, "Invalid destination theme name: #{name.inspect}"
+        end
+
+        normalized
+      end
+
+      def print_theme_get_plan(source:, destination_theme_root:, files:)
+        @stdout.puts("Theme download plan")
+        @stdout.puts("- source: #{source.raw_manifest_url}")
+        @stdout.puts("- destination: #{destination_theme_root}")
+        @stdout.puts("- files:")
+        files.each { |path| @stdout.puts("  - #{path}") }
+      end
+
+      def http_get(url, redirect_limit: 4)
+        raise ArgumentError, "Too many redirects while fetching #{url}" if redirect_limit < 0
+
+        uri = URI.parse(url)
+        request = Net::HTTP::Get.new(uri)
+
+        response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
+          http.request(request)
+        end
+
+        case response
+        when Net::HTTPSuccess
+          response.body
+        when Net::HTTPRedirection
+          location = response["location"]
+          raise ArgumentError, "Redirect without location while fetching #{url}" if blank?(location)
+
+          redirected_url = URI.join(url, location).to_s
+          http_get(redirected_url, redirect_limit: redirect_limit - 1)
+        else
+          raise ArgumentError, "Failed to fetch #{url} (#{response.code} #{response.message})"
+        end
+      end
+
+      def write_if_allowed(path, content, force:)
+        if File.exist?(path) && !force
+          raise ArgumentError, "Scaffold file already exists: #{path} (use --force to overwrite)"
+        end
+
+        File.write(path, content)
+      end
+
+      def default_theme_css(theme_name)
+        <<~CSS
+          /* Pocketbook theme: #{theme_name} */
+
+          :root {
+            --theme-accent: #1f4f8b;
+          }
+
+          body {
+            color: #111;
+          }
+        CSS
+      end
+
+      def default_theme_template
+        File.read(File.join(Pocketbook.bundled_theme_path("basic"), "template.html.erb"))
+      end
+
+      def print_build_success(output_path, elapsed)
+        absolute_output_path = File.expand_path(output_path)
+        @stdout.puts("✅ Built #{output_path} in #{format('%.2f', elapsed)}s")
+        @stdout.puts("📄 #{absolute_output_path}")
+        @stdout.puts("👀 Open: #{open_command(absolute_output_path)}")
+      end
+
+      def print_next_step_hint(request)
+        return unless request.style.nil?
+
+        @stdout.puts("🎨 Try: pocketbook build #{request.inputs.join(' ')} --theme classic --style dark")
+      end
+
+      def maybe_open_output(output_path)
+        absolute_output_path = File.expand_path(output_path)
+        success = open_with_default_viewer(absolute_output_path)
+
+        if success
+          @stdout.puts("🚀 Opened PDF in default viewer")
+        else
+          @stderr.puts("Warning: could not open PDF automatically. Try: #{open_command(absolute_output_path)}")
+        end
+      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 print_build_diagnostics(request, theme, output_path, elapsed)
+        @stdout.puts("\nDiagnostics")
+        @stdout.puts("- inputs:")
+        request.inputs.each { |path| @stdout.puts("  - #{File.expand_path(path)}") }
+        @stdout.puts("- theme root: #{theme.root_path}")
+        @stdout.puts("- template: #{theme.template_path}")
+        @stdout.puts("- selected style: #{theme.style_name || '(none)'}")
+        @stdout.puts("- style files:")
+        if theme.style_paths.empty?
+          @stdout.puts("  (none)")
+        else
+          theme.style_paths.each { |path| @stdout.puts("  - #{path}") }
+        end
+        @stdout.puts("- output: #{File.expand_path(output_path)}")
+        @stdout.puts("- elapsed: #{format('%.2f', elapsed)}s")
+      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 blank?(value)
+        value.nil? || value.to_s.strip.empty?
+      end
+    end
+  end
+end