booksmith 1.0.0

data/lib/booksmith/font_paths.rb

@@ -0,0 +1,56 @@
+module Booksmith
+  module FontPaths
+    NOTO_SANS_FILES = {
+      normal: 'NotoSans-Regular.ttf',
+      bold: 'NotoSans-Bold.ttf',
+      italic: 'NotoSans-Italic.ttf',
+      bold_italic: 'NotoSans-BoldItalic.ttf'
+    }.freeze
+
+    NOTO_SANS_MONO_FILES = {
+      normal: 'NotoSansMono-Regular.ttf',
+      bold: 'NotoSansMono-Bold.ttf'
+    }.freeze
+
+    def self.search_dirs
+      [
+        File.join(Dir.pwd, 'assets', 'fonts'),
+        File.expand_path('../fonts', __dir__),
+        File.expand_path('~/Library/Fonts'),
+        '/usr/share/fonts/noto',
+        '/usr/share/fonts/truetype/noto',
+        '/usr/local/share/fonts/noto',
+        *Dir.glob('/opt/homebrew/Caskroom/font-noto-sans/*/NotoSans/unhinted/ttf'),
+        *Dir.glob('/opt/homebrew/Caskroom/font-noto-sans-mono/*/NotoSansMono/unhinted/ttf'),
+        *Dir.glob('/usr/local/Caskroom/font-noto-sans/*/NotoSans/unhinted/ttf'),
+        *Dir.glob('/usr/local/Caskroom/font-noto-sans-mono/*/NotoSansMono/unhinted/ttf')
+      ]
+    end
+
+    def self.resolve(filename)
+      search_dirs.each do |dir|
+        path = File.join(dir, filename)
+        return path if File.file?(path)
+      end
+
+      raise <<~MSG.strip
+        #{filename} not found. Install Noto fonts (e.g. `brew install --cask font-noto-sans font-noto-sans-mono`) or add font files to assets/fonts/.
+      MSG
+    end
+
+    def self.families
+      {
+        'Noto Sans' => NOTO_SANS_FILES.transform_values { |file| resolve(file) },
+        'Noto Sans Mono' => NOTO_SANS_MONO_FILES.transform_values { |file| resolve(file) }
+      }
+    end
+
+    def self.all_files
+      families.values.flat_map(&:values).uniq
+    end
+
+    def self.register(pdf)
+      pdf.font_families.update(families)
+    end
+  end
+end

data/lib/booksmith/headers.rb

@@ -0,0 +1,97 @@
+module Booksmith
+  module Headers
+    private
+
+    SUBTITLE_COMMENT = /\A<!--\s*subtitle:\s*(.*?)\s*-->\z/i
+    PAGE_BREAK_COMMENT = /\A<!--\s*PAGE_BREAK\s*-->\z/i
+
+    # Kramdown requires a blank line between consecutive headers.
+    def self.normalize_consecutive_headers(content)
+      lines = content.lines
+      normalized = []
+      lines.each_with_index do |line, idx|
+        normalized << line
+        next_line = lines[idx + 1]
+        if line.match?(/\A\#{1,6}\s/) && next_line&.match?(/\A\#{1,6}\s/)
+          normalized << "\n"
+        end
+      end
+      normalized.join
+    end
+
+    def normalize_consecutive_headers(content)
+      Headers.normalize_consecutive_headers(content)
+    end
+
+    def subtitle_comment?(el)
+      el&.type == :xml_comment && el.value.to_s =~ SUBTITLE_COMMENT
+    end
+
+    def subtitle_comment_text(el)
+      el.value.to_s[SUBTITLE_COMMENT, 1]&.strip
+    end
+
+    def render_subtitle(text)
+      size = @config.fetch(:subtitle_font_size, @config[:h4_font_size])
+      style = @config.fetch(:subtitle_bold, false) ? :bold : nil
+      font_name = @config[:subtitle_font]
+      if font_name
+        @pdf.font(font_name) do
+          @pdf.text text, size: size, style: style
+        end
+      else
+        @pdf.text text, size: size, style: style
+      end
+    end
+
+    def render_header(el, prev:, next_el:)
+      prev_is_page_break = prev&.type == :xml_comment && prev.value.to_s =~ PAGE_BREAK_COMMENT
+      if prev&.type == :header || prev_is_page_break
+        @pdf.move_down 0
+      else
+        @pdf.move_down 20
+      end
+
+      level = el.options[:level]
+
+      header_sizes = {
+        1 => @config[:h1_font_size],
+        2 => @config[:h2_font_size],
+        3 => @config[:h3_font_size],
+        4 => @config[:h4_font_size]
+      }
+
+      size = header_sizes[level]
+      raise KeyError, "Missing required header font size config for H#{level} (:h#{level}_font_size)" unless size
+
+      font_name = @config[:header_font]
+      if font_name
+        @pdf.font(font_name) do
+          @pdf.text el.options[:raw_text], size: size, style: :bold
+        end
+      else
+        @pdf.text el.options[:raw_text], size: size, style: :bold
+      end
+
+      title_spacing_after = @config.fetch(:title_spacing_after, 20)
+      if level == 1 && subtitle_comment?(next_el)
+        @pdf.move_down 0
+      elsif next_el&.type == :header
+        @pdf.move_down 0
+      elsif level == 1
+        @pdf.move_down title_spacing_after
+      else
+        @pdf.move_down 14
+      end
+    end
+
+    def render_xml_comment(el, prev:)
+      if el.value.to_s =~ PAGE_BREAK_COMMENT
+        @pdf.start_new_page
+      elsif prev&.type == :header && prev.options[:level] == 1 && (text = subtitle_comment_text(el))
+        render_subtitle(text)
+        @pdf.move_down @config.fetch(:subtitle_spacing_after, 10)
+      end
+    end
+  end
+end

data/lib/booksmith/images.rb

@@ -0,0 +1,92 @@
+require 'digest/md5'
+require 'fileutils'
+
+module Booksmith
+  module Images
+    private
+
+    def image_child(el)
+      non_blank = el.children.reject { |c| c.type == :blank || (c.type == :text && c.value.strip.empty?) }
+      return nil unless non_blank.length == 1 && non_blank.first.type == :img
+      non_blank.first
+    end
+
+    def render_image(img_el)
+      src = img_el.attr['src']
+      path = File.expand_path(src, Dir.pwd)
+      return unless File.exist?(path)
+
+      opts = img_el.attr['title'].to_s
+      margin_top    = opts[/top=(\d+(?:\.\d+)?)/,    1]&.to_f || 0
+      margin_bottom = opts[/bottom=(\d+(?:\.\d+)?)/, 1]&.to_f || 0
+      width         = opts[/width=(\d+(?:\.\d+)?)/,  1]&.to_f
+      flatten_bg = image_flatten_bg_color(bg_override: opts[/bg=([0-9A-Fa-f]{6})/, 1])
+
+      @pdf.move_down margin_top if margin_top > 0
+      max_w = width || @pdf.bounds.width
+      max_h = @pdf.cursor - 20
+      @pdf.image(prepare_png_path(path, background_color: flatten_bg), fit: [max_w, max_h], position: :center)
+      @pdf.move_down margin_bottom if margin_bottom > 0
+    end
+
+    def image_flatten_bg_color(bg_override: nil)
+      return bg_override if bg_override
+      return @image_flatten_bg if @image_flatten_bg
+
+      @config.fetch(:image_flatten_bg_color, 'FFFFFF')
+    end
+
+    def blockquote_image_flatten_color(style_name)
+      flatten_key = :"#{style_name}_image_flatten_bg_color"
+      return @config[flatten_key] if @config.key?(flatten_key)
+
+      blockquote_style_value(style_name, :bg_color, 'EEEEEE')
+    end
+
+    def with_image_flatten_bg(color)
+      previous = @image_flatten_bg
+      @image_flatten_bg = color
+      yield
+    ensure
+      @image_flatten_bg = previous
+    end
+
+    def magick_available?
+      return @magick_available unless @magick_available.nil?
+
+      @magick_available = system('which magick > /dev/null 2>&1')
+    end
+
+    # Some PNG exports bake a visible checkerboard into opaque pixels instead of
+    # using a real alpha channel. Flatten those onto the target background.
+    def prepare_png_path(path, background_color:)
+      return path unless path.downcase.end_with?('.png')
+      return path unless magick_available?
+
+      bg_hex = background_color.to_s.delete_prefix('#').upcase
+      cache_dir = File.join(Dir.pwd, '.booksmith-cache', 'images')
+      FileUtils.mkdir_p(cache_dir)
+
+      cache_name = "#{Digest::MD5.hexdigest(path)}_#{bg_hex}_#{File.mtime(path).to_i}.png"
+      cached = File.join(cache_dir, cache_name)
+      return cached if File.exist?(cached)
+
+      success = system(
+        'magick', path,
+        '-fuzz', '12%',
+        '-transparent', 'white',
+        '-transparent', '#EBEBEB',
+        '-transparent', '#EAEAEA',
+        '-background', "##{bg_hex}",
+        '-alpha', 'remove',
+        '-compose', 'Copy',
+        '-flatten',
+        cached,
+        out: File::NULL,
+        err: File::NULL
+      )
+
+      success && File.exist?(cached) ? cached : path
+    end
+  end
+end

data/lib/booksmith/lists.rb

@@ -0,0 +1,62 @@
+module Booksmith
+  module Lists
+    private
+
+    def render_list(el)
+      list_indent = list_indent_for(el.type)
+      list_bullet_offset = @config.fetch(:list_bullet_offset, 10)
+      list_marker_gap = @config.fetch(:list_marker_gap, 4).to_f
+      list_item_spacing = @config.fetch(:list_item_spacing, 6)
+      list_margin_top = @config.fetch(:list_margin_top, 8)
+      list_margin_bottom = @config.fetch(:list_margin_bottom, 8)
+
+      @list_level += 1
+      @pdf.move_down list_margin_top if @list_level == 1
+
+      el.children.each_with_index do |item, index|
+        marker = el.type == :ul ? '•' : "#{index + 1}."
+        indent = @list_level * list_indent
+
+        @pdf.indent(indent) do
+          ensure_space_for_list_item
+          render_list_marker(marker, list_bullet_offset, align: el.type == :ul ? :center : :right)
+          @pdf.indent(list_bullet_offset + list_marker_gap) { convert_element(item) }
+        end
+        @pdf.move_down list_item_spacing unless index == el.children.length - 1
+      end
+
+      @list_level -= 1
+      @pdf.move_down list_margin_bottom if @list_level == 0
+    end
+
+    def render_list_item(el)
+      el.children.each { |child| convert_element(child) }
+    end
+
+    def list_indent_for(list_type)
+      key = list_type == :ul ? :list_bullet_indent : :list_number_indent
+      @config.fetch(key, @config.fetch(:list_indent, 18)).to_f
+    end
+
+    def ensure_space_for_list_item
+      font_size = @config[:font_size].to_f
+      min_height = font_size * @config[:line_height].to_f
+      @pdf.start_new_page if @pdf.cursor <= @pdf.bounds.bottom + min_height
+    end
+
+    def render_list_marker(marker, offset, align: :right)
+      font_size = @config[:font_size].to_f
+      body_font = @config.fetch(:body_font, 'Noto Sans')
+
+      @pdf.font(body_font, size: font_size) do
+        @pdf.formatted_text_box(
+          [{ text: marker, size: font_size, font: body_font }],
+          at: [@pdf.bounds.left, @pdf.cursor],
+          width: offset,
+          align: align,
+          leading: @config[:line_height]
+        )
+      end
+    end
+  end
+end

data/lib/booksmith/text.rb

@@ -0,0 +1,56 @@
+module Booksmith
+  module Text
+    SMART_QUOTES = {
+      ldquo: "\u201c", rdquo: "\u201d",
+      lsquo: "\u2018", rsquo: "\u2019",
+      mdash: "\u2014", ndash: "\u2013",
+      laquo: "\u00ab", raquo: "\u00bb"
+    }.freeze
+
+    private
+
+    def extract_text(element, styles: nil)
+      formatted_text = []
+
+      element.children.each do |child|
+        case child.type
+        when :text
+          entry = { text: child.value }
+          entry[:styles] = styles if styles && !styles.empty?
+          formatted_text << entry
+        when :strong
+          new_styles = (styles || []) + [:bold]
+          formatted_text.concat(extract_text(child, styles: new_styles))
+        when :em
+          new_styles = (styles || []) + [:italic]
+          formatted_text.concat(extract_text(child, styles: new_styles))
+        when :codespan
+          entry = { text: child.value, font: 'Noto Sans Mono', size: @config[:font_size] - 2 }
+          entry[:styles] = styles if styles && !styles.empty?
+          formatted_text << entry
+        when :smart_quote
+          char = SMART_QUOTES[child.value] || '?'
+          entry = { text: char }
+          entry[:styles] = styles if styles && !styles.empty?
+          formatted_text << entry
+        when :a
+          new_styles = (styles || []) + [:underline]
+          extract_text(child, styles: new_styles).each do |entry|
+            entry[:color] = '0000FF'
+            formatted_text << entry
+          end
+        else
+          # Ignore unsupported inline types for now
+        end
+      end
+
+      formatted_text
+    end
+
+    def plain_text(element)
+      return '' unless element
+
+      extract_text(element).map { |entry| entry[:text] }.join
+    end
+  end
+end

data/lib/booksmith/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Booksmith
+  VERSION = '1.0.0'
+end

data/lib/booksmith.rb

@@ -0,0 +1,218 @@
+require 'commander'
+require 'prawn'
+require 'kramdown'
+require 'fileutils'
+
+require_relative 'booksmith/version'
+require_relative 'booksmith/font_paths'
+require_relative 'booksmith/headers'
+require_relative 'booksmith/text'
+require_relative 'booksmith/lists'
+require_relative 'booksmith/blockquotes'
+require_relative 'booksmith/images'
+require_relative 'booksmith/book_generator'
+require_relative 'booksmith/epub_generator'
+
+module Booksmith
+  class PDFConverter
+    include Headers
+    include Text
+    include Lists
+    include Blockquotes
+    include Images
+
+    def initialize(pdf, config, image_flatten_bg: nil)
+      @pdf = pdf
+      @config = config
+      @list_level = 0
+      @image_flatten_bg = image_flatten_bg
+    end
+
+    def convert(content)
+      content = normalize_consecutive_headers(content)
+      doc = Kramdown::Document.new(content)
+      convert_element(doc.root)
+    end
+
+    private
+
+    def convert_element(el, prev: nil, next_el: nil)
+      case el.type
+      when :header        then render_header(el, prev: prev, next_el: next_el)
+      when :xml_comment   then render_xml_comment(el, prev: prev)
+      when :p             then render_paragraph(el)
+      when :blockquote    then render_blockquote_element(el)
+      when :codeblock     then render_codeblock(el)
+      when :ul, :ol       then render_list(el)
+      when :li            then render_list_item(el)
+      when :text          then nil
+      else                     render_children(el)
+      end
+    end
+
+    def render_paragraph(el)
+      img_el = image_child(el)
+      if img_el
+        render_image(img_el)
+        @pdf.move_down 10
+        return
+      end
+
+      @pdf.formatted_text extract_text(el), size: @config[:font_size], leading: @config[:line_height]
+      @pdf.move_down 10 unless @list_level > 0
+    end
+
+    def render_blockquote_element(el)
+      if exercise_blockquote?(el)
+        render_exercise_blockquote(el)
+      elsif alt_blockquote?(el)
+        render_blockquote(el, :alt_blockquote)
+      else
+        render_blockquote(el, :blockquote)
+      end
+    end
+
+    def render_codeblock(el)
+      @pdf.font('Noto Sans Mono') do
+        @pdf.formatted_text_box(
+          [{ text: el.value, size: @config[:font_size] - 2 }],
+          at: [@pdf.bounds.left + 20, @pdf.cursor],
+          width: @pdf.bounds.width - 40
+        )
+      end
+      @pdf.move_down(el.value.lines.count * (@config[:font_size] + 2) + 10)
+    end
+
+    def render_children(el)
+      el.children.each_with_index do |child, idx|
+        prev_idx = idx - 1
+        prev_child = nil
+        while prev_idx >= 0
+          candidate = el.children[prev_idx]
+          if candidate.type != :blank
+            prev_child = candidate
+            break
+          end
+          prev_idx -= 1
+        end
+
+        next_idx = idx + 1
+        next_child = nil
+        while next_idx < el.children.length
+          candidate = el.children[next_idx]
+          if candidate.type != :blank
+            next_child = candidate
+            break
+          end
+          next_idx += 1
+        end
+
+        convert_element(child, prev: prev_child, next_el: next_child)
+      end
+    end
+  end
+
+  class CLI
+    include Commander::Methods
+
+    def self.run!
+      new.run!
+    end
+
+    def run!
+      program :name, 'Booksmith'
+      program :version, Booksmith::VERSION
+      program :description, 'A flexible book publishing tool'
+
+      default_command :help
+
+      command :init do |c|
+        c.syntax = 'booksmith init'
+        c.description = 'Initialize a new book project'
+        c.action do |_args, _options|
+          CLI.create_project_structure
+        end
+      end
+
+      command :build do |c|
+        c.syntax = 'booksmith build [options]'
+        c.description = 'Generate the book in PDF and/or EPUB format'
+        c.option '--no-cover', 'Skip cover page generation'
+        c.option '--epub', 'Generate EPUB format'
+        c.option '--pdf', 'Generate PDF format'
+        c.option '--format FORMAT', String, 'Specify format to build (pdf, epub, or all)'
+        c.action do |_args, options|
+          formats = CLI.determine_formats(options)
+          BookGenerator.new(options).generate if formats.include?(:pdf)
+          EpubGenerator.new(options).generate if formats.include?(:epub)
+        end
+      end
+
+      command :fonts do |c|
+        c.syntax = 'booksmith fonts'
+        c.description = 'List registered Prawn font families'
+        c.action do |_args, _options|
+          CLI.list_fonts
+        end
+      end
+
+      super
+    end
+
+    def self.create_project_structure
+      dirs = %w[assets chapters config]
+      dirs.each { |dir| FileUtils.mkdir_p(dir) }
+
+      templates_dir = File.expand_path('templates', __dir__)
+
+      config_template = File.join(templates_dir, 'book.yml')
+      chapter_template = File.join(templates_dir, '01_introduction.md')
+      clock_template = File.join(templates_dir, 'clock.png')
+
+      FileUtils.cp(config_template, 'config/book.yml') if File.exist?(config_template)
+      FileUtils.cp(chapter_template, 'chapters/01_introduction.md') if File.exist?(chapter_template)
+      FileUtils.cp(clock_template, 'assets/clock.png') if File.exist?(clock_template)
+
+      puts '✅ Book project initialized!'
+      puts '📁 Created assets/, chapters/, and config/ directories'
+      puts '📝 Generated config/book.yml'
+      puts '📚 Generated sample chapter chapters/01_introduction.md'
+      puts '🖼️  Added default exercise icon assets/clock.png'
+      puts ''
+      puts 'Next steps:'
+      puts '  booksmith build           # generates book.pdf'
+      puts '  booksmith build --epub    # generates book.epub'
+      puts '  booksmith build --format all'
+    end
+
+    def self.determine_formats(options)
+      if options.format
+        case options.format.to_s.downcase
+        when 'all', 'both'
+          [:pdf, :epub]
+        when 'epub'
+          [:epub]
+        when 'pdf'
+          [:pdf]
+        else
+          raise ArgumentError, "Unknown format: #{options.format}. Supported formats are: pdf, epub, all"
+        end
+      elsif options.epub && options.pdf
+        [:pdf, :epub]
+      elsif options.epub
+        [:epub]
+      elsif options.pdf
+        [:pdf]
+      else
+        [:pdf]
+      end
+    end
+
+    def self.list_fonts
+      pdf = Prawn::Document.new
+      FontPaths.register(pdf)
+      puts 'Registered Prawn font families:'
+      pdf.font_families.keys.sort.each { |name| puts "- #{name}" }
+    end
+  end
+end

data/lib/templates/01_introduction.md

@@ -0,0 +1,58 @@
+# CHAPTER I
+<!-- subtitle: GETTING STARTED WITH BOOKSMITH -->
+
+Welcome to your new book! This is a sample chapter generated by **Booksmith**.
+
+Booksmith converts Markdown chapters into beautifully formatted PDF and EPUB publications using Prawn, GEPUB, and Kramdown.
+
+## Features Overview
+
+Booksmith provides a rich set of layout and typography enhancements:
+
+- **Configurable typography**: Fonts, sizes, and leading customizable via `config/book.yml`
+- **Subtitle comments**: Add subtitles right under chapter titles without breaking Markdown linters
+- **Specialized callouts**: Standard, alternate, and exercise blockquotes
+- **Smart page breaks**: Invisible page break markers for precise print layout
+
+<!-- PAGE_BREAK -->
+
+## Markdown Examples
+
+### Lists and Code Blocks
+
+You can write nested bullet lists and numbered lists:
+
+1. First step in setting up your book:
+   - Edit `config/book.yml` to set your book title and author
+   - Place chapter Markdown files in the `chapters/` folder
+2. Run `booksmith build` to generate `book.pdf`
+3. Run `booksmith build --epub` to generate `book.epub`
+
+Here is an example code block:
+
+```ruby
+def publish_book
+  puts "Building your masterpiece with Booksmith..."
+end
+```
+
+### Callouts and Blockquotes
+
+Booksmith supports three distinct blockquote styles.
+
+> **Standard Callout**
+>
+> When the first line is wrapped in bold text, Booksmith renders it as a distinct header row inside the shaded callout box.
+
+> **Alternate Callout**
+>
+> Use `{: .alt_blockquote}` for secondary notes, sidebars, or slightly different background tinting.
+{: .alt_blockquote}
+
+> Try It Yourself
+>
+> Exercise callouts feature an icon (configured in `config/book.yml`) and are styled for hands-on activities:
+>
+> - What is the main thesis of your book?
+> - Who is the intended reader?
+{: .exercise_blockquote}