p_css 0.2.0.beta1-aarch64-linux

data/lib/css/media_queries/parser.rb

@@ -0,0 +1,374 @@
+module CSS
+  module MediaQueries
+    # Parser for `<media-query-list>` per Media Queries Level 4 §3.
+    # https://drafts.csswg.org/mediaqueries-4/
+    #
+    # Accepts either a String (which is tokenized and re-component-valued
+    # so `(...)` becomes a `SimpleBlock`) or an Array of component values
+    # (for use against an `@media` rule's prelude from the main parser).
+    class Parser
+      include CSS::TokenCursor
+
+      MODIFIER_KEYWORDS = %w[not only].freeze
+      LOGICAL_KEYWORDS  = %w[and or not].freeze
+
+      class << self
+        def parse(input)
+          new(items_from(input)).parse_media_query_list
+        end
+
+        private
+
+        def items_from(input)
+          input.is_a?(String) ? CSS::Parser.parse_component_values(input) : input.to_a
+        end
+      end
+
+      def initialize(items)
+        init_cursor(items)
+      end
+
+      def parse_media_query_list
+        skip_whitespace
+
+        queries = [parse_media_query]
+
+        loop do
+          skip_whitespace
+          break unless peek_token.type == :comma
+
+          consume
+          queries << parse_media_query
+        end
+
+        skip_whitespace
+
+        unless eof?
+          parse_error!("trailing tokens after media query list: #{describe(peek)}")
+        end
+
+        MediaQueryList.new(queries:)
+      end
+
+      def parse_media_query
+        skip_whitespace
+
+        saved = @pos
+
+        # Try the `[not | only]? <media-type> [and <condition-without-or>]?` form.
+        modifier = consume_modifier
+        skip_whitespace if modifier
+
+        if (item = peek).is_a?(Token) && item.type == :ident && !LOGICAL_KEYWORDS.include?(item.value.downcase)
+          type = consume.value.downcase
+          skip_whitespace
+
+          condition = nil
+
+          if keyword?('and')
+            consume
+            skip_whitespace
+            condition = parse_media_condition(allow_or: false)
+          end
+
+          return MediaQuery.new(modifier:, type:, condition:)
+        end
+
+        # Otherwise this is a pure media-condition (no type / modifier).
+        @pos = saved
+
+        MediaQuery.new(modifier: nil, type: nil, condition: parse_media_condition(allow_or: true))
+      end
+
+      private
+
+      def parse_media_condition(allow_or:)
+        skip_whitespace
+
+        if keyword?('not')
+          consume
+          skip_whitespace
+          return MediaNot.new(operand: parse_media_in_parens)
+        end
+
+        first = parse_media_in_parens
+
+        skip_whitespace
+
+        if keyword?('and')
+          operands = [first]
+          while keyword?('and')
+            consume
+            skip_whitespace
+            operands << parse_media_in_parens
+            skip_whitespace
+          end
+          MediaAnd.new(operands:)
+        elsif allow_or && keyword?('or')
+          operands = [first]
+          while keyword?('or')
+            consume
+            skip_whitespace
+            operands << parse_media_in_parens
+            skip_whitespace
+          end
+          MediaOr.new(operands:)
+        else
+          first
+        end
+      end
+
+      def parse_media_in_parens
+        item = peek
+
+        unless item.is_a?(Nodes::SimpleBlock) && item.parenthesized?
+          parse_error!("expected '(', got #{describe(item)}")
+        end
+
+        consume
+        inner = self.class.new(item.value)
+        inner.parse_in_parens_contents
+      end
+
+      protected
+
+      # Called on a sub-parser whose @items is the contents inside `(...)`.
+      # Returns a media-condition or a feature.
+      def parse_in_parens_contents
+        skip_whitespace
+
+        return GeneralEnclosed.new(tokens: []) if eof?
+
+        # Nested `(condition)`?
+        first = peek
+
+        if first.is_a?(Nodes::SimpleBlock) && first.parenthesized?
+          cond = parse_media_condition(allow_or: true)
+          skip_whitespace
+
+          unless eof?
+            return GeneralEnclosed.new(tokens: @items)
+          end
+
+          return cond
+        end
+
+        result = try_parse_feature
+
+        return result if result
+
+        GeneralEnclosed.new(tokens: @items)
+      end
+
+      private
+
+      def try_parse_feature
+        saved = @pos
+
+        starting_token = peek
+
+        if starting_token.is_a?(Token) && starting_token.type == :ident
+          feature = try_parse_feature_starting_with_ident
+
+          return feature if feature
+
+          @pos = saved
+        end
+
+        if value_starts?(starting_token)
+          feature = try_parse_feature_starting_with_value
+
+          return feature if feature
+
+          @pos = saved
+        end
+
+        nil
+      end
+
+      def try_parse_feature_starting_with_ident
+        name = consume.value.downcase
+
+        skip_whitespace
+
+        if eof?
+          return MediaFeature.new(name:, op: nil, value: nil)
+        end
+
+        if peek_token.type == :colon
+          consume
+          skip_whitespace
+          value = parse_mf_value
+
+          return nil if value.nil?
+
+          skip_whitespace
+
+          return nil unless eof?
+
+          return MediaFeature.new(name:, op: :eq, value:)
+        end
+
+        if (op = consume_comparison)
+          skip_whitespace
+          value = parse_mf_value
+
+          return nil if value.nil?
+
+          skip_whitespace
+
+          if eof?
+            return MediaFeature.new(name:, op:, value:)
+          end
+
+          # Bounded form: `<name> <op> <value> ... <op> <value>`
+          # Per spec, bounded form has the name in the middle, not here.
+          # Reject.
+          return nil
+        end
+
+        nil
+      end
+
+      def try_parse_feature_starting_with_value
+        first_value = parse_mf_value
+
+        return nil if first_value.nil?
+
+        skip_whitespace
+
+        first_op = consume_comparison
+
+        return nil unless first_op
+
+        skip_whitespace
+
+        return nil unless peek_token.type == :ident
+
+        name = consume.value.downcase
+
+        skip_whitespace
+
+        if eof?
+          return MediaFeature.new(name:, op: invert_op(first_op), value: first_value)
+        end
+
+        # Bounded form: <value> <op1> <name> <op2> <value>
+        second_op = consume_comparison
+
+        return nil unless second_op
+
+        skip_whitespace
+
+        second_value = parse_mf_value
+
+        return nil if second_value.nil?
+
+        skip_whitespace
+
+        return nil unless eof?
+
+        # Decompose into MediaAnd of two normalized features.
+        MediaAnd.new(operands: [
+          MediaFeature.new(name:, op: invert_op(first_op), value: first_value),
+          MediaFeature.new(name:, op: second_op,           value: second_value)
+        ])
+      end
+
+      # `value op name` swaps to `name (inverted op) value`.
+      INVERSE_OP = {lt: :gt, le: :ge, gt: :lt, ge: :le, eq: :eq}.freeze
+
+      def invert_op(op) = INVERSE_OP.fetch(op, op)
+
+      def parse_mf_value
+        item = peek
+
+        return nil unless item.is_a?(Token)
+
+        case item.type
+        when :number
+          consume
+
+          if peek_token.type == :delim && peek_token.value == '/'
+            consume
+            skip_whitespace
+            denom = peek
+
+            return nil unless denom.is_a?(Token) && denom.type == :number
+
+            consume
+            return Ratio.new(numerator: item.value, denominator: denom.value)
+          end
+
+          item
+        when :dimension, :percentage, :ident, :string
+          consume
+          item
+        else
+          nil
+        end
+      end
+
+      def consume_comparison
+        item = peek
+
+        return nil unless item.is_a?(Token) && item.type == :delim
+
+        case item.value
+        when '='
+          consume
+          :eq
+        when '<'
+          consume
+
+          if peek_token.type == :delim && peek_token.value == '='
+            consume
+            :le
+          else
+            :lt
+          end
+        when '>'
+          consume
+
+          if peek_token.type == :delim && peek_token.value == '='
+            consume
+            :ge
+          else
+            :gt
+          end
+        end
+      end
+
+      def value_starts?(item)
+        item.is_a?(Token) && %i[number dimension percentage].include?(item.type)
+      end
+
+      def consume_modifier
+        item = peek
+
+        return nil unless item.is_a?(Token) && item.type == :ident
+
+        kw = item.value.downcase
+
+        return nil unless MODIFIER_KEYWORDS.include?(kw)
+
+        consume
+        kw.to_sym
+      end
+
+      def keyword?(kw)
+        item = peek
+        item.is_a?(Token) && item.type == :ident && item.value.downcase == kw
+      end
+
+      def describe(item)
+        case item
+        when Token             then item.type
+        when Nodes::SimpleBlock then "#{item.open}-block"
+        when Nodes::Function    then "#{item.name}()"
+        else                        item.class.name
+        end
+      end
+    end
+  end
+end

data/lib/css/media_queries.rb

@@ -0,0 +1,9 @@
+require_relative 'media_queries/nodes'
+require_relative 'media_queries/parser'
+require_relative 'media_queries/context'
+require_relative 'media_queries/evaluator'
+
+module CSS
+  module MediaQueries
+  end
+end

data/lib/css/native.rb

@@ -0,0 +1,179 @@
+require_relative '../css'
+
+# cibuildgem ships precompiled binaries at lib/css/<ruby_minor>/css_native.{so,bundle,dll}.
+# When users compile the gem from source (no platform gem available),
+# extconf.rb places the binary at lib/css/css_native.{so,bundle,dll}.
+# Try the version-specific path first, fall back to the non-versioned one.
+begin
+  ruby_minor = RUBY_VERSION[/\d+\.\d+/]
+  require "css/#{ruby_minor}/css_native"
+rescue LoadError
+  require_relative 'css_native'
+end
+
+# Rust defines matches?, matches_any?, match_indices with a required
+# `state` argument (3 args). Wrap them in Ruby so callers can pass 2
+# args when stateful pseudos aren't relevant.
+module CSS
+  module Native
+    class Snapshot
+      alias_method :_native_matches?,      :matches?
+      alias_method :_native_matches_any?,  :matches_any?
+      alias_method :_native_match_indices, :match_indices
+
+      def matches?(element, selector, state = nil)
+        _native_matches?(element, selector, state)
+      end
+
+      def matches_any?(element, selectors, state = nil)
+        _native_matches_any?(element, selectors, state)
+      end
+
+      def match_indices(element, selectors, state = nil)
+        _native_match_indices(element, selectors, state)
+      end
+    end
+  end
+end
+
+module CSS
+  module Native
+    # High-level wrapper: takes a Nokogiri element + a selector (string or
+    # parsed AST) and returns matches?(element). Falls back to the pure-Ruby
+    # Matcher when the selector contains features the native matcher doesn't
+    # support yet (pseudo-classes, :not, etc.).
+    #
+    # `document:` / `snapshot:` let callers control snapshot reuse across
+    # many matches against the same DOM. With neither, a per-document
+    # snapshot is cached by document identity.
+    class << self
+      def matches?(element, selector, snapshot: nil, document: nil, state: nil)
+        ast      = selector.is_a?(String) ? CSS.parse_selector_list(selector) : selector
+        compiled = compile_or_nil(ast)
+        snap     = snapshot || snapshot_for(document || element.document)
+
+        return CSS.matches?(element, ast, state: state) unless compiled
+
+        native_state = state.nil? ? nil : (state.is_a?(State) ? state : snap.compile_state(state))
+        snap.matches?(element, compiled, native_state)
+      end
+
+      def compile_or_nil(ast)
+        Selector.compile(ast)
+      rescue Unsupported
+        nil
+      end
+
+      private
+
+      def snapshot_for(document)
+        (@snapshots ||= {}.compare_by_identity)[document] ||= Snapshot.from_document(document)
+      end
+    end
+
+    # Subclass of CSS::Cascade that uses the native matcher for the inner
+    # rule-matching loop. Selectors are pre-compiled at construction —
+    # those that can't be compiled (pseudo-classes etc.) fall through to
+    # the pure-Ruby matcher, so behavior is identical to CSS::Cascade.
+    #
+    # Requires a Nokogiri document at construction; the snapshot is built
+    # once and reused for every resolve(). Mutate the DOM and you must
+    # construct a fresh CSS::Native::Cascade.
+    class Cascade < CSS::Cascade
+      def initialize(stylesheet, document, context: CSS::MediaQueries::Context.default)
+        super(stylesheet, context: context)
+
+        @snapshot        = Snapshot.from_document(document)
+        @compiled_by_ast = {}.compare_by_identity
+
+        @entries.each do |entry|
+          entry.selector_pairs.each {|ast, _spec|
+            @compiled_by_ast[ast] = Native.compile_or_nil(ast)
+          }
+        end
+      end
+
+      # Override: batch every candidate's compiled selectors into one FFI
+      # hop per resolve (GVL released), then merge in any Ruby-fallback
+      # matches. Cuts per-resolve FFI cost from O(candidates) to O(1).
+      def resolve(element, inline_style: nil, state: nil)
+        cache        = {}
+        candidates   = collect_candidate_indexes(element, cache)
+        order        = 0
+        matches      = []
+        native_state = state && @snapshot.compile_state(state)
+
+        best_by_entry = native_pass(element, candidates, native_state)
+        ruby_fallback_pass(element, candidates, best_by_entry, cache, state)
+
+        candidates.each do |entry_idx|
+          spec = best_by_entry[entry_idx] or next
+
+          @entries[entry_idx].declarations.each {|decl|
+            order += 1
+            matches << CSS::Cascade::Match.new(declaration: decl, specificity: spec, inline: false, order: order)
+          }
+        end
+
+        if inline_style
+          inline_declarations(inline_style).each {|decl|
+            order += 1
+            matches << CSS::Cascade::Match.new(
+              declaration: decl,
+              specificity: CSS::Selectors::Specificity::ZERO,
+              inline:      true,
+              order:       order
+            )
+          }
+        end
+
+        pick_winners(matches)
+      end
+
+      private
+
+      # Flatten the candidates' compiled selectors into one batched
+      # match_indices call. Returns Hash{entry_idx => best_specificity}.
+      def native_pass(element, candidates, native_state)
+        positions = []
+        sels      = []
+
+        candidates.each do |entry_idx|
+          @entries[entry_idx].selector_pairs.each {|ast, spec|
+            compiled = @compiled_by_ast[ast] or next
+
+            positions << [entry_idx, spec]
+            sels      << compiled
+          }
+        end
+
+        best_by_entry = {}
+
+        return best_by_entry if sels.empty?
+
+        @snapshot.match_indices(element, sels, native_state).each {|i|
+          entry_idx, spec = positions[i]
+          cur             = best_by_entry[entry_idx]
+
+          best_by_entry[entry_idx] = spec if cur.nil? || spec > cur
+        }
+
+        best_by_entry
+      end
+
+      # Run pure-Ruby matching for any selectors that didn't compile
+      # (pseudo-classes, etc.), merging results into best_by_entry.
+      def ruby_fallback_pass(element, candidates, best_by_entry, cache, state)
+        candidates.each do |entry_idx|
+          @entries[entry_idx].selector_pairs.each {|ast, spec|
+            next if @compiled_by_ast[ast]
+            next unless Selectors::Matcher.matches?(element, ast, cache: cache, state: state)
+
+            cur = best_by_entry[entry_idx]
+            best_by_entry[entry_idx] = spec if cur.nil? || spec > cur
+          }
+        end
+      end
+    end
+  end
+end