cataract 0.2.2 → 0.2.4

data/lib/cataract/stylesheet_scope.rb

@@ -131,10 +131,8 @@ module Cataract
 
       # Get base rules set
       rules = if @filters[:base_only]
-                # Get rules not in any media query
-                media_index = @stylesheet.instance_variable_get(:@_media_index)
-                media_rule_ids = media_index.values.flatten.uniq
-                @stylesheet.rules.select.with_index { |_rule, idx| !media_rule_ids.include?(idx) }
+                # Get rules not in any media query (media_query_id is nil)
+                @stylesheet.rules.select { |r| r.is_a?(Rule) && r.media_query_id.nil? }
               elsif @filters[:media]
                 media_array = Array(@filters[:media])
 
@@ -142,9 +140,14 @@ module Cataract
                 if media_array.include?(:all)
                   @stylesheet.rules
                 else
-                  media_index = @stylesheet.instance_variable_get(:@_media_index)
-                  rule_ids = media_array.flat_map { |m| media_index[m] || [] }.uniq
-                  rule_ids.map { |id| @stylesheet.rules[id] }
+                  # Use media_index for efficient lookup (it handles compound media queries)
+                  matching_rule_ids = Set.new
+                  media_array.each do |media_sym|
+                    rule_ids = @stylesheet.media_index[media_sym]
+                    matching_rule_ids.merge(rule_ids) if rule_ids
+                  end
+                  # Filter rules by ID
+                  @stylesheet.rules.select { |r| matching_rule_ids.include?(r.id) }
                 end
               else
                 @stylesheet.rules

data/lib/cataract/version.rb

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

data/lib/cataract.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
 require_relative 'cataract/version'
+require_relative 'cataract/constants'
 
 # Load struct definitions first (before C extension or pure Ruby)
 require_relative 'cataract/declaration'
 require_relative 'cataract/rule'
 require_relative 'cataract/at_rule'
+require_relative 'cataract/media_query'
 require_relative 'cataract/import_statement'
 
 # Load pure Ruby or C extension based on ENV var
@@ -73,14 +75,8 @@ module Cataract
     # @see Stylesheet#parse
     # @see Stylesheet.parse
     unless method_defined?(:parse_css)
-      def parse_css(css, imports: false)
-        # Pass import options to Stylesheet.parse
-        # The new flow: parse first (extract @import), then resolve them
-        if imports
-          Stylesheet.parse(css, import: imports)
-        else
-          Stylesheet.parse(css)
-        end
+      def parse_css(css, **options)
+        Stylesheet.parse(css, **options)
       end
     end
 

data/lib/tasks/profile.rake

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+namespace :profile do
+  desc 'Profile pure Ruby parser with bootstrap.css (outputs JSON for speedscope)'
+  task :parsing do
+    require 'fileutils'
+
+    # Check for stackprof
+    begin
+      require 'stackprof'
+    rescue LoadError
+      abort('stackprof gem not found. Install with: gem install stackprof')
+    end
+
+    # Ensure we're using pure Ruby implementation
+    ENV['CATARACT_PURE'] = '1'
+
+    fixture_path = File.expand_path('../../test/fixtures/bootstrap.css', __dir__)
+    unless File.exist?(fixture_path)
+      abort("Fixture not found: #{fixture_path}")
+    end
+
+    output_dir = 'tmp/profile'
+    FileUtils.mkdir_p(output_dir)
+    json_output = File.join(output_dir, 'stackprof-parsing.json')
+
+    puts 'Profiling pure Ruby parser with bootstrap.css'
+    puts '=' * 80
+    puts "Fixture: #{fixture_path}"
+    puts "Output:  #{json_output}"
+    puts '=' * 80
+
+    # Load the CSS content
+    css_content = File.read(fixture_path)
+    puts "CSS size: #{css_content.bytesize} bytes"
+    puts
+
+    require_relative '../../lib/cataract/pure'
+    require 'json'
+
+    # Use higher sampling rate (interval in microseconds, default is 1000)
+    # Lower interval = higher sampling rate = more detailed profile
+    profile = StackProf.run(mode: :wall, raw: true, interval: 100) do
+      # Parse multiple times to get better signal
+      100.times do
+        Cataract.parse_css(css_content)
+      end
+    end
+
+    # Write JSON output
+    File.write(json_output, JSON.generate(profile))
+
+    puts
+    puts 'Profile complete!'
+    puts "JSON output: #{json_output}"
+    puts
+    puts 'View in speedscope:'
+    puts '  1. Visit https://www.speedscope.app/'
+    puts "  2. Drag and drop: #{json_output}"
+    puts
+    puts 'Or use stackprof CLI:'
+    puts "  stackprof #{json_output} --text"
+    puts "  stackprof #{json_output} --method 'Cataract'"
+  end
+
+  desc 'Profile pure Ruby flatten with bootstrap.css (outputs JSON for speedscope)'
+  task :flatten do
+    require 'fileutils'
+
+    # Check for stackprof
+    begin
+      require 'stackprof'
+    rescue LoadError
+      abort('stackprof gem not found. Install with: gem install stackprof')
+    end
+
+    fixture_path = File.expand_path('../../test/fixtures/bootstrap.css', __dir__)
+    unless File.exist?(fixture_path)
+      abort("Fixture not found: #{fixture_path}")
+    end
+
+    output_dir = 'tmp/profile'
+    FileUtils.mkdir_p(output_dir)
+    json_output = File.join(output_dir, 'stackprof-flatten.json')
+
+    puts 'Profiling pure Ruby flatten with bootstrap.css'
+    puts '=' * 80
+    puts "Fixture: #{fixture_path}"
+    puts "Output:  #{json_output}"
+    puts '=' * 80
+
+    # Load the CSS content
+    css_content = File.read(fixture_path)
+    puts "CSS size: #{css_content.bytesize} bytes"
+    puts
+
+    require_relative '../../lib/cataract/pure'
+    require 'json'
+
+    # Parse once outside profiling to get stylesheet
+    stylesheet = Cataract.parse_css(css_content)
+    puts "Parsed: #{stylesheet.rules.size} rules"
+    puts
+
+    # Profile flatten only
+    # Use higher sampling rate (interval in microseconds, default is 1000)
+    # Lower interval = higher sampling rate = more detailed profile
+    profile = StackProf.run(mode: :wall, raw: true, interval: 100) do
+      # Flatten multiple times to get better signal
+      100.times do
+        Cataract.flatten(stylesheet.dup)
+      end
+    end
+
+    # Write JSON output
+    File.write(json_output, JSON.generate(profile))
+
+    puts
+    puts 'Profile complete!'
+    puts "JSON output: #{json_output}"
+    puts
+    puts 'View in speedscope:'
+    puts '  1. Visit https://www.speedscope.app/'
+    puts "  2. Drag and drop: #{json_output}"
+    puts
+    puts 'Or use stackprof CLI:'
+    puts "  stackprof #{json_output} --text"
+    puts "  stackprof #{json_output} --method 'Cataract'"
+  end
+
+  desc 'Profile pure Ruby serialization with bootstrap.css (outputs JSON for speedscope)'
+  task :serialization do
+    require 'fileutils'
+
+    # Check for stackprof
+    begin
+      require 'stackprof'
+    rescue LoadError
+      abort('stackprof gem not found. Install with: gem install stackprof')
+    end
+
+    # Ensure we're using pure Ruby implementation
+    ENV['CATARACT_PURE'] = '1'
+
+    fixture_path = File.expand_path('../../test/fixtures/bootstrap.css', __dir__)
+    unless File.exist?(fixture_path)
+      abort("Fixture not found: #{fixture_path}")
+    end
+
+    output_dir = 'tmp/profile'
+    FileUtils.mkdir_p(output_dir)
+    json_output = File.join(output_dir, 'stackprof-serialization.json')
+
+    puts 'Profiling pure Ruby serialization with bootstrap.css'
+    puts '=' * 80
+    puts "Fixture: #{fixture_path}"
+    puts "Output:  #{json_output}"
+    puts '=' * 80
+
+    # Load the CSS content
+    css_content = File.read(fixture_path)
+    puts "CSS size: #{css_content.bytesize} bytes"
+    puts
+
+    require_relative '../../lib/cataract/pure'
+    require 'json'
+
+    # Parse once outside profiling to get stylesheet
+    stylesheet = Cataract.parse_css(css_content)
+    puts "Parsed: #{stylesheet.rules.size} rules"
+    puts
+
+    # Profile serialization only (to_s)
+    # Use higher sampling rate (interval in microseconds, default is 1000)
+    # Lower interval = higher sampling rate = more detailed profile
+    profile = StackProf.run(mode: :wall, raw: true, interval: 100) do
+      # Serialize multiple times to get better signal
+      100.times do
+        stylesheet.dup.to_s
+      end
+    end
+
+    # Write JSON output
+    File.write(json_output, JSON.generate(profile))
+
+    puts
+    puts 'Profile complete!'
+    puts "JSON output: #{json_output}"
+    puts
+    puts 'View in speedscope:'
+    puts '  1. Visit https://www.speedscope.app/'
+    puts "  2. Drag and drop: #{json_output}"
+    puts
+    puts 'Or use stackprof CLI:'
+    puts "  stackprof #{json_output} --text"
+    puts "  stackprof #{json_output} --method 'Cataract'"
+  end
+end
+
+desc 'Profile pure Ruby parser, flatten, and serialization (outputs JSON for speedscope)'
+task profile: ['profile:parsing', 'profile:flatten', 'profile:serialization'] do
+  puts
+  puts '=' * 80
+  puts 'All profiles complete!'
+  puts 'Artifacts in: tmp/profile/'
+  puts '  - stackprof-parsing.json'
+  puts '  - stackprof-flatten.json'
+  puts '  - stackprof-serialization.json'
+  puts '=' * 80
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cataract
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.4
 platform: ruby
 authors:
 - James Cook
@@ -80,15 +80,16 @@ files:
 - lib/cataract.rb
 - lib/cataract/at_rule.rb
 - lib/cataract/color_conversion.rb
+- lib/cataract/constants.rb
 - lib/cataract/declaration.rb
 - lib/cataract/declarations.rb
 - lib/cataract/import_resolver.rb
 - lib/cataract/import_statement.rb
+- lib/cataract/media_query.rb
 - lib/cataract/pure.rb
 - lib/cataract/pure/byte_constants.rb
 - lib/cataract/pure/flatten.rb
 - lib/cataract/pure/helpers.rb
-- lib/cataract/pure/imports.rb
 - lib/cataract/pure/parser.rb
 - lib/cataract/pure/serializer.rb
 - lib/cataract/pure/specificity.rb
@@ -97,6 +98,7 @@ files:
 - lib/cataract/stylesheet_scope.rb
 - lib/cataract/version.rb
 - lib/tasks/gem.rake
+- lib/tasks/profile.rake
 homepage: https://github.com/jamescook/cataract
 licenses:
 - MIT

data/lib/cataract/pure/imports.rb

@@ -1,268 +0,0 @@
-# frozen_string_literal: true
-
-# Pure Ruby CSS parser - Import extraction
-# NO REGEXP ALLOWED - char-by-char parsing only
-
-module Cataract
-  # Helper: Case-insensitive ASCII byte comparison
-  # Compares bytes at given position with ASCII pattern (case-insensitive)
-  # Safe to use even if position is in middle of multi-byte UTF-8 characters
-  # Returns true if match, false otherwise
-  def self.match_ascii_ci?(str, pos, pattern)
-    pattern_len = pattern.bytesize
-    return false if pos + pattern_len > str.bytesize
-
-    i = 0
-    while i < pattern_len
-      str_byte = str.getbyte(pos + i)
-      pat_byte = pattern.getbyte(i)
-
-      # Convert both to lowercase for comparison (ASCII only: A-Z -> a-z)
-      str_byte += BYTE_CASE_DIFF if str_byte >= BYTE_UPPER_A && str_byte <= BYTE_UPPER_Z
-      pat_byte += BYTE_CASE_DIFF if pat_byte >= BYTE_UPPER_A && pat_byte <= BYTE_UPPER_Z
-
-      return false if str_byte != pat_byte
-
-      i += 1
-    end
-
-    true
-  end
-
-  # Extract @import statements from CSS
-  #
-  # @param css_string [String] CSS to scan for @imports
-  # @return [Array<Hash>] Array of import hashes with :url, :media, :full_match
-  def self.extract_imports(css_string)
-    imports = []
-
-    i = 0
-    len = css_string.length
-
-    while i < len
-      # Skip whitespace and comments
-      while i < len
-        byte = css_string.getbyte(i)
-        if is_whitespace?(byte)
-          i += 1
-        elsif i + 1 < len && css_string.getbyte(i) == BYTE_SLASH && css_string.getbyte(i + 1) == BYTE_STAR
-          # Skip /* */ comment
-          i += 2
-          while i + 1 < len && !(css_string.getbyte(i) == BYTE_STAR && css_string.getbyte(i + 1) == BYTE_SLASH)
-            i += 1
-          end
-          i += 2 if i + 1 < len # Skip */
-        else
-          break
-        end
-      end
-
-      break if i >= len
-
-      # Check for @import (case-insensitive byte comparison)
-      if match_ascii_ci?(css_string, i, '@import')
-        import_start = i
-        i += 7
-
-        # Skip whitespace after @import
-        while i < len && is_whitespace?(css_string.getbyte(i))
-          i += 1
-        end
-
-        # Check for optional url( (case-insensitive byte comparison)
-        has_url_function = false
-        if match_ascii_ci?(css_string, i, 'url(')
-          has_url_function = true
-          i += 4
-          while i < len && is_whitespace?(css_string.getbyte(i))
-            i += 1
-          end
-        end
-
-        # Find opening quote
-        byte = css_string.getbyte(i) if i < len
-        if i >= len || (byte != BYTE_DQUOTE && byte != BYTE_SQUOTE)
-          # Invalid @import, skip to next semicolon
-          while i < len && css_string.getbyte(i) != BYTE_SEMICOLON
-            i += 1
-          end
-          i += 1 if i < len # Skip semicolon
-          next
-        end
-
-        quote_char = byte
-        i += 1 # Skip opening quote
-
-        url_start = i
-
-        # Find closing quote (handle escaped quotes)
-        while i < len && css_string.getbyte(i) != quote_char
-          if css_string.getbyte(i) == BYTE_BACKSLASH && i + 1 < len
-            i += 2 # Skip escaped character
-          else
-            i += 1
-          end
-        end
-
-        break if i >= len # Unterminated string
-
-        url_end = i
-        i += 1 # Skip closing quote
-
-        # Skip closing paren if we had url(
-        if has_url_function
-          while i < len && is_whitespace?(css_string.getbyte(i))
-            i += 1
-          end
-          if i < len && css_string.getbyte(i) == BYTE_RPAREN
-            i += 1
-          end
-        end
-
-        # Skip whitespace before optional media query or semicolon
-        while i < len && is_whitespace?(css_string.getbyte(i))
-          i += 1
-        end
-
-        # Check for optional media query (everything until semicolon)
-        media_start = nil
-        media_end = nil
-
-        if i < len && css_string.getbyte(i) != BYTE_SEMICOLON
-          media_start = i
-
-          # Find semicolon
-          while i < len && css_string.getbyte(i) != BYTE_SEMICOLON
-            i += 1
-          end
-
-          media_end = i
-
-          # Trim trailing whitespace from media query
-          while media_end > media_start && is_whitespace?(css_string.getbyte(media_end - 1))
-            media_end -= 1
-          end
-        end
-
-        # Skip semicolon
-        i += 1 if i < len && css_string.getbyte(i) == BYTE_SEMICOLON
-
-        import_end = i
-
-        # Build result hash
-        url = css_string[url_start...url_end]
-        media = media_start && media_end > media_start ? css_string[media_start...media_end] : nil
-        full_match = css_string[import_start...import_end]
-
-        imports << { url: url, media: media, full_match: full_match }
-      elsif match_ascii_ci?(css_string, i, '@charset')
-        # Skip @charset if present - it can come before @import
-        while i < len && css_string.getbyte(i) != BYTE_SEMICOLON
-          i += 1
-        end
-        i += 1 if i < len # Skip semicolon
-      else
-        # If we hit any other content (rules, other at-rules), stop scanning
-        # Per CSS spec, @import must be at the top (only @charset can come before)
-        byte = css_string.getbyte(i) if i < len
-        if i < len && !is_whitespace?(byte)
-          break
-        end
-
-        i += 1
-      end
-    end
-
-    imports
-  end
-
-  # Parse media query symbol into array of media types
-  #
-  # @param media_query_sym [Symbol] Media query as symbol (e.g., :screen, :"print, screen")
-  # @return [Array<Symbol>] Array of individual media types
-  #
-  # @example
-  #   parse_media_types(:screen) #=> [:screen]
-  #   parse_media_types(:"print, screen") #=> [:print, :screen]
-  def self.parse_media_types(media_query_sym)
-    query = media_query_sym.to_s
-    types = []
-
-    i = 0
-    len = query.length
-
-    kwords = %w[and or not only]
-
-    while i < len
-      # Skip whitespace
-      while i < len && is_whitespace?(query.getbyte(i))
-        i += 1
-      end
-      break if i >= len
-
-      # Check for opening paren - skip conditions like "(min-width: 768px)"
-      if query.getbyte(i) == BYTE_LPAREN
-        # Skip to matching closing paren
-        paren_depth = 1
-        i += 1
-        while i < len && paren_depth > 0
-          byte = query.getbyte(i)
-          if byte == BYTE_LPAREN
-            paren_depth += 1
-          elsif byte == BYTE_RPAREN
-            paren_depth -= 1
-          end
-          i += 1
-        end
-        next
-      end
-
-      # Find end of word (media type or keyword)
-      word_start = i
-      byte = query.getbyte(i)
-      while i < len && !is_whitespace?(byte) && byte != BYTE_COMMA && byte != BYTE_LPAREN && byte != BYTE_COLON
-        i += 1
-        byte = query.getbyte(i) if i < len
-      end
-
-      if i > word_start
-        word = query[word_start...i]
-
-        # Check if this is a media feature (followed by ':')
-        is_media_feature = (i < len && query.getbyte(i) == BYTE_COLON)
-
-        # Check if it's a keyword (and, or, not, only)
-        is_keyword = kwords.include?(word)
-
-        if !is_keyword && !is_media_feature
-          # This is a media type - add it as symbol
-          types << word.to_sym
-        end
-      end
-
-      # Skip to comma or end
-      while i < len && query.getbyte(i) != BYTE_COMMA
-        if query.getbyte(i) == BYTE_LPAREN
-          # Skip condition
-          paren_depth = 1
-          i += 1
-          while i < len && paren_depth > 0
-            byte = query.getbyte(i)
-            if byte == BYTE_LPAREN
-              paren_depth += 1
-            elsif byte == BYTE_RPAREN
-              paren_depth -= 1
-            end
-            i += 1
-          end
-        else
-          i += 1
-        end
-      end
-
-      i += 1 if i < len && query.getbyte(i) == BYTE_COMMA # Skip comma
-    end
-
-    types
-  end
-end