p_css 0.1.0

data/lib/css/media_queries/evaluator.rb

@@ -0,0 +1,157 @@
+module CSS
+  module MediaQueries
+    # Evaluates a MediaQueryList against a Context, returning true if at
+    # least one media-query in the list matches.
+    module Evaluator
+      extend self
+
+      # Length conversion to CSS px assumes 1em = 1rem = 16px. Per Media
+      # Queries Level 4 §1.3 this is the conventional fallback when the
+      # font-size of the root is unknown.
+      EM_PX = 16.0
+
+      LENGTH_UNITS_PX = {
+        'px'  => 1.0,
+        'em'  => EM_PX,
+        'rem' => EM_PX,
+        'ex'  => EM_PX * 0.5,
+        'ch'  => EM_PX * 0.5,
+        'pt'  => 96.0 / 72,
+        'pc'  => 16.0,
+        'in'  => 96.0,
+        'cm'  => 96.0 / 2.54,
+        'mm'  => 96.0 / 25.4,
+        'q'   => 96.0 / 25.4 / 4
+      }.freeze
+
+      RESOLUTION_UNITS_DPPX = {
+        'dppx' => 1.0,
+        'x'    => 1.0,
+        'dpi'  => 1.0 / 96,
+        'dpcm' => 2.54 / 96
+      }.freeze
+
+      RESOLUTION_FEATURES = %w[resolution].freeze
+
+      INVERSE_OP = {lt: :gt, le: :ge, gt: :lt, ge: :le, eq: :eq}.freeze
+
+      PREFIX_OP = {min: :ge, max: :le}.freeze
+
+      def evaluate(query_list, context)
+        query_list.queries.any? { evaluate_query(it, context) }
+      end
+
+      private
+
+      def evaluate_query(query, context)
+        result = evaluate_query_main(query, context)
+        query.modifier == :not ? !result : result
+      end
+
+      def evaluate_query_main(query, context)
+        if query.type
+          return false unless type_matches?(query.type, context.media_type)
+        end
+
+        return true if query.condition.nil?
+
+        evaluate_condition(query.condition, context)
+      end
+
+      def type_matches?(type, ctx_type)
+        type == 'all' || type == ctx_type.to_s
+      end
+
+      def evaluate_condition(node, context)
+        case node
+        when MediaNot       then !evaluate_condition(node.operand, context)
+        when MediaAnd       then node.operands.all? { evaluate_condition(it, context) }
+        when MediaOr        then node.operands.any? { evaluate_condition(it, context) }
+        when MediaFeature   then evaluate_feature(node, context)
+        when GeneralEnclosed then false
+        else                      false
+        end
+      end
+
+      def evaluate_feature(feature, context)
+        ctx_name, prefix = strip_prefix(feature.name)
+        ctx_value = context[ctx_name]
+
+        return evaluate_boolean(ctx_value) if feature.op.nil?
+
+        compare(prefix, feature.op, ctx_value, feature.value, ctx_name)
+      end
+
+      def evaluate_boolean(ctx_value)
+        return false if ctx_value.nil?
+        return false if ctx_value == 0 || ctx_value == false || ctx_value == '' || ctx_value == 'none'
+
+        true
+      end
+
+      def strip_prefix(name)
+        case name
+        when /\Amin-(.+)/ then [$1, :min]
+        when /\Amax-(.+)/ then [$1, :max]
+        else                   [name, nil]
+        end
+      end
+
+      def compare(prefix, op, ctx_value, feature_value, ctx_name)
+        op = PREFIX_OP[prefix] || op
+
+        return string_op_apply(op, ctx_value.to_s, feature_value.value.to_s) if ident_compare?(feature_value)
+
+        a = numeric_for(ctx_name, ctx_value)
+        b = numeric_for(ctx_name, feature_value)
+
+        return false if a.nil? || b.nil?
+
+        numeric_op_apply(op, a, b)
+      end
+
+      def ident_compare?(feature_value)
+        feature_value.is_a?(Token) && feature_value.type == :ident
+      end
+
+      def string_op_apply(op, a, b)
+        op == :eq && a.casecmp?(b)
+      end
+
+      def numeric_op_apply(op, a, b)
+        case op
+        when :eq then a == b
+        when :lt then a < b
+        when :le then a <= b
+        when :gt then a > b
+        when :ge then a >= b
+        end
+      end
+
+      # Converts both context value and feature value to a comparable
+      # numeric in the canonical unit for the named feature.
+      def numeric_for(ctx_name, value)
+        case value
+        when Numeric then value.to_f
+        when Ratio   then value.to_f
+        when Token
+          case value.type
+          when :number     then value.value.to_f
+          when :percentage then value.value.to_f / 100
+          when :dimension  then dimension_to_canonical(value, ctx_name)
+          else                  nil
+          end
+        else nil
+        end
+      end
+
+      def dimension_to_canonical(token, ctx_name)
+        unit  = token.unit.downcase
+        table = RESOLUTION_FEATURES.include?(ctx_name) ? RESOLUTION_UNITS_DPPX : LENGTH_UNITS_PX
+
+        factor = table[unit]
+        factor && token.value.to_f * factor
+      end
+    end
+  end
+end

data/lib/css/media_queries/nodes.rb

@@ -0,0 +1,41 @@
+module CSS
+  module MediaQueries
+    # Marker module for media-query AST nodes; lets the main serializer
+    # dispatch into MediaQueries::Serializer when it ever exists.
+    module Node; end
+
+    MediaQueryList = Data.define(:queries) do
+      include Node
+    end
+
+    # `modifier` is `nil`, `:not`, or `:only`.
+    # `type` is `nil` or a downcased string ('screen', 'print', 'all', ...).
+    # `condition` is `nil` or a media-condition node.
+    MediaQuery = Data.define(:modifier, :type, :condition) do
+      include Node
+    end
+
+    MediaNot = Data.define(:operand)        { include Node }
+    MediaAnd = Data.define(:operands)       { include Node }
+    MediaOr  = Data.define(:operands)       { include Node }
+
+    # `op` is `nil` (boolean form, e.g. `(color)`), `:eq` (plain form,
+    # `(min-width: 600px)`, or range `=`), `:lt`, `:le`, `:gt`, or `:ge`.
+    # `value` is `nil` (boolean), a Token, or a Ratio.
+    MediaFeature = Data.define(:name, :op, :value) do
+      include Node
+    end
+
+    # Catch-all for `(...)` content the parser couldn't recognize as a
+    # feature or condition. Preserved so downstream tools can still see it.
+    GeneralEnclosed = Data.define(:tokens) do
+      include Node
+    end
+
+    # Numeric ratio used in `aspect-ratio` / `device-aspect-ratio` features.
+    Ratio = Data.define(:numerator, :denominator) do
+      include Node
+      def to_f = numerator.to_f / denominator
+    end
+  end
+end

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