p_css 0.2.0.beta1-aarch64-linux

data/lib/css/tokenizer.rb

@@ -0,0 +1,447 @@
+module CSS
+  # Tokenizer based on CSS Syntax Module Level 3/4 §4.
+  # https://www.w3.org/TR/css-syntax-3/#tokenization
+  #
+  # Not thread-safe: an instance carries a mutable cursor (`@pos`) that
+  # advances over the input. Allocate one tokenizer per thread.
+  class Tokenizer
+    include CodePoints
+
+    PUNCTUATION = {
+      '(' => :lparen,
+      ')' => :rparen,
+      ',' => :comma,
+      ':' => :colon,
+      ';' => :semicolon,
+      '[' => :lbracket,
+      ']' => :rbracket,
+      '{' => :lbrace,
+      '}' => :rbrace
+    }.freeze
+
+    # CR / FF (and CR LF) collapse to LF; NUL collapses to U+FFFD. Done in
+    # one pass.
+    PREPROCESS_RE = /\r\n?|\f|\0/.freeze
+
+    def initialize(input, preserve_comments: false)
+      @chars             = preprocess(input)
+      @length            = @chars.length
+      @pos               = 0
+      @newlines          = collect_newline_offsets(@chars)
+      @preserve_comments = preserve_comments
+    end
+
+    def tokenize
+      tokens = []
+
+      loop do
+        token = next_token
+        break if token.type == :eof
+
+        tokens << token
+      end
+
+      tokens
+    end
+
+    def next_token
+      consume_comments unless @preserve_comments
+
+      return Token.new(:eof) if @pos >= @length
+
+      start_offset = @pos
+      tok          = consume_one_token
+
+      tok.assign_source!(start_offset, @pos, @newlines)
+    end
+
+    private
+
+    def consume_one_token
+      return consume_comment_token if peek == '/' && peek(1) == '*'
+
+      c = consume
+
+      return consume_whitespace      if whitespace?(c)
+      return consume_string_token(c) if c == '"' || c == "'"
+
+      if (c == '+' || c == '-' || c == '.') && number_starts?(c, peek, peek(1))
+        reconsume
+        return consume_numeric_token
+      end
+
+      if (type = PUNCTUATION[c])
+        return Token.new(type)
+      end
+
+      case c
+      when '#'
+        if ident_code_point?(peek) || valid_escape?(peek, peek(1))
+          flag = ident_sequence_starts?(peek, peek(1), peek(2)) ? :id : :unrestricted
+          Token.new(:hash, consume_ident_sequence, flag:)
+        else
+          Token.new(:delim, c)
+        end
+      when '+', '.'
+        Token.new(:delim, c)
+      when '-'
+        if peek == '-' && peek(1) == '>'
+          consume
+          consume
+          Token.new(:cdc)
+        elsif ident_sequence_starts?(c, peek, peek(1))
+          reconsume
+          consume_ident_like_token
+        else
+          Token.new(:delim, c)
+        end
+      when '<'
+        if peek == '!' && peek(1) == '-' && peek(2) == '-'
+          consume
+          consume
+          consume
+          Token.new(:cdo)
+        else
+          Token.new(:delim, c)
+        end
+      when '@'
+        if ident_sequence_starts?(peek, peek(1), peek(2))
+          Token.new(:at_keyword, consume_ident_sequence)
+        else
+          Token.new(:delim, c)
+        end
+      when '\\'
+        if valid_escape?(c, peek)
+          reconsume
+          consume_ident_like_token
+        else
+          Token.new(:delim, c)
+        end
+      when '0'..'9'
+        reconsume
+        consume_numeric_token
+      else
+        if ident_start_code_point?(c)
+          reconsume
+          consume_ident_like_token
+        else
+          Token.new(:delim, c)
+        end
+      end
+    end
+
+    # Random access on a non-ascii-only UTF-8 String is O(distance from
+    # the cached character index), and the peek-ahead pattern (`peek`,
+    # `peek(1)`, `peek(2)`) defeats the cache — empirically ~200× slower
+    # than indexing a flat Array. Splitting into `chars` once amortizes
+    # the UTF-8 walk and gives us O(1) random access for the rest of
+    # tokenization.
+    def preprocess(input)
+      input
+        .encode('UTF-8')
+        .gsub(PREPROCESS_RE) { $~[0] == "\0" ? CodePoints::REPLACEMENT : "\n" }
+        .chars
+    end
+
+    def peek(offset = 0)
+      @chars[@pos + offset]
+    end
+
+    def consume
+      c = @chars[@pos]
+      return nil if c.nil?
+
+      @pos += 1
+      c
+    end
+
+    def reconsume
+      @pos -= 1
+    end
+
+    def collect_newline_offsets(chars)
+      offsets = []
+      i       = 0
+      n       = chars.length
+
+      while i < n
+        offsets << i if chars[i] == "\n"
+        i += 1
+      end
+
+      offsets
+    end
+
+    def whitespace?(c)
+      c == ' ' || c == "\n" || c == "\t"
+    end
+
+    def non_printable?(c)
+      return false if c.nil?
+
+      o = c.ord
+      o <= 0x08 || o == 0x0B || (0x0E..0x1F).cover?(o) || o == 0x7F
+    end
+
+    # §4.3.8.
+    def valid_escape?(c1, c2)
+      c1 == '\\' && c2 != "\n" && !c2.nil?
+    end
+
+    # §4.3.9.
+    def ident_sequence_starts?(c1, c2, c3)
+      case c1
+      when '-'
+        ident_start_code_point?(c2) || c2 == '-' || valid_escape?(c2, c3)
+      when '\\'
+        valid_escape?(c1, c2)
+      else
+        ident_start_code_point?(c1)
+      end
+    end
+
+    # §4.3.10.
+    def number_starts?(c1, c2, c3)
+      case c1
+      when '+', '-'
+        digit?(c2) || (c2 == '.' && digit?(c3))
+      when '.'
+        digit?(c2)
+      else
+        digit?(c1)
+      end
+    end
+
+    # §4.3.2. Skips through `/* ... */` comments without producing tokens.
+    def consume_comments
+      while peek == '/' && peek(1) == '*'
+        consume
+        consume
+
+        until eof?
+          if consume == '*' && peek == '/'
+            consume
+            break
+          end
+        end
+      end
+    end
+
+    # When `preserve_comments` is on, comments are emitted as tokens whose
+    # value is the body between `/*` and `*/`.
+    def consume_comment_token
+      consume
+      consume
+      buf = +''
+
+      until eof?
+        c = consume
+        if c == '*' && peek == '/'
+          consume
+          break
+        end
+
+        buf << c
+      end
+
+      Token.new(:comment, buf)
+    end
+
+    def eof?
+      @pos >= @length
+    end
+
+    def consume_whitespace
+      consume while whitespace?(peek)
+
+      Token.new(:whitespace)
+    end
+
+    # §4.3.5.
+    def consume_string_token(ending)
+      buf = +''
+
+      loop do
+        c = consume
+
+        case c
+        when nil, ending
+          return Token.new(:string, buf)
+        when "\n"
+          reconsume
+          return Token.new(:bad_string)
+        when '\\'
+          n = peek
+
+          if n.nil?
+            next
+          elsif n == "\n"
+            consume
+          else
+            buf << consume_escaped_code_point
+          end
+        else
+          buf << c
+        end
+      end
+    end
+
+    # §4.3.7. Assumes the backslash has already been consumed.
+    def consume_escaped_code_point
+      c = consume
+
+      return CodePoints::REPLACEMENT if c.nil?
+      return c                       unless hex_digit?(c)
+
+      hex = c.dup
+      hex << consume while hex.length < 6 && hex_digit?(peek)
+      consume if whitespace?(peek)
+
+      n = hex.to_i(16)
+
+      if n.zero? || (0xD800..0xDFFF).cover?(n) || n > 0x10FFFF
+        CodePoints::REPLACEMENT
+      else
+        [n].pack('U')
+      end
+    end
+
+    # §4.3.11.
+    def consume_ident_sequence
+      buf = +''
+
+      loop do
+        c = consume
+
+        if ident_code_point?(c)
+          buf << c
+        elsif valid_escape?(c, peek)
+          buf << consume_escaped_code_point
+        else
+          reconsume unless c.nil?
+          return buf
+        end
+      end
+    end
+
+    # §4.3.4.
+    def consume_ident_like_token
+      name = consume_ident_sequence
+
+      if name.casecmp('url').zero? && peek == '('
+        consume
+
+        consume while whitespace?(peek) && whitespace?(peek(1))
+
+        n1 = peek
+        n2 = whitespace?(n1) ? peek(1) : n1
+
+        if n1 == '"' || n1 == "'" || (whitespace?(n1) && (n2 == '"' || n2 == "'"))
+          Token.new(:function, name)
+        else
+          consume_url_token
+        end
+      elsif peek == '('
+        consume
+        Token.new(:function, name)
+      else
+        Token.new(:ident, name)
+      end
+    end
+
+    # §4.3.6. Assumes "url(" has already been consumed.
+    def consume_url_token
+      buf = +''
+
+      consume while whitespace?(peek)
+
+      loop do
+        c = consume
+
+        case c
+        when nil, ')'
+          return Token.new(:url, buf)
+        when '"', "'", '('
+          consume_bad_url_remnants
+          return Token.new(:bad_url)
+        when ' ', "\t", "\n"
+          consume while whitespace?(peek)
+
+          n = peek
+
+          if n.nil? || n == ')'
+            consume unless n.nil?
+            return Token.new(:url, buf)
+          else
+            consume_bad_url_remnants
+            return Token.new(:bad_url)
+          end
+        when '\\'
+          if valid_escape?(c, peek)
+            buf << consume_escaped_code_point
+          else
+            consume_bad_url_remnants
+            return Token.new(:bad_url)
+          end
+        else
+          if non_printable?(c)
+            consume_bad_url_remnants
+            return Token.new(:bad_url)
+          end
+
+          buf << c
+        end
+      end
+    end
+
+    # §4.3.14.
+    def consume_bad_url_remnants
+      loop do
+        c = consume
+
+        return if c.nil? || c == ')'
+
+        consume_escaped_code_point if valid_escape?(c, peek)
+      end
+    end
+
+    # §4.3.3.
+    def consume_numeric_token
+      number, flag = consume_number
+
+      if ident_sequence_starts?(peek, peek(1), peek(2))
+        Token.new(:dimension, number, flag:, unit: consume_ident_sequence)
+      elsif peek == '%'
+        consume
+        Token.new(:percentage, number)
+      else
+        Token.new(:number, number, flag:)
+      end
+    end
+
+    # §4.3.12. Returns [numeric_value, :integer | :number].
+    def consume_number
+      repr = +''
+      flag = :integer
+
+      repr << consume if peek == '+' || peek == '-'
+      repr << consume while digit?(peek)
+
+      if peek == '.' && digit?(peek(1))
+        repr << consume
+        repr << consume while digit?(peek)
+        flag = :number
+      end
+
+      if (peek == 'E' || peek == 'e') &&
+          (digit?(peek(1)) || ((peek(1) == '+' || peek(1) == '-') && digit?(peek(2))))
+        repr << consume
+        repr << consume if peek == '+' || peek == '-'
+        repr << consume while digit?(peek)
+        flag = :number
+      end
+
+      [flag == :integer ? repr.to_i : repr.to_f, flag]
+    end
+  end
+end

data/lib/css/urange.rb

@@ -0,0 +1,45 @@
+module CSS
+  # Parser for CSS <urange> tokens, e.g. `U+0-7F`, `U+26`, `U+10??`.
+  # https://drafts.csswg.org/css-syntax/#urange-syntax
+  #
+  # Operates on the source string rather than a token stream because the
+  # tokenizer destructively normalizes shapes like `U+0` (the `+` is
+  # absorbed into a number-token whose sign is lost on serialization).
+  # Sticking with the source preserves the exact form.
+  module Urange
+    URANGE_RE   = /\Au\+([0-9a-f?]{1,6})(?:-([0-9a-f]{1,6}))?\z/i.freeze
+    WILDCARD_RE = /\A[0-9a-f]*\?+\z/i.freeze
+
+    MAX_CODEPOINT = 0x10FFFF
+
+    extend self
+
+    def parse(input)
+      s = input.to_s.strip
+      m = URANGE_RE.match(s)
+
+      raise ParseError, "invalid urange: #{input.inspect}" unless m
+
+      start_str, end_str = m[1], m[2]
+
+      first, last =
+        if end_str
+          raise ParseError, 'wildcards are not allowed in range form' if start_str.include?('?')
+
+          [start_str.to_i(16), end_str.to_i(16)]
+        elsif start_str.include?('?')
+          raise ParseError, 'wildcards must be trailing' unless start_str.match?(WILDCARD_RE)
+
+          [start_str.tr('?', '0').to_i(16), start_str.tr('?', 'f').to_i(16)]
+        else
+          n = start_str.to_i(16)
+          [n, n]
+        end
+
+      raise ParseError, "codepoint out of range: U+#{format('%X', last)}" if last > MAX_CODEPOINT
+      raise ParseError, "urange start must be <= end (U+#{format('%X', first)} > U+#{format('%X', last)})" if first > last
+
+      Nodes::UnicodeRange.new(first:, last:)
+    end
+  end
+end

data/lib/css/version.rb

@@ -0,0 +1,3 @@
+module CSS
+  VERSION = '0.2.0.beta1'
+end

data/lib/css.rb

@@ -0,0 +1,73 @@
+module CSS
+  # Bracket information for the three "simple block" pairs. Indexed both by
+  # opening token type (for the parser) and by opening character (for the
+  # serializer).
+  BRACKET_OPEN_CHAR  = {lbrace: '{', lbracket: '[', lparen: '('}.freeze
+  BRACKET_CLOSE_TYPE = {lbrace: :rbrace, lbracket: :rbracket, lparen: :rparen}.freeze
+  BRACKET_PAIRS      = {'{' => '}', '[' => ']', '(' => ')'}.freeze
+end
+
+require_relative 'css/version'
+require_relative 'css/code_points'
+require_relative 'css/escape'
+require_relative 'css/token'
+require_relative 'css/tokenizer'
+require_relative 'css/token_cursor'
+require_relative 'css/nodes'
+require_relative 'css/parser'
+require_relative 'css/selectors'
+require_relative 'css/media_queries'
+require_relative 'css/serializer'
+require_relative 'css/urange'
+require_relative 'css/nesting'
+require_relative 'css/cascade'
+
+module CSS
+  class ParseError < StandardError
+    attr_reader :position
+
+    def initialize(message, position: nil)
+      super(position ? "#{position}: #{message}" : message)
+      @position = position
+    end
+  end
+
+  class << self
+    def tokenize(input, **opts)                    = Tokenizer.new(input, **opts).tokenize
+    def parse_stylesheet(input, **opts)            = Parser.parse_stylesheet(input, **opts)
+    def parse_rule(input, **opts)                  = Parser.parse_rule(input, **opts)
+    def parse_declaration(input, **opts)           = Parser.parse_declaration(input, **opts)
+    def parse_block_contents(input, **opts)        = Parser.parse_block_contents(input, **opts)
+    def parse_component_value(input, **opts)       = Parser.parse_component_value(input, **opts)
+    def parse_component_values(input, **opts)      = Parser.parse_component_values(input, **opts)
+    def parse_comma_separated_values(input, **opts) = Parser.parse_comma_separated_values(input, **opts)
+
+    def parse_urange(input) = Urange.parse(input)
+
+    def parse_selector_list(input) = Selectors::Parser.parse_selector_list(input)
+    def parse_selector(input)      = Selectors::Parser.parse_selector(input)
+    def parse_anb(input)           = Selectors::AnBParser.parse(input)
+
+    def specificity(selector) = Selectors::SpecificityCalculator.calculate(selector)
+
+    def matches?(element, selector, state: nil) = Selectors::Matcher.matches?(element, selector, state: state)
+
+    def parse_media_query_list(input) = MediaQueries::Parser.parse(input)
+
+    def media_matches?(query_list, context)
+      ql = query_list.is_a?(String) ? MediaQueries::Parser.parse(query_list) : query_list
+      ctx = context.is_a?(MediaQueries::Context) ? context : MediaQueries::Context.default(**context.to_h)
+      MediaQueries::Evaluator.evaluate(ql, ctx)
+    end
+
+    def cascade(stylesheet, context: MediaQueries::Context.default)
+      Cascade.new(stylesheet, context:)
+    end
+
+    def desugar(stylesheet) = Nesting.desugar(stylesheet)
+
+    def serialize(node) = Serializer.serialize(node)
+
+    alias parse parse_stylesheet
+  end
+end

data/lib/p_css.rb

@@ -0,0 +1 @@
+require_relative 'css'

data/sig/css/cascade.rbs

@@ -0,0 +1,22 @@
+module CSS
+  # See `CSS.cascade` for the typical entry point.
+  class Cascade
+    type inline_style = String | Nodes::Block | Array[Nodes::Declaration]
+
+    class Match < Data
+      attr_reader declaration: Nodes::Declaration
+      attr_reader specificity: Selectors::Specificity
+      attr_reader inline: bool
+      attr_reader order: Integer
+
+      def self.new: (declaration: Nodes::Declaration, specificity: Selectors::Specificity, inline: bool, order: Integer) -> Match
+    end
+
+    def initialize: (Nodes::Stylesheet stylesheet, ?context: MediaQueries::Context) -> void
+
+    # Returns Hash<String, Declaration> of winning declarations after
+    # !important > inline > stylesheet > specificity > source-order
+    # sorting.
+    def resolve: (untyped element, ?inline_style: inline_style?, ?state: matcher_state?) -> Hash[String, Nodes::Declaration]
+  end
+end

data/sig/css/media_queries.rbs

@@ -0,0 +1,107 @@
+module CSS
+  module MediaQueries
+    module Node
+    end
+
+    type modifier = :not | :only
+
+    type comparison_op = :eq | :lt | :le | :gt | :ge
+
+    type media_condition = MediaNot | MediaAnd | MediaOr | MediaFeature | GeneralEnclosed
+
+    type feature_value = Token | Ratio
+
+    class MediaQueryList < Data
+      include Node
+
+      attr_reader queries: Array[MediaQuery]
+
+      def self.new: (queries: Array[MediaQuery]) -> MediaQueryList
+    end
+
+    class MediaQuery < Data
+      include Node
+
+      attr_reader modifier: modifier?
+      attr_reader type: String?
+      attr_reader condition: media_condition?
+
+      def self.new: (modifier: modifier?, type: String?, condition: media_condition?) -> MediaQuery
+    end
+
+    class MediaNot < Data
+      include Node
+
+      attr_reader operand: media_condition
+
+      def self.new: (operand: media_condition) -> MediaNot
+    end
+
+    class MediaAnd < Data
+      include Node
+
+      attr_reader operands: Array[media_condition]
+
+      def self.new: (operands: Array[media_condition]) -> MediaAnd
+    end
+
+    class MediaOr < Data
+      include Node
+
+      attr_reader operands: Array[media_condition]
+
+      def self.new: (operands: Array[media_condition]) -> MediaOr
+    end
+
+    # `op` is `nil` for boolean form (`(color)`), `:eq` for plain
+    # (`(min-width: 600px)`) and explicit `=`, otherwise a comparison.
+    # `value` mirrors that — `nil` for boolean form.
+    class MediaFeature < Data
+      include Node
+
+      attr_reader name: String
+      attr_reader op: comparison_op?
+      attr_reader value: feature_value?
+
+      def self.new: (name: String, op: comparison_op?, value: feature_value?) -> MediaFeature
+    end
+
+    class GeneralEnclosed < Data
+      include Node
+
+      attr_reader tokens: Array[component_value]
+
+      def self.new: (tokens: Array[component_value]) -> GeneralEnclosed
+    end
+
+    class Ratio < Data
+      include Node
+
+      attr_reader numerator: Numeric
+      attr_reader denominator: Numeric
+
+      def self.new: (numerator: Numeric, denominator: Numeric) -> Ratio
+
+      def to_f: () -> Float
+    end
+
+    # User-agent context against which a `MediaQueryList` is evaluated.
+    # `features` is keyed by feature name (no `min-`/`max-` prefix);
+    # values follow Media Queries 4 conventions (lengths in CSS px,
+    # resolution in `dppx`, identifiers as Strings, booleans as 1/0).
+    class Context < Data
+      DEFAULTS: Hash[String, untyped]
+
+      attr_reader features: Hash[String, untyped]
+
+      def self.new: (features: Hash[String, untyped]) -> Context
+
+      # `Context.default('width' => 1200, 'prefers-color-scheme' => 'dark')`
+      def self.default: (**untyped overrides) -> Context
+
+      def []: ((String | Symbol) name) -> untyped
+      def media_type: () -> String
+      def with: (**untyped overrides) -> Context
+    end
+  end
+end