silk_layout 0.1.0

data/lib/silk_layout/html/parser.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "nokogiri"
+require "uri"
+
+module SilkLayout
+  module HTML
+    class Parser
+      def self.parse_document(html, url: nil)
+        document = Nokogiri::HTML(html)
+
+        base_uri = base_uri_for(document, url)
+        stylesheets = extract_stylesheets!(document, base_uri)
+
+        [Node.from_nokogiri(document.root), stylesheets]
+      end
+
+      def self.extract_stylesheets!(document, base_uri)
+        stylesheets = []
+        cache = {}
+
+        document.css("style, link").each do |node|
+          if node.name == "style"
+            stylesheets << node.content.to_s
+            node.remove
+            next
+          end
+
+          next unless node.name == "link"
+
+          rel = node["rel"].to_s.downcase.split
+          next unless rel.include?("stylesheet")
+
+          href = node["href"].to_s.strip
+          next if href.empty?
+
+          stylesheets << fetch_stylesheet(href, base_uri, cache)
+          node.remove
+        end
+
+        stylesheets
+      end
+
+      def self.base_uri_for(document, url)
+        doc_uri = normalize_document_url(url)
+
+        base_href = document.at_css("base[href]")&.[]("href")
+        return doc_uri unless base_href
+
+        normalize_href(base_href.to_s, doc_uri)
+      end
+
+      def self.normalize_document_url(url)
+        return default_workdir_uri unless url
+
+        uri = URI.parse(url.to_s)
+        return uri if uri.scheme
+
+        path = Pathname.new(url.to_s).expand_path
+        file_uri_for(path)
+      rescue URI::InvalidURIError
+        path = Pathname.new(url.to_s).expand_path
+        file_uri_for(path)
+      end
+
+      def self.default_workdir_uri
+        file_uri_for(Pathname.pwd)
+      end
+
+      def self.file_uri_for(path)
+        p = path
+        p = p.dirname if p.file?
+
+        dir = p.to_s
+        dir = "#{dir}/" unless dir.end_with?("/")
+
+        URI::Generic.build(scheme: "file", path: dir)
+      end
+
+      def self.fetch_stylesheet(href, base_uri, cache)
+        resolved = normalize_href(href, base_uri)
+        key = resolved.to_s
+        return cache[key] if cache.key?(key)
+
+        css =
+          case resolved.scheme
+          when "file", nil
+            path = uri_unescape(resolved.path)
+            raise "Stylesheet not found: #{path}" unless File.exist?(path)
+
+            File.read(path)
+          when "http", "https"
+            fetch_http(resolved)
+          else
+            raise "Unsupported stylesheet scheme: #{resolved.scheme} (#{resolved})"
+          end
+
+        css = inline_css_imports(css, resolved, cache)
+        cache[key] = css
+      end
+
+      def self.normalize_href(href, base_uri)
+        href = href.to_s
+        uri = URI.parse(href)
+        return uri if uri.scheme
+
+        URI.join(base_uri.to_s, href)
+      rescue URI::InvalidURIError
+        URI.join(base_uri.to_s, URI::DEFAULT_PARSER.escape(href))
+      end
+
+      def self.fetch_http(uri)
+        current = uri
+        redirects = 0
+
+        loop do
+          http = Net::HTTP.new(current.host, current.port)
+          http.use_ssl = (current.scheme == "https")
+          http.open_timeout = 10
+          http.read_timeout = 10
+
+          request = Net::HTTP::Get.new(current)
+          request["User-Agent"] = "SilkLayout/#{SilkLayout::VERSION}"
+
+          response = http.request(request)
+
+          case response
+          when Net::HTTPSuccess
+            return response.body.to_s
+          when Net::HTTPRedirection
+            location = response["location"].to_s
+            raise "Missing redirect location for #{current}" if location.empty?
+
+            redirects += 1
+            raise "Too many redirects fetching #{uri}" if redirects > 5
+
+            current = URI.join(current.to_s, location)
+          else
+            raise "Failed to fetch #{current} (HTTP #{response.code})"
+          end
+        end
+      end
+
+      def self.inline_css_imports(css, stylesheet_uri, cache)
+        return css unless css.include?("@import")
+
+        base = stylesheet_base_uri(stylesheet_uri)
+        remaining = css.dup
+        inlined = +""
+        seen = {}
+
+        20.times do
+          m = remaining.match(/@import\s+(?:url\()?
+            \s*['"]?([^'")\s;]+)['"]?
+            \s*\)?\s*;/ix)
+          break unless m
+
+          href = m[1]
+          break if seen[href]
+
+          seen[href] = true
+          import_uri = normalize_href(href, base)
+          imported = fetch_stylesheet(import_uri.to_s, base, cache)
+
+          inlined << imported.to_s << "\n"
+          remaining.sub!(m[0], "")
+        end
+
+        (inlined + remaining)
+      end
+
+      def self.stylesheet_base_uri(stylesheet_uri)
+        if stylesheet_uri.scheme == "file"
+          file_uri_for(Pathname.new(uri_unescape(stylesheet_uri.path)))
+        else
+          uri = stylesheet_uri.dup
+          uri.path = uri.path.to_s.sub(/[^\/]+\z/, "")
+          uri
+        end
+      end
+
+      def self.uri_unescape(value)
+        URI::RFC2396_PARSER.unescape(value.to_s)
+      end
+    end
+  end
+end

data/lib/silk_layout/layout/block_layout.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module SilkLayout
+  module Layout
+    class BlockLayout
+      def self.layout(box, context, cursor_y = 0, parent_x = 0, containing_width = nil)
+        return FlexLayout.layout(box, context, cursor_y, parent_x, containing_width) if box.is_a?(FlexBox)
+
+        box.x = parent_x + box.margin[:left]
+        box.y = cursor_y + box.margin[:top]
+
+        content_x =
+          box.x + box.border[:left] + box.padding[:left]
+
+        content_y =
+          box.y + box.border[:top] + box.padding[:top]
+
+        available_width = containing_width || context.width
+        if box.explicit_width
+          content_width = box.width
+        else
+          content_width =
+            available_width -
+            box.margin[:left] - box.margin[:right] -
+            box.border[:left] - box.border[:right] -
+            box.padding[:left] - box.padding[:right]
+          content_width = 0 if content_width < 0
+        end
+
+        current_y = content_y
+        new_children = []
+        inline_buffer = []
+
+        box.children.each do |child|
+          if child.is_a?(InlineBox)
+            inline_buffer << child
+            next
+          end
+
+          if inline_buffer.any?
+            lines = InlineFormatter.layout(inline_buffer, content_width, content_x, current_y)
+            lines.each do |line|
+              line.x = content_x
+              line.y = current_y
+              current_y += line.height
+              new_children << line
+            end
+            inline_buffer.clear
+          end
+
+          layout(child, context, current_y, content_x, content_width)
+
+          current_y +=
+            child.height +
+            child.margin[:top] +
+            child.margin[:bottom]
+
+          new_children << child
+        end
+
+        if inline_buffer.any?
+          lines = InlineFormatter.layout(inline_buffer, content_width, content_x, current_y)
+          lines.each do |line|
+            line.x = content_x
+            line.y = current_y
+            current_y += line.height
+            new_children << line
+          end
+        end
+
+        box.children = new_children
+
+        content_height = current_y - content_y
+        content_height = [content_height, box.height].max if box.explicit_height
+
+        max_child_width =
+          box.children.map(&:width).max || 0
+
+        content_width = max_child_width if !box.explicit_width && content_width == 0
+
+        box.width =
+          content_width +
+          box.padding[:left] + box.padding[:right] +
+          box.border[:left] + box.border[:right]
+
+        box.height =
+          content_height +
+          box.padding[:top] + box.padding[:bottom] +
+          box.border[:top] + box.border[:bottom]
+      end
+    end
+  end
+end

data/lib/silk_layout/layout/box.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module SilkLayout
+  module Layout
+    class Box
+      attr_accessor :x,
+        :y,
+        :width,
+        :height,
+        :children,
+        :node,
+        :margin,
+        :padding,
+        :border,
+        :border_color,
+        :background_color,
+        :explicit_width,
+        :explicit_height,
+        :flex,
+        :display,
+        :has_border
+
+      def initialize(node)
+        @node = node
+        @children = []
+
+        @x = 0
+        @y = 0
+        @width = 0
+        @height = 0
+
+        @margin = {top: 0, right: 0, bottom: 0, left: 0}
+        @padding = {top: 0, right: 0, bottom: 0, left: 0}
+        @border = {top: 0, right: 0, bottom: 0, left: 0}
+        @border_color = {
+          top: nil,
+          right: nil,
+          bottom: nil,
+          left: nil
+        }
+        @background_color = nil
+
+        @explicit_width = false
+        @explicit_height = false
+        @flex = {}
+        @display = nil
+      end
+
+      def add_child(box)
+        @children << box
+      end
+
+      def border_box_x
+        x
+      end
+
+      def border_box_y
+        y
+      end
+
+      def border_box_width
+        width
+      end
+
+      def border_box_height
+        height
+      end
+    end
+
+    class BlockBox < Box; end
+    class FlexBox < BlockBox; end
+    class InlineBox < Box; end
+
+    class AnonymousBlockBox < Box
+      def initialize
+        super(nil)
+      end
+    end
+  end
+end

data/lib/silk_layout/layout/box_builder.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SilkLayout
+  module Layout
+    class BoxBuilder
+      def self.build(dom_root)
+        FormattingBuilder.build(dom_root)
+      end
+    end
+  end
+end

data/lib/silk_layout/layout/context.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SilkLayout
+  module Layout
+    class Context
+      attr_reader :width
+
+      def initialize(width:)
+        @width = width
+      end
+    end
+  end
+end

data/lib/silk_layout/layout/engine.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SilkLayout
+  module Layout
+    class Engine
+      DEFAULT_VIEWPORT_WIDTH = 800
+
+      def self.layout(dom, css_rules, viewport_width: DEFAULT_VIEWPORT_WIDTH)
+        CSS::Cascade.apply(dom, css_rules)
+
+        box_tree = FormattingBuilder.build(dom)
+
+        root = Root.find(box_tree)
+
+        context = Context.new(width: viewport_width)
+        BlockLayout.layout(root, context)
+
+        root
+      end
+    end
+  end
+end