cataract 0.4.0 → 0.5.0

data/lib/cataract/pure/serializer.rb

@@ -12,13 +12,15 @@ module Cataract
       # compact-vs-formatted knobs all live on ivars instead of being threaded
       # through every helper as parameters.
       class Serializer
-        def initialize(rules, charset, has_nesting, selector_lists, media_queries, media_query_lists, formatted:)
+        def initialize(rules, charset, has_nesting, selector_lists, media_queries, media_query_lists, formatted:,
+                       conditional_groups: [])
           @rules = rules
           @charset = charset
           @has_nesting = has_nesting
           @selector_lists = selector_lists || {}
           @media_queries = media_queries || []
           @media_query_lists = media_query_lists || {}
+          @conditional_groups = conditional_groups || []
           @formatted = formatted
           @result = +''
 
@@ -123,6 +125,64 @@ module Cataract
           end
         end
 
+        # A rule's conditional-group wrapping chain, outermost first, found
+        # by walking parent_id from its own conditional_group_id up to the
+        # root. Only @supports currently populates conditional_group_id (see
+        # the parser), but this walks whatever's there generically.
+        #
+        # @param conditional_group_id [Integer, nil]
+        # @return [Array<ConditionalGroup>] empty if not in any conditional group
+        def conditional_group_chain(conditional_group_id)
+          chain = []
+          id = conditional_group_id
+          while id
+            group = @conditional_groups[id]
+            break unless group
+
+            chain.unshift(group)
+            id = group.parent_id
+          end
+          chain
+        end
+
+        # Reconcile the currently-open conditional-group blocks with the
+        # ones a rule needs, like diffing two paths down a tree: close
+        # whatever's open past where the chains diverge (innermost first),
+        # then open whatever the target chain adds from that point on.
+        # Nested entirely inside whatever media block is currently open
+        # (conditional groups don't affect media context).
+        #
+        # @param current_chain [Array<ConditionalGroup>] currently-open chain, outermost first
+        # @param target_chain [Array<ConditionalGroup>] the chain the next rule needs
+        # @param indent [String]
+        # @return [Array<ConditionalGroup>] target_chain, for the caller to track as current
+        def sync_conditional_group_chain!(current_chain, target_chain, indent)
+          common = 0
+          common += 1 while common < current_chain.size && common < target_chain.size &&
+                            current_chain[common].id == target_chain[common].id
+
+          close_conditional_groups!(current_chain.size - common, indent)
+
+          target_chain[common..].each do |group|
+            prelude = conditional_group_prelude(group)
+            prelude_part = prelude.empty? ? '' : " #{prelude}"
+            @result << indent << "@#{group.type}#{prelude_part} {\n"
+          end
+
+          target_chain
+        end
+
+        # Reconstruct a group's prelude text - "name condition", "name", or
+        # "condition" depending on which are present (@supports only ever
+        # has condition; @container may have either or both).
+        def conditional_group_prelude(group)
+          [group.name, group.condition].compact.join(' ')
+        end
+
+        def close_conditional_groups!(count, indent)
+          count.times { @result << indent << "}\n" }
+        end
+
         # Does the rule's media query differ from the currently open media
         # block, requiring a new "@media ... {" to be opened? Comma-separated
         # lists are compared by list id; single queries are compared by content
@@ -286,6 +346,7 @@ module Cataract
           current_media_query_list_id = nil
           current_media_query = nil
           in_media_block = false
+          current_cg_chain = []
           rule_index = 0
 
           @rules.each do |rule|
@@ -295,9 +356,11 @@ module Cataract
             rule_media_query = rule_media_query_id ? @media_queries[rule_media_query_id] : nil
             rule_media_query_list_id = rule_media_query_id ? @mq_id_to_list_id[rule_media_query_id] : nil
             is_first_rule = (rule_index == 0)
+            rule_cg_chain = conditional_group_chain(rule.conditional_group_id)
 
             if rule_media_query.nil?
               if in_media_block
+                current_cg_chain = sync_conditional_group_chain!(current_cg_chain, [], @media_indent)
                 @result << "}\n"
                 in_media_block = false
                 current_media_query = nil
@@ -306,19 +369,22 @@ module Cataract
 
               @result << "\n" if @add_blank_lines && !is_first_rule
 
+              current_cg_chain = sync_conditional_group_chain!(current_cg_chain, rule_cg_chain, '')
+              indent = current_cg_chain.empty? ? '' : @media_indent
+
               if grouping_enabled && rule.is_a?(Rule) && rule.selector_list_id
                 selectors = find_groupable_selectors(rule, rule_media_query_id)
 
-                @result << selectors.join(', ') << @opening_brace
+                @result << indent << selectors.join(', ') << @opening_brace
                 if @decl_indent_base
                   serialize_declarations_formatted(rule.declarations, @decl_indent_base)
                 else
                   serialize_declarations(rule.declarations)
                 end
-                @result << @closing_brace
+                @result << indent << @closing_brace
               else
                 if @decl_indent_base
-                  serialize_rule_formatted(rule, '', true)
+                  serialize_rule_formatted(rule, indent, true)
                 else
                   serialize_rule(rule)
                 end
@@ -329,6 +395,7 @@ module Cataract
                                                        rule_media_query, rule_media_query_list_id)
 
               if needs_new_block
+                current_cg_chain = sync_conditional_group_chain!(current_cg_chain, [], @media_indent)
                 @result << "}\n" if in_media_block
                 @result << "\n" if @add_blank_lines && !is_first_rule
 
@@ -340,6 +407,8 @@ module Cataract
                 in_media_block = true
               end
 
+              current_cg_chain = sync_conditional_group_chain!(current_cg_chain, rule_cg_chain, @media_indent)
+
               if grouping_enabled && rule.is_a?(Rule) && rule.selector_list_id
                 selectors = find_groupable_selectors(rule, rule_media_query_id)
 
@@ -363,6 +432,8 @@ module Cataract
             rule_index += 1
           end
 
+          close_conditional_groups!(current_cg_chain.size, in_media_block ? @media_indent : '')
+
           @result << "}\n" if in_media_block
         end
 
@@ -441,6 +512,11 @@ module Cataract
 
         # An at-rule (@keyframes, @font-face, etc), compact
         def serialize_at_rule(at_rule)
+          if at_rule.content.nil?
+            @result << "#{at_rule.selector};\n"
+            return
+          end
+
           @result << "#{at_rule.selector} {\n"
 
           if at_rule.content.length > 0
@@ -600,6 +676,13 @@ module Cataract
         end
 
         def serialize_at_rule_formatted(at_rule, indent)
+          if at_rule.content.nil?
+            @result << indent
+            @result << at_rule.selector
+            @result << ";\n"
+            return
+          end
+
           @result << indent
           @result << at_rule.selector
           @result << " {\n"
@@ -637,9 +720,12 @@ module Cataract
       # @param selector_lists [Hash] Selector list ID => array of rule IDs (for grouping)
       # @param media_queries [Array<MediaQuery>] Array of MediaQuery objects
       # @param media_query_lists [Hash] List ID => array of MediaQuery IDs (for comma-separated queries)
+      # @param conditional_groups [Array<ConditionalGroup>] Array of ConditionalGroup objects (@supports/@layer/@container/@scope)
       # @return [String] Compact CSS string
-      def stylesheet_to_s(rules, charset, has_nesting, selector_lists = {}, media_queries = [], media_query_lists = {})
-        Serializer.new(rules, charset, has_nesting, selector_lists, media_queries, media_query_lists, formatted: false).to_s
+      def stylesheet_to_s(rules, charset, has_nesting, selector_lists = {}, media_queries = [], media_query_lists = {},
+                          conditional_groups = [])
+        Serializer.new(rules, charset, has_nesting, selector_lists, media_queries, media_query_lists,
+                       formatted: false, conditional_groups: conditional_groups).to_s
       end
 
       # Serialize stylesheet to formatted CSS string (with indentation).
@@ -650,11 +736,12 @@ module Cataract
       # @param selector_lists [Hash] Selector list ID => array of rule IDs (for grouping)
       # @param media_queries [Array<MediaQuery>] Array of MediaQuery objects
       # @param media_query_lists [Hash] List ID => array of MediaQuery IDs (for comma-separated queries)
+      # @param conditional_groups [Array<ConditionalGroup>] Array of ConditionalGroup objects (@supports/@layer/@container/@scope)
       # @return [String] Formatted CSS string
       def stylesheet_to_formatted_s(rules, charset, has_nesting, selector_lists = {}, media_queries = [],
-                                    media_query_lists = {})
+                                    media_query_lists = {}, conditional_groups = [])
         Serializer.new(rules, charset, has_nesting, selector_lists, media_queries, media_query_lists,
-                       formatted: true).to_s
+                       formatted: true, conditional_groups: conditional_groups).to_s
       end
     end
   end

data/lib/cataract/pure/specificity.rb

@@ -78,8 +78,16 @@ module Cataract
               end
             end
           elsif letter?(byte)
-            element_count += 1
-            i = skip_identifier(selector, i + 1, len)
+            ident_end = skip_identifier(selector, i + 1, len)
+            if ident_end < len && selector.getbyte(ident_end) == BYTE_PIPE
+              # Namespace prefix (ns|E, css-namespaces-3 qname grammar) -
+              # contributes nothing itself; the local name after '|' is the
+              # real type selector and gets counted on the next iteration.
+              i = ident_end + 1
+            else
+              element_count += 1
+              i = ident_end
+            end
           else
             # Whitespace, combinators, and the universal selector (*) all have
             # zero specificity - just skip a single byte.

data/lib/cataract/pure.rb

@@ -37,6 +37,7 @@ require_relative 'declaration'
 require_relative 'rule'
 require_relative 'at_rule'
 require_relative 'media_query'
+require_relative 'conditional_group'
 require_relative 'import_statement'
 require_relative 'stylesheet_scope'
 require_relative 'stylesheet'

data/lib/cataract/rule.rb

@@ -26,6 +26,7 @@ module Cataract
   # @attr [Integer, nil] nesting_style 0=implicit, 1=explicit, nil=not nested
   # @attr [Integer, nil] selector_list_id ID linking rules from same selector list (e.g., "h1, h2")
   # @attr [Integer, nil] media_query_id ID of the MediaQuery this rule belongs to (nil if not in media query)
+  # @attr [Integer, nil] conditional_group_id ID of the ConditionalGroup (@supports/@layer/@container/@scope) this rule belongs to (nil if not in one)
   Rule = Struct.new(
     :id,
     :selector,
@@ -34,7 +35,8 @@ module Cataract
     :parent_rule_id,
     :nesting_style,
     :selector_list_id,
-    :media_query_id
+    :media_query_id,
+    :conditional_group_id
   )
 
   class Rule
@@ -49,6 +51,7 @@ module Cataract
     # @param nesting_style [Integer, nil] Nesting style (0=implicit, 1=explicit, nil=not nested)
     # @param selector_list_id [Integer, nil] Selector list ID for grouping
     # @param media_query_id [Integer, nil] MediaQuery ID for rules in media queries
+    # @param conditional_group_id [Integer, nil] ConditionalGroup ID for rules in @supports/@layer/@container/@scope
     # @return [Rule] New rule instance
     #
     # @example Create a rule with keyword arguments
@@ -60,10 +63,11 @@ module Cataract
     #     parent_rule_id: nil,
     #     nesting_style: nil,
     #     selector_list_id: nil,
-    #     media_query_id: nil
+    #     media_query_id: nil,
+    #     conditional_group_id: nil
     #   )
-    def self.make(id:, selector:, declarations:, specificity: nil, parent_rule_id: nil, nesting_style: nil, selector_list_id: nil, media_query_id: nil)
-      new(id, selector, declarations, specificity, parent_rule_id, nesting_style, selector_list_id, media_query_id)
+    def self.make(id:, selector:, declarations:, specificity: nil, parent_rule_id: nil, nesting_style: nil, selector_list_id: nil, media_query_id: nil, conditional_group_id: nil)
+      new(id, selector, declarations, specificity, parent_rule_id, nesting_style, selector_list_id, media_query_id, conditional_group_id)
     end
 
     # Silence warning about method redefinition. We redefine below to lazily calculate

data/lib/cataract/stylesheet.rb

@@ -29,6 +29,9 @@ module Cataract
     # @return [Array<MediaQuery>] Array of media query objects
     attr_reader :media_queries
 
+    # @return [Array<ConditionalGroup>] Array of conditional-group objects (@supports/@layer/@container/@scope)
+    attr_reader :conditional_groups
+
     # @return [Hash<Symbol, Array<Integer>>] Cached index mapping media query text to rule IDs
     # Lazily build and return media_index.
     # Only builds the index when first accessed, not eagerly during parse.
@@ -160,6 +163,8 @@ module Cataract
       @_next_selector_list_id = 0 # Counter for selector list IDs
       @_media_query_lists = {} # Hash: list_id => Array of MediaQuery IDs (for "screen, print" grouping)
       @_next_media_query_list_id = 0 # Counter for media query list IDs
+      @conditional_groups = [] # Array of ConditionalGroup objects (@supports/@layer/@container/@scope)
+      @_next_conditional_group_id = 0 # Counter for ConditionalGroup IDs
       @charset = nil
       @imports = [] # Array of ImportStatement objects
       @_has_nesting = nil # Set by parser (nil or boolean)
@@ -187,6 +192,8 @@ module Cataract
       @_next_selector_list_id = source.next_selector_list_id
       @_media_query_lists = source.media_query_lists.transform_values(&:dup)
       @_next_media_query_list_id = source.next_media_query_list_id
+      @conditional_groups = source.conditional_groups.dup
+      @_next_conditional_group_id = source.next_conditional_group_id
       @parser_options = source.parser_options.dup
       clear_memoized_caches
       @_hash = nil # Clear cached hash
@@ -474,7 +481,8 @@ module Cataract
     # @example Filter to multiple media types
     #   sheet.to_s(media: [:screen, :print])  # => "@media screen { ... } @media print { ... }"
     def to_s(media: :all)
-      @backend.stylesheet_to_s(filter_rules_by_media(media), @charset, @_has_nesting || false, @_selector_lists, @media_queries, @_media_query_lists)
+      @backend.stylesheet_to_s(filter_rules_by_media(media), @charset, @_has_nesting || false, @_selector_lists, @media_queries, @_media_query_lists,
+                               @conditional_groups)
     end
     alias to_css to_s
 
@@ -500,7 +508,8 @@ module Cataract
     #
     # @see #to_s For compact single-line output
     def to_formatted_s(media: :all)
-      @backend.stylesheet_to_formatted_s(filter_rules_by_media(media), @charset, @_has_nesting || false, @_selector_lists, @media_queries, @_media_query_lists)
+      @backend.stylesheet_to_formatted_s(filter_rules_by_media(media), @charset, @_has_nesting || false, @_selector_lists, @media_queries, @_media_query_lists,
+                                         @conditional_groups)
     end
 
     # Get number of rules
@@ -769,8 +778,9 @@ module Cataract
     # Compare stylesheets for equality.
     #
     # Two stylesheets are equal if they have the same rules in the same order
-    # and the same media queries. Rule equality uses shorthand-aware comparison.
-    # Order matters because CSS cascade depends on rule order.
+    # and the same media queries and conditional groups. Rule equality uses
+    # shorthand-aware comparison. Order matters because CSS cascade depends
+    # on rule order.
     #
     # Charset is ignored since it's file encoding metadata, not semantic content.
     #
@@ -780,6 +790,7 @@ module Cataract
       return false unless other.is_a?(Stylesheet)
       return false unless rules == other.rules
       return false unless @media_queries == other.media_queries
+      return false unless @conditional_groups == other.conditional_groups
 
       true
     end
@@ -787,11 +798,12 @@ module Cataract
 
     # Generate hash code for this stylesheet.
     #
-    # Hash is based on rules and media_queries to match equality semantics.
+    # Hash is based on rules, media_queries, and conditional_groups to match
+    # equality semantics.
     #
     # @return [Integer] hash code
     def hash
-      @_hash ||= [self.class, rules, @media_queries].hash # rubocop:disable Naming/MemoizedInstanceVariableName
+      @_hash ||= [self.class, rules, @media_queries, @conditional_groups].hash # rubocop:disable Naming/MemoizedInstanceVariableName
     end
 
     # Flatten all rules in this stylesheet according to CSS cascade rules.
@@ -852,11 +864,13 @@ module Cataract
       list_id_offset = merge_selector_lists!(other.selector_lists, rule_id_offset: offset)
       mq_id_offset = merge_media_queries!(other.media_queries)
       merge_media_query_lists!(other.media_query_lists, mq_id_offset: mq_id_offset)
+      cg_id_offset = merge_conditional_groups!(other.conditional_groups)
 
       # Add rules with updated IDs and cross-references
       other.rules.each do |rule|
         new_rule = rule.dup
-        rebase_rule!(new_rule, rule_id_offset: offset, list_id_offset: list_id_offset, mq_id_offset: mq_id_offset)
+        rebase_rule!(new_rule, rule_id_offset: offset, list_id_offset: list_id_offset, mq_id_offset: mq_id_offset,
+                               cg_id_offset: cg_id_offset)
         @rules << new_rule
       end
 
@@ -946,6 +960,10 @@ module Cataract
       @_next_media_query_id
     end
 
+    def next_conditional_group_id
+      @_next_conditional_group_id
+    end
+
     def next_selector_list_id
       @_next_selector_list_id
     end
@@ -998,6 +1016,28 @@ module Cataract
       mq_id_offset
     end
 
+    # Offset and append ConditionalGroup objects into @conditional_groups,
+    # without mutating the source objects. Unlike merge_media_queries!,
+    # each group's own parent_id (pointing at another ConditionalGroup, for
+    # nesting) must also be rebased by the same offset.
+    #
+    # @param source_groups [Array<ConditionalGroup>, nil]
+    # @return [Integer] id offset applied to each merged ConditionalGroup
+    def merge_conditional_groups!(source_groups)
+      cg_id_offset = @_next_conditional_group_id
+      return cg_id_offset if source_groups.nil? || source_groups.empty?
+
+      source_groups.each do |group|
+        new_group = group.dup
+        new_group.id += cg_id_offset
+        new_group.parent_id += cg_id_offset if new_group.parent_id
+        @conditional_groups << new_group
+      end
+      @_next_conditional_group_id += source_groups.size
+
+      cg_id_offset
+    end
+
     # Offset and merge a selector_lists hash (list_id => [rule_ids]) into
     # @_selector_lists. List ids are always rebased onto the next available
     # id; rule ids are rebased by rule_id_offset (0 when the caller defers
@@ -1056,18 +1096,21 @@ module Cataract
     end
 
     # Rebase a rule/at-rule's own id and its cross-references (Rule's
-    # selector_list_id, and media_query_id on both Rule and AtRule) by the
-    # given offsets, mutating it in place. Callers merging from a live
-    # Stylesheet they don't own (e.g. concat) must dup the rule first.
+    # selector_list_id, and media_query_id/conditional_group_id on both Rule
+    # and AtRule) by the given offsets, mutating it in place. Callers
+    # merging from a live Stylesheet they don't own (e.g. concat) must dup
+    # the rule first.
     #
     # @param rule [Rule, AtRule]
     # @param rule_id_offset [Integer]
     # @param list_id_offset [Integer]
     # @param mq_id_offset [Integer]
+    # @param cg_id_offset [Integer]
     # @return [void]
-    def rebase_rule!(rule, rule_id_offset:, list_id_offset: 0, mq_id_offset: 0)
+    def rebase_rule!(rule, rule_id_offset:, list_id_offset: 0, mq_id_offset: 0, cg_id_offset: 0)
       rule.id += rule_id_offset
       rule.media_query_id += mq_id_offset if rule.media_query_id
+      rule.conditional_group_id += cg_id_offset if rule.conditional_group_id
       return unless rule.is_a?(Rule)
 
       rule.selector_list_id += list_id_offset if rule.selector_list_id
@@ -1099,10 +1142,12 @@ module Cataract
       list_id_offset = merge_selector_lists!(result[:_selector_lists], rule_id_offset: offset)
       mq_id_offset = merge_media_queries!(result[:media_queries])
       merge_media_query_lists!(result[:_media_query_lists], mq_id_offset: mq_id_offset)
+      cg_id_offset = merge_conditional_groups!(result[:conditional_groups])
 
       new_rules = result[:rules]
       new_rules.each do |rule|
-        rebase_rule!(rule, rule_id_offset: offset, list_id_offset: list_id_offset, mq_id_offset: mq_id_offset)
+        rebase_rule!(rule, rule_id_offset: offset, list_id_offset: list_id_offset, mq_id_offset: mq_id_offset,
+                           cg_id_offset: cg_id_offset)
         @rules << rule
       end
       @_last_rule_id = offset + new_rules.length
@@ -1313,7 +1358,8 @@ module Cataract
     # @return [void]
     def merge_imported_sheet!(imported_sheet, import)
       mq_id_offset = merge_media_queries!(imported_sheet.media_queries)
-      rebase_imported_rules_media_query!(imported_sheet.rules, mq_id_offset, import.media_query_id)
+      cg_id_offset = merge_conditional_groups!(imported_sheet.conditional_groups)
+      rebase_imported_rules!(imported_sheet.rules, mq_id_offset, cg_id_offset, import.media_query_id)
 
       insert_position = import.id
       imported_sheet.rules.each_with_index do |rule, idx|
@@ -1324,15 +1370,16 @@ module Cataract
       merge_media_query_lists!(imported_sheet.media_query_lists, mq_id_offset: mq_id_offset)
     end
 
-    # Rebase every imported rule/at-rule's media_query_id onto this
-    # stylesheet's own @media_queries (now that the imported sheet's own
-    # media queries have been merged in), then, if the @import statement
-    # itself had a media qualifier, combine it with (or assign it to) each
-    # rule's media context.
+    # Rebase every imported rule/at-rule's media_query_id and
+    # conditional_group_id onto this stylesheet's own @media_queries/
+    # @conditional_groups (now that the imported sheet's own copies have
+    # been merged in), then, if the @import statement itself had a media
+    # qualifier, combine it with (or assign it to) each rule's media
+    # context.
     #
     # @return [void]
-    def rebase_imported_rules_media_query!(imported_rules, mq_id_offset, import_media_query_id)
-      imported_rules.each { |rule| rebase_rule!(rule, rule_id_offset: 0, mq_id_offset: mq_id_offset) }
+    def rebase_imported_rules!(imported_rules, mq_id_offset, cg_id_offset, import_media_query_id)
+      imported_rules.each { |rule| rebase_rule!(rule, rule_id_offset: 0, mq_id_offset: mq_id_offset, cg_id_offset: cg_id_offset) }
 
       return unless import_media_query_id
 

data/lib/cataract/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cataract
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cataract
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - James Cook
@@ -29,6 +29,7 @@ files:
 - ".overcommit.yml"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
+- ".yardopts"
 - BENCHMARKS.md
 - CHANGELOG.md
 - Gemfile
@@ -69,6 +70,7 @@ files:
 - lib/cataract.rb
 - lib/cataract/at_rule.rb
 - lib/cataract/color_conversion.rb
+- lib/cataract/conditional_group.rb
 - lib/cataract/constants.rb
 - lib/cataract/declaration.rb
 - lib/cataract/declarations.rb