silk_layout 0.1.0

data/lib/silk_layout/render/font_library.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "hexapdf"
+
+module SilkLayout
+  module Render
+    class FontLibrary
+      BASE_FONTS = {
+        helvetica: {
+          normal: {
+            normal: "Helvetica",
+            italic: "Helvetica-Oblique"
+          },
+          bold: {
+            normal: "Helvetica-Bold",
+            italic: "Helvetica-BoldOblique"
+          }
+        },
+        times: {
+          normal: {
+            normal: "Times-Roman",
+            italic: "Times-Italic"
+          },
+          bold: {
+            normal: "Times-Bold",
+            italic: "Times-BoldItalic"
+          }
+        },
+        courier: {
+          normal: {
+            normal: "Courier",
+            italic: "Courier-Oblique"
+          },
+          bold: {
+            normal: "Courier-Bold",
+            italic: "Courier-BoldOblique"
+          }
+        }
+      }.freeze
+
+      FAMILY_ALIASES = {
+        "arial" => :helvetica,
+        "helvetica" => :helvetica,
+        "sans-serif" => :helvetica,
+        "sans serif" => :helvetica,
+        "times" => :times,
+        "times new roman" => :times,
+        "serif" => :times,
+        "courier" => :courier,
+        "courier new" => :courier,
+        "monospace" => :courier
+      }.freeze
+
+      class << self
+        def metrics(font_family, font_weight: "normal", font_style: "normal")
+          font_name = resolve_font_name(font_family, font_weight: font_weight, font_style: font_style)
+          font = font_wrapper(font_name)
+
+          {
+            font_name: font_name,
+            font: font,
+            ascender: normalized_metric(font, :ascender),
+            descender: normalized_metric(font, :descender)
+          }
+        end
+
+        def measure_text(text, font_size:, font_family:, font_weight: "normal", font_style: "normal")
+          return 0 if text.to_s.empty?
+
+          font = metrics(font_family, font_weight: font_weight, font_style: font_style)[:font]
+          glyph_width = font.decode_utf8(text.to_s).sum(&:width)
+          glyph_width * font_size / 1000.0
+        end
+
+        def resolve_font_name(font_family, font_weight: "normal", font_style: "normal")
+          family = normalized_family(font_family)
+          weight = bold?(font_weight) ? :bold : :normal
+          style = italic?(font_style) ? :italic : :normal
+
+          BASE_FONTS.fetch(family, BASE_FONTS[:helvetica]).fetch(weight).fetch(style)
+        end
+
+        private
+
+        def font_wrapper(font_name)
+          @document ||= HexaPDF::Document.new
+          @fonts ||= {}
+          @fonts[font_name] ||= @document.fonts.add(font_name)
+        end
+
+        def normalized_metric(font, metric_name)
+          wrapped_font = font.instance_variable_get(:@wrapped_font)
+          return 0 unless wrapped_font
+
+          wrapped_font.public_send(metric_name).to_f * font.scaling_factor
+        end
+
+        def normalized_family(font_family)
+          candidates(font_family).each do |candidate|
+            mapped = FAMILY_ALIASES[candidate]
+            return mapped if mapped
+          end
+
+          :helvetica
+        end
+
+        def candidates(font_family)
+          font_family.to_s.split(",").map do |family|
+            family.to_s.strip.delete_prefix('"').delete_suffix('"').delete_prefix("'").delete_suffix("'").downcase
+          end.reject(&:empty?)
+        end
+
+        def bold?(font_weight)
+          weight = font_weight.to_s.strip.downcase
+          return true if weight == "bold"
+          return false if weight.empty? || weight == "normal"
+
+          weight.to_i >= 600
+        end
+
+        def italic?(font_style)
+          %w[italic oblique].include?(font_style.to_s.strip.downcase)
+        end
+      end
+    end
+  end
+end

data/lib/silk_layout/render/painter.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+module SilkLayout
+  module Render
+    class Painter
+      def self.paint(canvas, box, page_height_pt)
+        paint_box(canvas, box, page_height_pt)
+      end
+
+      def self.paint_box(canvas, box, page_height_pt)
+        draw_background(canvas, box, page_height_pt)
+        draw_borders(canvas, box, page_height_pt)
+
+        if box.is_a?(SilkLayout::Layout::TextBox)
+          paint_text(canvas, box, page_height_pt)
+        end
+
+        box.children.each do |child|
+          paint_box(canvas, child, page_height_pt)
+        end
+      end
+
+      def self.paint_text(canvas, box, page_height_pt)
+        font_size_px = box.font_size || 16
+        font_name = box.font_name || box.font_family || "Helvetica"
+
+        font_size_pt = PdfRenderer.px_to_pt(font_size_px)
+        ascent_pt = PdfRenderer.px_to_pt(box.respond_to?(:ascender) ? box.ascender : font_size_px * 0.8)
+
+        canvas.font(font_name, size: font_size_pt)
+
+        canvas = set_color(canvas, color_to_symbol(box.respond_to?(:color) ? box.color : nil) || :black)
+
+        x_pt = PdfRenderer.px_to_pt(box.x)
+        y_pt = page_height_pt - PdfRenderer.px_to_pt(box.y) - ascent_pt
+
+        canvas.text(box.text, at: [x_pt, y_pt])
+      end
+
+      def self.draw_background(canvas, box, page_height_pt)
+        return if box.is_a?(SilkLayout::Layout::AnonymousBlockBox)
+        return unless box.respond_to?(:background_color) && box.background_color
+
+        rgb = rgb_color(box.background_color)
+        return unless rgb
+
+        x = PdfRenderer.px_to_pt(box.border_box_x)
+        y = page_height_pt - PdfRenderer.px_to_pt(box.border_box_y + box.border_box_height)
+        w = PdfRenderer.px_to_pt(box.border_box_width)
+        h = PdfRenderer.px_to_pt(box.border_box_height)
+
+        canvas.fill_color(*rgb)
+        canvas.rectangle(x, y, w, h).fill
+      end
+
+      def self.draw_borders(canvas, box, page_height_pt)
+        return if box.is_a?(SilkLayout::Layout::AnonymousBlockBox)
+        return unless box.has_border
+
+        x = PdfRenderer.px_to_pt(box.border_box_x)
+        y = page_height_pt - PdfRenderer.px_to_pt(box.border_box_y + box.border_box_height)
+        w = PdfRenderer.px_to_pt(box.border_box_width)
+        h = PdfRenderer.px_to_pt(box.border_box_height)
+
+        top = PdfRenderer.px_to_pt(box.border[:top])
+        bottom = PdfRenderer.px_to_pt(box.border[:bottom])
+        left = PdfRenderer.px_to_pt(box.border[:left])
+        right = PdfRenderer.px_to_pt(box.border[:right])
+
+        colors = [box.border_color[:top], box.border_color[:right], box.border_color[:bottom], box.border_color[:left]]
+        if colors.uniq.length <= 1
+          if top > 0
+            canvas = set_color(canvas, box.border_color[:top])
+            canvas.rectangle(x, y + h - top, w, top).fill
+          end
+
+          if bottom > 0
+            canvas = set_color(canvas, box.border_color[:bottom])
+            canvas.rectangle(x, y, w, bottom).fill
+          end
+
+          if left > 0
+            canvas = set_color(canvas, box.border_color[:left])
+            canvas.rectangle(x, y, left, h).fill
+          end
+
+          if right > 0
+            canvas = set_color(canvas, box.border_color[:right])
+            canvas.rectangle(x + w - right, y, right, h).fill
+          end
+
+          return
+        end
+
+        inner_w = [w - left - right, 0].max
+        inner_h = [h - top - bottom, 0].max
+
+        if top > 0 && inner_w > 0
+          canvas = set_color(canvas, box.border_color[:top])
+          canvas.rectangle(x + left, y + h - top, inner_w, top).fill
+        end
+
+        if bottom > 0 && inner_w > 0
+          canvas = set_color(canvas, box.border_color[:bottom])
+          canvas.rectangle(x + left, y, inner_w, bottom).fill
+        end
+
+        if left > 0 && inner_h > 0
+          canvas = set_color(canvas, box.border_color[:left])
+          canvas.rectangle(x, y + bottom, left, inner_h).fill
+        end
+
+        if right > 0 && inner_h > 0
+          canvas = set_color(canvas, box.border_color[:right])
+          canvas.rectangle(x + w - right, y + bottom, right, inner_h).fill
+        end
+
+        draw_corner(
+          canvas,
+          x,
+          y + h - top,
+          left,
+          top,
+          box.border_color[:left],
+          box.border_color[:top],
+          :top_left
+        )
+
+        draw_corner(
+          canvas,
+          x + w - right,
+          y + h - top,
+          right,
+          top,
+          box.border_color[:right],
+          box.border_color[:top],
+          :top_right
+        )
+
+        draw_corner(
+          canvas,
+          x,
+          y,
+          left,
+          bottom,
+          box.border_color[:left],
+          box.border_color[:bottom],
+          :bottom_left
+        )
+
+        draw_corner(
+          canvas,
+          x + w - right,
+          y,
+          right,
+          bottom,
+          box.border_color[:right],
+          box.border_color[:bottom],
+          :bottom_right
+        )
+      end
+
+      def self.set_color(canvas, color)
+        return canvas unless color
+
+        rgb = rgb_color(color)
+        if rgb
+          canvas.fill_color(*rgb)
+        else
+          canvas.fill_color(0, 0, 0)
+        end
+
+        canvas
+      end
+
+      def self.color_to_symbol(color)
+        return nil unless color
+
+        normalized = color.to_s.strip
+        return nil if normalized.empty?
+
+        normalized.to_sym
+      end
+
+      def self.rgb_color(color)
+        normalized = color.to_s.strip.downcase
+        return nil if normalized.empty? || normalized == "transparent"
+
+        return hex_color(normalized) if normalized.start_with?("#")
+
+        NAMED_COLORS[normalized.to_sym]
+      end
+
+      def self.hex_color(color)
+        hex = color.delete_prefix("#")
+        hex = hex.chars.flat_map { |char| [char, char] }.join if hex.length == 3
+        return nil unless hex.match?(/\A[0-9a-f]{6}\z/)
+
+        hex.scan(/../).map { |component| component.to_i(16) }
+      end
+
+      def self.draw_corner(canvas, x, y, w, h, vertical_color, horizontal_color, kind)
+        return if w <= 0 || h <= 0
+
+        if vertical_color == horizontal_color
+          canvas = set_color(canvas, vertical_color)
+          canvas.rectangle(x, y, w, h).fill
+          return
+        end
+
+        case kind
+        when :top_left
+          fill_triangle(canvas, horizontal_color, [x, y + h], [x + w, y + h], [x + w, y])
+          fill_triangle(canvas, vertical_color, [x, y + h], [x + w, y], [x, y])
+        when :top_right
+          fill_triangle(canvas, horizontal_color, [x, y + h], [x + w, y + h], [x, y])
+          fill_triangle(canvas, vertical_color, [x + w, y + h], [x + w, y], [x, y])
+        when :bottom_left
+          fill_triangle(canvas, horizontal_color, [x, y], [x + w, y], [x + w, y + h])
+          fill_triangle(canvas, vertical_color, [x, y], [x + w, y + h], [x, y + h])
+        when :bottom_right
+          fill_triangle(canvas, horizontal_color, [x, y], [x + w, y], [x, y + h])
+          fill_triangle(canvas, vertical_color, [x + w, y], [x + w, y + h], [x, y + h])
+        end
+      end
+
+      def self.fill_triangle(canvas, color, p1, p2, p3)
+        canvas = set_color(canvas, color)
+        canvas.move_to(*p1)
+        canvas.line_to(*p2)
+        canvas.line_to(*p3)
+        canvas.close_subpath.fill
+      end
+
+      private_class_method :paint_box
+
+      NAMED_COLORS = {
+        black: [0, 0, 0],
+        blue: [0, 0, 255],
+        green: [0, 128, 0],
+        lightblue: [173, 216, 230],
+        red: [255, 0, 0],
+        white: [255, 255, 255]
+      }.freeze
+    end
+  end
+end

data/lib/silk_layout/render/pdf_renderer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "hexapdf"
+
+module SilkLayout
+  module Render
+    class PdfRenderer
+      CSS_DPI = 96.0
+      PDF_DPI = 72.0
+
+      PAGE_WIDTH_PX = 800
+      PAGE_HEIGHT_PX = 1000
+
+      def self.render(box_tree, output_path)
+        doc = HexaPDF::Document.new
+
+        page_width_pt = px_to_pt(PAGE_WIDTH_PX)
+        page_height_pt = px_to_pt(PAGE_HEIGHT_PX)
+
+        page = doc.pages.add([0, 0, page_width_pt, page_height_pt])
+        Painter.paint(page.canvas, box_tree, page_height_pt)
+
+        doc.write(output_path)
+      end
+
+      def self.px_to_pt(px)
+        px * PDF_DPI / CSS_DPI
+      end
+    end
+  end
+end

data/lib/silk_layout/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SilkLayout
+  VERSION = "0.1.0"
+end

data/lib/silk_layout.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "active_support/all"
+
+module SilkLayout
+  autoload :VERSION, "silk_layout/version"
+
+  module HTML
+    autoload :Parser, "silk_layout/html/parser"
+    autoload :Node, "silk_layout/html/node"
+  end
+
+  module CSS
+    autoload :Parser, "silk_layout/css/parser"
+    autoload :Cascade, "silk_layout/css/cascade"
+    autoload :ComputedStyle, "silk_layout/css/computed_style"
+    autoload :Rule, "silk_layout/css/rule"
+    autoload :Declaration, "silk_layout/css/rule"
+    autoload :Selector, "silk_layout/css/selector"
+    autoload :Properties, "silk_layout/css/properties"
+  end
+
+  module Layout
+    autoload :Box, "silk_layout/layout/box"
+    autoload :BlockBox, "silk_layout/layout/box"
+    autoload :FlexBox, "silk_layout/layout/box"
+    autoload :InlineBox, "silk_layout/layout/box"
+    autoload :AnonymousBlockBox, "silk_layout/layout/box"
+    autoload :Inline, "silk_layout/layout/inline"
+    autoload :TextBox, "silk_layout/layout/inline"
+    autoload :LineBox, "silk_layout/layout/inline"
+    autoload :InlineFormatter, "silk_layout/layout/inline_formatter"
+    autoload :FormattingBuilder, "silk_layout/layout/formatting_builder"
+    autoload :BoxBuilder, "silk_layout/layout/box_builder"
+    autoload :Context, "silk_layout/layout/context"
+    autoload :BlockLayout, "silk_layout/layout/block_layout"
+    autoload :FlexLayout, "silk_layout/layout/flex_layout"
+    autoload :Engine, "silk_layout/layout/engine"
+    autoload :Root, "silk_layout/layout/root"
+  end
+
+  module Render
+    autoload :FontLibrary, "silk_layout/render/font_library"
+    autoload :Painter, "silk_layout/render/painter"
+    autoload :PdfRenderer, "silk_layout/render/pdf_renderer"
+  end
+
+  def self.render_document(html_document, out, url: nil)
+    dom, stylesheets = SilkLayout::HTML::Parser.parse_document(html_document, url: url)
+    rules = SilkLayout::CSS::Parser.parse_all(stylesheets)
+    box_tree = SilkLayout::Layout::Engine.layout(dom, rules)
+
+    SilkLayout::Render::PdfRenderer.render(box_tree, out)
+  end
+end