silk_layout 0.1.0 → 0.2.0

data/lib/silk_layout/css/selector.rb

@@ -5,10 +5,13 @@ module SilkLayout
     class Selector
       def initialize(raw)
         @raw = raw.to_s.strip
-        @steps = parse_steps(@raw)
+        @valid = !@raw.empty?
+        @steps = @valid ? parse_steps(@raw) : []
+        @valid &&= @steps.any?
       end
 
       def match?(node)
+        return false unless @valid
         return false unless node.respond_to?(:element?)
         return false unless node.element?
         return false if node.tag.nil?
@@ -29,6 +32,10 @@ module SilkLayout
           when :descendant
             current = find_ancestor(current.parent, simple)
             return false unless current
+          when :adjacent
+            current = previous_element_sibling(current)
+            return false unless current
+            return false unless step_match?(simple, current)
           else
             return false
           end
@@ -45,10 +52,10 @@ module SilkLayout
         elements = 0
 
         @steps.each do |step|
-          simple = step[:simple]
-          ids += 1 if simple[:id]
-          classes += simple[:classes].length
-          elements += 1 if simple[:tag]
+          simple_ids, simple_classes, simple_elements = simple_specificity(step[:simple])
+          ids += simple_ids
+          classes += simple_classes
+          elements += simple_elements
         end
 
         [ids, classes, elements]
@@ -56,52 +63,103 @@ module SilkLayout
 
       private
 
+      IDENT = /[a-zA-Z][a-zA-Z0-9_-]*/
+      NAME = /[a-zA-Z0-9_-]+/
+
       def parse_steps(raw)
         tokens = tokenize(raw)
         parts = []
         pending_combinator = nil
+        expecting_simple = true
 
         tokens.each do |tok|
-          if tok == ">"
-            pending_combinator = :child
+          if tok == " "
+            pending_combinator ||= :descendant unless expecting_simple || parts.empty?
             next
           end
 
-          if tok == " "
-            pending_combinator ||= :descendant
+          if tok == ">" || tok == "+"
+            return invalid_steps if parts.empty? || expecting_simple
+
+            pending_combinator = (tok == ">") ? :child : :adjacent
+            expecting_simple = true
             next
           end
 
-          parts << {simple: parse_simple(tok), combinator: pending_combinator}
+          simple = parse_simple(tok)
+          return invalid_steps unless simple
+
+          parts << {
+            simple: simple,
+            combinator: parts.empty? ? nil : (pending_combinator || :descendant)
+          }
           pending_combinator = nil
+          expecting_simple = false
         end
 
-        # Default combinator between left/right parts is descendant.
-        # Combinator is stored on the RIGHT step to indicate how it relates to the LEFT.
-        parts.each_with_index do |part, idx|
-          next if idx == 0
-          part[:combinator] ||= :descendant
-        end
+        return invalid_steps if expecting_simple && parts.any?
 
         parts
       end
 
       def tokenize(raw)
-        raw = raw.strip
         tokens = []
         buf = +""
         in_space = false
+        quote = nil
+        bracket_depth = 0
+        paren_depth = 0
+
+        raw.strip.each_char do |ch|
+          if quote
+            buf << ch
+            quote = nil if ch == quote
+            next
+          end
 
-        raw.each_char do |ch|
-          if ch == ">"
+          if ch == '"' || ch == "'"
+            quote = ch
+            buf << ch
+            next
+          end
+
+          if ch == "["
+            bracket_depth += 1
+            buf << ch
+            next
+          end
+
+          if ch == "]"
+            bracket_depth -= 1
+            return invalid_steps if bracket_depth.negative?
+
+            buf << ch
+            next
+          end
+
+          if ch == "("
+            paren_depth += 1
+            buf << ch
+            next
+          end
+
+          if ch == ")"
+            paren_depth -= 1
+            return invalid_steps if paren_depth.negative?
+
+            buf << ch
+            next
+          end
+
+          if (ch == ">" || ch == "+") && bracket_depth.zero? && paren_depth.zero?
             tokens << buf unless buf.empty?
             buf = +""
-            tokens << ">"
+            tokens << ch
             in_space = false
             next
           end
 
-          if ch.match?(/\s/)
+          if ch.match?(/\s/) && bracket_depth.zero? && paren_depth.zero?
             tokens << buf unless buf.empty?
             buf = +""
             tokens << " " unless in_space
@@ -113,31 +171,85 @@ module SilkLayout
           buf << ch
         end
 
+        return invalid_steps if quote || !bracket_depth.zero? || !paren_depth.zero?
+
         tokens << buf unless buf.empty?
         tokens.reject(&:empty?)
       end
 
-      def parse_simple(token)
+      def parse_simple(token, allow_not: true)
         tag = nil
         id = nil
         classes = []
+        attributes = []
+        pseudo_classes = []
+        negations = []
+        universal = false
 
         rest = token.to_s
-        if rest.match?(/\A[a-zA-Z][a-zA-Z0-9_-]*/)
-          m = rest.match(/\A([a-zA-Z][a-zA-Z0-9_-]*)/)
-          tag = m[1]
+        if rest.start_with?("*")
+          universal = true
+          rest = rest[1..].to_s
+        elsif (m = rest.match(/\A(#{IDENT.source})/))
+          tag = m[1].downcase
           rest = rest[m[1].length..]
         end
 
-        rest.scan(/([#.])([a-zA-Z0-9_-]+)/) do |kind, value|
-          if kind == "#"
-            id = value
+        until rest.empty?
+          if (m = rest.match(/\A#(#{NAME.source})/))
+            id = m[1]
+            rest = rest[m[0].length..].to_s
+          elsif (m = rest.match(/\A\.(#{NAME.source})/))
+            classes << m[1]
+            rest = rest[m[0].length..].to_s
+          elsif rest.start_with?("[")
+            closing = closing_index(rest, "]")
+            return invalid_simple unless closing
+
+            attribute = parse_attribute(rest[1...closing])
+            return invalid_simple unless attribute
+
+            attributes << attribute
+            rest = rest[(closing + 1)..].to_s
+          elsif rest.start_with?(":first-child")
+            pseudo_classes << :first_child
+            rest = rest[12..].to_s
+          elsif rest.start_with?(":last-child")
+            pseudo_classes << :last_child
+            rest = rest[11..].to_s
+          elsif rest.start_with?(":not(")
+            return invalid_simple unless allow_not
+
+            closing = closing_index(rest, ")")
+            return invalid_simple unless closing
+
+            inner = rest[5...closing].to_s.strip
+            inner_tokens = tokenize(inner)
+            return invalid_simple unless @valid && inner_tokens.length == 1
+
+            negation = parse_simple(inner_tokens.first, allow_not: false)
+            return invalid_simple unless negation
+
+            negations << negation
+            rest = rest[(closing + 1)..].to_s
           else
-            classes << value
+            return invalid_simple
           end
         end
 
-        {tag: tag, id: id, classes: classes}
+        if tag.nil? && id.nil? && classes.empty? && attributes.empty? && pseudo_classes.empty? && negations.empty? && !universal
+          return invalid_simple
+        end
+
+        {
+          tag: tag,
+          id: id,
+          classes: classes,
+          attributes: attributes,
+          pseudo_classes: pseudo_classes,
+          negations: negations,
+          universal: universal
+        }
       end
 
       def step_match?(simple, node)
@@ -149,6 +261,26 @@ module SilkLayout
           return false unless simple[:classes].all? { |c| node_classes.include?(c) }
         end
 
+        simple[:attributes].each do |attribute|
+          return false unless node.attributes.key?(attribute[:name])
+          return false if attribute.key?(:value) && node.attributes[attribute[:name]] != attribute[:value]
+        end
+
+        simple[:pseudo_classes].each do |pseudo_class|
+          case pseudo_class
+          when :first_child
+            return false unless first_element_child?(node)
+          when :last_child
+            return false unless last_element_child?(node)
+          else
+            return false
+          end
+        end
+
+        simple[:negations].each do |negation|
+          return false if step_match?(negation, node)
+        end
+
         true
       end
 
@@ -160,6 +292,90 @@ module SilkLayout
         end
         nil
       end
+
+      def simple_specificity(simple)
+        ids = simple[:id] ? 1 : 0
+        classes = simple[:classes].length + simple[:attributes].length + simple[:pseudo_classes].length
+        elements = simple[:tag] ? 1 : 0
+
+        simple[:negations].each do |negation|
+          negation_ids, negation_classes, negation_elements = simple_specificity(negation)
+          ids += negation_ids
+          classes += negation_classes
+          elements += negation_elements
+        end
+
+        [ids, classes, elements]
+      end
+
+      def parse_attribute(raw)
+        m = raw.to_s.strip.match(/\A(#{IDENT.source})(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=\]]+)))?\z/)
+        return nil unless m
+
+        attribute = {name: m[1].downcase}
+        value = m[2] || m[3] || m[4]
+        attribute[:value] = value unless value.nil?
+        attribute
+      end
+
+      def closing_index(raw, character)
+        quote = nil
+
+        raw.each_char.with_index do |ch, index|
+          next if index.zero?
+
+          if quote
+            quote = nil if ch == quote
+            next
+          end
+
+          if ch == '"' || ch == "'"
+            quote = ch
+            next
+          end
+
+          return index if ch == character
+        end
+
+        nil
+      end
+
+      def first_element_child?(node)
+        element_siblings(node).first == node
+      end
+
+      def last_element_child?(node)
+        element_siblings(node).last == node
+      end
+
+      def element_siblings(node)
+        node.parent&.children&.select { |child| child.respond_to?(:element?) && child.element? } || []
+      end
+
+      def previous_element_sibling(node)
+        siblings = node.parent&.children
+        return nil unless siblings
+
+        index = siblings.index(node)
+        return nil unless index
+
+        (index - 1).downto(0) do |candidate_index|
+          candidate = siblings[candidate_index]
+          return candidate if candidate.respond_to?(:element?) && candidate.element?
+        end
+
+        nil
+      end
+
+      def invalid_steps
+        @valid = false
+        []
+      end
+
+      def invalid_simple
+        @valid = false
+        nil
+      end
     end
   end
 end

data/lib/silk_layout/css/values.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module SilkLayout
+  module CSS
+    module Values
+      NUMBER = /[-+]?(?:\d+(?:\.\d+)?|\.\d+)/
+      LENGTH = /\A(?<number>#{NUMBER.source})(?<unit>px|%)?\z/i
+      CALC = /\Acalc\((?<expression>.*)\)\z/i
+
+      NAMED_LENGTHS = {
+        "thin" => 1,
+        "medium" => 3,
+        "thick" => 5
+      }.freeze
+
+      Term = Struct.new(:value, :unit)
+
+      class Length
+        attr_reader :type, :value, :unit, :terms
+
+        def self.parse(value)
+          raw = value.to_s.strip
+          normalized = raw.downcase
+          return new(:auto) if normalized.empty? || normalized == "auto" || normalized == "none"
+
+          named = NAMED_LENGTHS[normalized]
+          return new(:length, value: named.to_f, unit: "px") if named
+
+          calc_match = raw.match(CALC)
+          if calc_match
+            parsed = parse_calc(calc_match[:expression])
+            return parsed if parsed
+
+            return new(:length, value: raw.to_f, unit: "px")
+          end
+
+          match = raw.match(LENGTH)
+          return new(:length, value: match[:number].to_f, unit: (match[:unit] || "px").downcase) if match
+
+          new(:length, value: raw.to_f, unit: "px")
+        end
+
+        def self.parse_calc(expression)
+          scanner = StringScanner.new(expression)
+          terms = []
+          sign = 1
+
+          until scanner.eos?
+            scanner.skip(/\s+/)
+
+            operator = scanner.scan(/[+-]/)
+            sign = (operator == "-") ? -1 : 1 if operator
+            scanner.skip(/\s+/)
+
+            token = scanner.scan(/(?:\d+(?:\.\d+)?|\.\d+)(?:px|%)?/i)
+            return nil unless token
+
+            length = parse(token)
+            return nil unless length.type == :length
+
+            terms << Term.new(length.value * sign, length.unit)
+            scanner.skip(/\s+/)
+
+            return nil unless scanner.eos? || scanner.peek(1).match?(/[+-]/)
+          end
+
+          return nil if terms.empty?
+
+          new(:calc, terms: terms)
+        end
+
+        def initialize(type, value: 0, unit: nil, terms: [])
+          @type = type
+          @value = value
+          @unit = unit
+          @terms = terms
+        end
+
+        def resolve(reference: nil, default: 0)
+          case type
+          when :auto
+            default
+          when :length
+            return default if unit == "%" && reference.nil?
+
+            (unit == "%") ? reference * value / 100.0 : value
+          when :calc
+            return default if terms.any? { |term| term.unit == "%" } && reference.nil?
+
+            terms.sum do |term|
+              (term.unit == "%") ? reference * term.value / 100.0 : term.value
+            end
+          else
+            default
+          end
+        end
+
+        def reference_relative?
+          return true if type == :length && unit == "%"
+          return true if type == :calc && terms.any? { |term| term.unit == "%" }
+
+          false
+        end
+      end
+
+      module_function
+
+      def length(value)
+        value.is_a?(Length) ? value : Length.parse(value)
+      end
+
+      def resolve_length(value, reference: nil, default: 0)
+        length(value).resolve(reference: reference, default: default)
+      end
+
+      def reference_relative?(value)
+        length(value).reference_relative?
+      end
+
+      def split_tokens(value)
+        tokens = []
+        current = +""
+        depth = 0
+
+        value.to_s.each_char do |char|
+          case char
+          when "("
+            depth += 1
+            current << char
+          when ")"
+            depth -= 1 if depth.positive?
+            current << char
+          when /\s/
+            if depth.zero?
+              tokens << current unless current.empty?
+              current = +""
+            else
+              current << char
+            end
+          else
+            current << char
+          end
+        end
+
+        tokens << current unless current.empty?
+        tokens
+      end
+
+      def expanded_edges(value)
+        tokens = split_tokens(value)
+
+        case tokens.length
+        when 0
+          {top: nil, right: nil, bottom: nil, left: nil}
+        when 1
+          {top: tokens[0], right: tokens[0], bottom: tokens[0], left: tokens[0]}
+        when 2
+          {top: tokens[0], right: tokens[1], bottom: tokens[0], left: tokens[1]}
+        when 3
+          {top: tokens[0], right: tokens[1], bottom: tokens[2], left: tokens[1]}
+        else
+          {top: tokens[0], right: tokens[1], bottom: tokens[2], left: tokens[3]}
+        end
+      end
+    end
+  end
+end

data/lib/silk_layout/html/node.rb

@@ -6,6 +6,7 @@ module SilkLayout
       attr_reader :tag, :attributes, :text
       attr_accessor :children, :parent
       attr_accessor :computed_style
+      attr_accessor :resolved_source_url
 
       def initialize(tag:, attributes:, children:, text: nil, parent: nil)
         @tag = tag

data/lib/silk_layout/html/parser.rb

@@ -13,7 +13,10 @@ module SilkLayout
         base_uri = base_uri_for(document, url)
         stylesheets = extract_stylesheets!(document, base_uri)
 
-        [Node.from_nokogiri(document.root), stylesheets]
+        root = Node.from_nokogiri(document.root)
+        resolve_resource_urls!(root, base_uri)
+
+        [root, stylesheets]
       end
 
       def self.extract_stylesheets!(document, base_uri)
@@ -75,7 +78,7 @@ module SilkLayout
         dir = p.to_s
         dir = "#{dir}/" unless dir.end_with?("/")
 
-        URI::Generic.build(scheme: "file", path: dir)
+        URI::Generic.build(scheme: "file", path: URI::RFC2396_PARSER.escape(dir, /[^A-Za-z0-9\-._~\/]/))
       end
 
       def self.fetch_stylesheet(href, base_uri, cache)
@@ -107,7 +110,18 @@ module SilkLayout
 
         URI.join(base_uri.to_s, href)
       rescue URI::InvalidURIError
-        URI.join(base_uri.to_s, URI::DEFAULT_PARSER.escape(href))
+        URI.join(base_uri.to_s, URI::RFC2396_PARSER.escape(href))
+      end
+
+      def self.resolve_resource_urls!(node, base_uri)
+        return unless node
+
+        if node.element? && node.tag == "img"
+          src = node.attributes["src"].to_s.strip
+          node.resolved_source_url = normalize_href(src, base_uri) unless src.empty?
+        end
+
+        node.children.each { |child| resolve_resource_urls!(child, base_uri) }
       end
 
       def self.fetch_http(uri)