silk_layout 0.1.0 → 0.2.0

data/lib/silk_layout/render/pdf_renderer.rb

@@ -8,14 +8,20 @@ module SilkLayout
       CSS_DPI = 96.0
       PDF_DPI = 72.0
 
-      PAGE_WIDTH_PX = 800
-      PAGE_HEIGHT_PX = 1000
+      DEFAULT_PAGE_WIDTH = 800
+      DEFAULT_PAGE_HEIGHT = 1000
 
-      def self.render(box_tree, output_path)
+      def self.render(box_tree, output_path, page_size: nil, page_width: nil, page_height: nil)
         doc = HexaPDF::Document.new
 
-        page_width_pt = px_to_pt(PAGE_WIDTH_PX)
-        page_height_pt = px_to_pt(PAGE_HEIGHT_PX)
+        resolved_page_width, resolved_page_height = page_dimensions(
+          page_size: page_size,
+          page_width: page_width,
+          page_height: page_height
+        )
+
+        page_width_pt = px_to_pt(resolved_page_width)
+        page_height_pt = px_to_pt(resolved_page_height)
 
         page = doc.pages.add([0, 0, page_width_pt, page_height_pt])
         Painter.paint(page.canvas, box_tree, page_height_pt)
@@ -26,6 +32,34 @@ module SilkLayout
       def self.px_to_pt(px)
         px * PDF_DPI / CSS_DPI
       end
+
+      def self.page_dimensions(page_size:, page_width:, page_height:)
+        width, height = page_size ? normalize_page_size(page_size) : [DEFAULT_PAGE_WIDTH, DEFAULT_PAGE_HEIGHT]
+
+        [
+          validate_dimension(page_width || width || DEFAULT_PAGE_WIDTH, "page_width"),
+          validate_dimension(page_height || height || DEFAULT_PAGE_HEIGHT, "page_height")
+        ]
+      end
+
+      def self.normalize_page_size(page_size)
+        case page_size
+        when Array
+          raise ArgumentError, "page_size must contain width and height" unless page_size.length == 2
+
+          page_size
+        when Hash
+          [page_size[:width] || page_size["width"], page_size[:height] || page_size["height"]]
+        else
+          raise ArgumentError, "page_size must be an Array or Hash"
+        end
+      end
+
+      def self.validate_dimension(value, name)
+        return value if value.is_a?(Numeric) && value.positive?
+
+        raise ArgumentError, "#{name} must be a positive number of CSS pixels"
+      end
     end
   end
 end

data/lib/silk_layout/resource/image.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module SilkLayout
+  module Resource
+    class Image
+      PNG_SIGNATURE = "\x89PNG\r\n\x1A\n".b
+      JPEG_START_OF_FRAME_MARKERS = [
+        0xC0,
+        0xC1,
+        0xC2,
+        0xC3,
+        0xC5,
+        0xC6,
+        0xC7,
+        0xC9,
+        0xCA,
+        0xCB,
+        0xCD,
+        0xCE,
+        0xCF
+      ].freeze
+
+      attr_reader :uri, :path, :width, :height
+
+      def self.load(source)
+        uri = normalize_uri(source)
+        return nil unless uri
+        return nil unless uri.scheme.nil? || uri.scheme == "file"
+
+        path = (uri.scheme == "file") ? uri_unescape(uri.path) : uri.to_s
+        return nil unless File.file?(path)
+
+        dimensions = read_dimensions(path)
+        return nil unless dimensions
+
+        new(uri: uri, path: path, width: dimensions[0], height: dimensions[1])
+      rescue URI::InvalidURIError, SystemCallError
+        nil
+      end
+
+      def initialize(uri:, path:, width:, height:)
+        @uri = uri
+        @path = path
+        @width = width
+        @height = height
+      end
+
+      def aspect_ratio
+        return nil unless width&.positive? && height&.positive?
+
+        width.to_f / height
+      end
+
+      def self.normalize_uri(source)
+        return source if source.is_a?(URI)
+
+        raw = source.to_s.strip
+        return nil if raw.empty?
+
+        URI.parse(raw)
+      end
+
+      def self.read_dimensions(path)
+        png_dimensions(path) || jpeg_dimensions(path)
+      end
+
+      def self.png_dimensions(path)
+        File.open(path, "rb") do |file|
+          header = file.read(24)
+          return nil unless header&.bytesize == 24
+          return nil unless header.start_with?(PNG_SIGNATURE)
+          return nil unless header.byteslice(12, 4) == "IHDR"
+
+          [
+            header.byteslice(16, 4).unpack1("N"),
+            header.byteslice(20, 4).unpack1("N")
+          ]
+        end
+      end
+
+      def self.jpeg_dimensions(path)
+        File.open(path, "rb") do |file|
+          return nil unless file.read(2)&.bytes == [0xFF, 0xD8]
+
+          loop do
+            marker = next_jpeg_marker(file)
+            return nil unless marker
+            return nil if marker == 0xD9 || marker == 0xDA
+            next if standalone_jpeg_marker?(marker)
+
+            length = read_uint16(file)
+            return nil unless length && length >= 2
+
+            if JPEG_START_OF_FRAME_MARKERS.include?(marker)
+              frame = file.read(5)
+              return nil unless frame&.bytesize == 5
+
+              return [
+                frame.byteslice(3, 2).unpack1("n"),
+                frame.byteslice(1, 2).unpack1("n")
+              ]
+            end
+
+            file.seek(length - 2, IO::SEEK_CUR)
+          end
+        end
+      end
+
+      def self.next_jpeg_marker(file)
+        loop do
+          byte = file.read(1)
+          return nil unless byte
+          next unless byte.ord == 0xFF
+
+          loop do
+            marker = file.read(1)
+            return nil unless marker
+            next if marker.ord == 0xFF
+
+            return marker.ord unless marker.ord == 0x00
+          end
+        end
+      end
+
+      def self.standalone_jpeg_marker?(marker)
+        marker == 0x01 || (0xD0..0xD8).cover?(marker)
+      end
+
+      def self.read_uint16(file)
+        bytes = file.read(2)
+        return nil unless bytes&.bytesize == 2
+
+        bytes.unpack1("n")
+      end
+
+      def self.uri_unescape(value)
+        URI::RFC2396_PARSER.unescape(value.to_s)
+      end
+
+      private_class_method :normalize_uri,
+        :png_dimensions,
+        :jpeg_dimensions,
+        :next_jpeg_marker,
+        :standalone_jpeg_marker?,
+        :read_uint16,
+        :uri_unescape
+    end
+  end
+end

data/lib/silk_layout/version.rb

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

data/lib/silk_layout.rb

@@ -10,6 +10,10 @@ module SilkLayout
     autoload :Node, "silk_layout/html/node"
   end
 
+  module Resource
+    autoload :Image, "silk_layout/resource/image"
+  end
+
   module CSS
     autoload :Parser, "silk_layout/css/parser"
     autoload :Cascade, "silk_layout/css/cascade"
@@ -18,6 +22,9 @@ module SilkLayout
     autoload :Declaration, "silk_layout/css/rule"
     autoload :Selector, "silk_layout/css/selector"
     autoload :Properties, "silk_layout/css/properties"
+    autoload :Values, "silk_layout/css/values"
+    autoload :Color, "silk_layout/css/color"
+    autoload :PageRule, "silk_layout/css/page_rule"
   end
 
   module Layout
@@ -45,11 +52,54 @@ module SilkLayout
     autoload :PdfRenderer, "silk_layout/render/pdf_renderer"
   end
 
-  def self.render_document(html_document, out, url: nil)
+  def self.render_document(
+    html_document,
+    out,
+    url: nil,
+    viewport_width: nil,
+    page_size: nil,
+    page_width: nil,
+    page_height: 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)
+    stylesheet = SilkLayout::CSS::Parser.parse_stylesheets(stylesheets, media: :print)
+    css_page_size = SilkLayout::CSS::PageRule.resolve_page_size(stylesheet.page_rules)
+    resolved_page_size = resolve_page_size(page_size || css_page_size, page_width, page_height)
+
+    box_tree = SilkLayout::Layout::Engine.layout(
+      dom,
+      stylesheet.rules,
+      viewport_width: viewport_width,
+      page_size: resolved_page_size
+    )
+
+    SilkLayout::Render::PdfRenderer.render(
+      box_tree,
+      out,
+      page_size: resolved_page_size
+    )
+  end
+
+  def self.resolve_page_size(page_size, page_width, page_height)
+    return page_size unless page_width || page_height
+
+    width, height = page_size_dimensions(page_size)
+    {
+      width: page_width || width,
+      height: page_height || height
+    }
+  end
+  private_class_method :resolve_page_size
 
-    SilkLayout::Render::PdfRenderer.render(box_tree, out)
+  def self.page_size_dimensions(page_size)
+    case page_size
+    when Array
+      page_size
+    when Hash
+      [page_size[:width] || page_size["width"], page_size[:height] || page_size["height"]]
+    else
+      [nil, nil]
+    end
   end
+  private_class_method :page_size_dimensions
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: silk_layout
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Reegan Viljoen
@@ -202,11 +202,14 @@ files:
 - README.md
 - lib/silk_layout.rb
 - lib/silk_layout/css/cascade.rb
+- lib/silk_layout/css/color.rb
 - lib/silk_layout/css/computed_style.rb
+- lib/silk_layout/css/page_rule.rb
 - lib/silk_layout/css/parser.rb
 - lib/silk_layout/css/properties.rb
 - lib/silk_layout/css/rule.rb
 - lib/silk_layout/css/selector.rb
+- lib/silk_layout/css/values.rb
 - lib/silk_layout/html/node.rb
 - lib/silk_layout/html/parser.rb
 - lib/silk_layout/layout/block_layout.rb
@@ -222,6 +225,7 @@ files:
 - lib/silk_layout/render/font_library.rb
 - lib/silk_layout/render/painter.rb
 - lib/silk_layout/render/pdf_renderer.rb
+- lib/silk_layout/resource/image.rb
 - lib/silk_layout/version.rb
 homepage: https://github.com/reeganviljoen/silk_layout
 licenses: