minicss 0.1.0

data/lib/minicss/ast/syntax_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module MiniCSS
+  module AST
+    class SyntaxError
+      attr_reader :reason
+
+      def initialize(reason)
+        @reason = reason
+      end
+    end
+  end
+end

data/lib/minicss/ast/unicode_range.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module MiniCSS
+  module AST
+    class UnicodeRange
+      attr_accessor :range_start, :range_end
+
+      def initialize(css)
+        @range_start, @range_end = css.opts.slice(:start, :end).values
+      end
+    end
+  end
+end

data/lib/minicss/ast/url.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module MiniCSS
+  module AST
+    class URL
+      attr_accessor :value
+
+      def initialize(value)
+        @value = value
+      end
+    end
+  end
+end

data/lib/minicss/ast.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "ast/rule"
+require_relative "ast/decl"
+require_relative "ast/decl_list"
+require_relative "ast/at_rule"
+require_relative "ast/function"
+require_relative "ast/block"
+require_relative "ast/number"
+require_relative "ast/dimension"
+require_relative "ast/percentage"
+require_relative "ast/bad_token"
+require_relative "ast/url"
+require_relative "ast/unicode_range"
+require_relative "ast/syntax_error"
+require_relative "ast/string_token"
+
+module MiniCSS
+  module AST
+    module_function
+
+    def convert(css)
+      case css
+      when CSS::AST::Stylesheet
+        css.rules.map { convert(it) }
+      when CSS::AST::QualifiedRule
+        Rule.new(css)
+      when CSS::AST::Declaration
+        Decl.new(css)
+      when CSS::AST::AtRule
+        AtRule.new(css)
+      when CSS::AST::DeclarationList
+        DeclList.new(css.map { convert(it) })
+      when Array
+        css.map { convert(it) }
+      when CSS::AST::Function
+        Function.new(css)
+      when CSS::Token
+        convert_token(css)
+      when CSS::AST::SimpleBlock
+        Block.new(css)
+      when CSS::SyntaxError
+        SyntaxError.new(css.message)
+      else
+        raise "Unexpected input type #{css.class} for conversion"
+      end
+    end
+
+    def convert_token(css)
+      case css.kind
+      when :delim, :ident, :whitespace, :cdc, :at_keyword, :hash, :cdo, :colon, :comma, :semicolon, :right_square_bracket, :right_parenthesis
+        css.literal
+      when :dimension
+        Dimension.new(css)
+      when :number
+        Number.new(css)
+      when :percentage
+        Percentage.new(css)
+      when :bad_string, :bad_url
+        BadToken.new(css)
+      when :url
+        URL.new(css.opts[:value])
+      when :unicode_range
+        UnicodeRange.new(css)
+      when :string
+        StringToken.new(css)
+      else
+        raise "Unexpected token in conversion pipeline: #{css.class} #{css.inspect}"
+      end
+    end
+  end
+end

data/lib/minicss/css/ast/at_rule.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module MiniCSS
+  module CSS
+    module AST
+      class AtRule
+        attr_accessor :name, :prelude, :child_rules
+
+        def initialize(name:, prelude: nil, child_rules: nil)
+          @name = name
+          @prelude = prelude || []
+          @child_rules = child_rules || []
+        end
+
+        def kind = :at_rule
+      end
+    end
+  end
+end

data/lib/minicss/css/ast/declaration.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module MiniCSS
+  module CSS
+    module AST
+      class Declaration
+        attr_accessor :name, :value, :important, :original_text
+
+        def initialize(name: "", value: nil)
+          @value = value || []
+          @name = name
+          @important = false
+          @original_text = nil
+        end
+
+        def important? = @important
+        def kind = :declaration
+      end
+    end
+  end
+end

data/lib/minicss/css/ast/declaration_list.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module MiniCSS
+  module CSS
+    module AST
+      class DeclarationList < Array
+        def kind = :declaration_list
+      end
+    end
+  end
+end

data/lib/minicss/css/ast/function.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module MiniCSS
+  module CSS
+    module AST
+      class Function
+        attr_accessor :name, :value
+
+        def initialize(name: "", value: nil)
+          @value = value || []
+          @name = name
+        end
+
+        def kind = :function
+
+        def literal = [name.literal, value.map(&:literal)].join
+      end
+    end
+  end
+end

data/lib/minicss/css/ast/qualified_rule.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module MiniCSS
+  module CSS
+    module AST
+      class QualifiedRule
+        attr_accessor :prelude, :decls, :child_rules
+
+        def initialize(prelude: nil, decls: nil, child_rules: nil)
+          @prelude = prelude || []
+          @decls = decls || []
+          @child_rules = child_rules || []
+        end
+
+        def kind = :qualified_rule
+      end
+    end
+  end
+end

data/lib/minicss/css/ast/simple_block.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module MiniCSS
+  module CSS
+    module AST
+      class SimpleBlock
+        RIGHT_TOKENS = {
+          left_parenthesis: ")",
+          left_curly: "}",
+          left_square_bracket: "]"
+        }.freeze
+
+        LEFT_TOKENS = {
+          left_parenthesis: "(",
+          left_curly: "{",
+          left_square_bracket: "["
+        }.freeze
+
+        attr_accessor :associated_token, :value
+
+        def initialize(associated_token:)
+          @associated_token = associated_token
+          @value = []
+        end
+
+        def kind = :simple_block
+
+        def right_token = RIGHT_TOKENS[associated_token]
+        def left_token = LEFT_TOKENS[associated_token]
+
+        def literal
+          [left_token, @value.map(&:literal), right_token].join
+        end
+      end
+    end
+  end
+end

data/lib/minicss/css/ast/stylesheet.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module MiniCSS
+  module CSS
+    module AST
+      class Stylesheet
+        attr_accessor :rules
+
+        def initialize(rules: nil)
+          @rules = rules || []
+        end
+
+        def kind = :stylesheet
+      end
+    end
+  end
+end

data/lib/minicss/css/ast.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "ast/stylesheet"
+require_relative "ast/at_rule"
+require_relative "ast/qualified_rule"
+require_relative "ast/declaration"
+require_relative "ast/function"
+require_relative "ast/declaration_list"
+require_relative "ast/simple_block"

data/lib/minicss/css/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module MiniCSS
+  module CSS
+    class InvalidRuleError < Error; end
+    class SyntaxError < Error; end
+  end
+end

data/lib/minicss/css/parser.rb

@@ -0,0 +1,360 @@
+# frozen_string_literal: true
+
+module MiniCSS
+  module CSS
+    class Parser
+      using StringRefinements
+
+      attr_reader :stream
+
+      def initialize(tokens)
+        @stream = TokenStream.new(tokens)
+        @tokens = tokens
+      end
+
+      # Entrypoints
+
+      def parse_stylesheet
+        AST::Stylesheet.new(rules: consume_stylesheet_contents)
+      end
+
+      def parse_stylesheet_contents
+        consume_stylesheet_contents
+      end
+
+      def parse_block_contents
+        consume_block_contents
+      end
+
+      def parse_rule
+        stream.discard_whitespace
+        return SyntaxError.new("empty") if stream.empty?
+
+        result = if stream.peek.kind == :at_keyword
+          consume_at_rule
+        else
+          consume_qualified_rule
+        end
+        return SyntaxError.new("invalid") unless result
+
+        stream.discard_whitespace
+        return SyntaxError.new("extra-input") unless stream.empty?
+
+        result
+      end
+
+      def parse_declaration
+        stream.discard_whitespace
+        return SyntaxError.new("empty") if stream.empty?
+
+        decl = consume_declaration
+        return SyntaxError.new("invalid") unless decl
+
+        decl
+      end
+
+      def parse_component_value
+        stream.discard_whitespace
+        return SyntaxError.new("empty") if stream.empty?
+
+        value = consume_component_value
+        stream.discard_whitespace
+        return SyntaxError.new("extra-input") unless stream.empty?
+
+        value
+      end
+
+      def parse_component_value_list
+        consume_component_value_list
+      end
+
+      def parse_component_value_comma_list
+        groups = []
+        until stream.empty?
+          groups << consume_component_value_list(stop: :comma)
+          stream.discard
+        end
+        groups
+      end
+
+      # Helpers
+
+      def assert_next_token(kind)
+        stream.peek.kind == kind
+      end
+
+      # Parsers
+
+      def consume_stylesheet_contents
+        rules = []
+        loop do
+          case stream.peek.kind
+          when :whitespace, :cdo, :cdc
+            stream.discard
+
+          when :eof
+            return rules
+
+          when :at_keyword
+            rule = consume_at_rule
+            rules << rule if rule
+
+          else
+            rule = consume_qualified_rule
+            rules << rule if rule
+          end
+        end
+      end
+
+      def consume_at_rule(nested: false)
+        return unless assert_next_token(:at_keyword)
+
+        rule = AST::AtRule.new(name: stream.consume)
+        loop do
+          case stream.peek.kind
+          when :semicolon, :eof
+            stream.discard
+            # TODO: If rule is valid in the current context, return it; otherwise return nothing.
+            return rule
+
+          when :right_curly
+            if nested
+              # TODO: If rule is valid in the current context, return it. Otherwise, return nothing.
+              return rule
+            end
+
+            rule.prelude << consume
+
+          when :left_curly
+            consume_block.each { rule.child_rules << it }
+            return rule
+
+          else
+            rule.prelude << consume_component_value
+          end
+        end
+      end
+
+      def consume_qualified_rule(stop: nil, nested: false)
+        rule = AST::QualifiedRule.new
+
+        loop do
+          case stream.peek.kind
+          when :eof, stop
+            return nil
+
+          when :right_curly
+            return nil if nested
+
+            rule.prelude << consume
+
+          when :left_curly
+            non_ws = rule.prelude.reject { it.kind == :whitespace }
+            first, second = non_ws.first(2)
+
+            if first&.kind == :ident && first.literal.start_with?("--") && second&.kind == :colon
+              nested ? consume_bad_declaration : consume_block
+              return nil
+            end
+
+            child_rules = consume_block
+
+            rule.decls = child_rules.shift if child_rules&.first.is_a?(AST::DeclarationList)
+
+            # Replace declaration lists with nested declaration rules
+            rule.child_rules = child_rules.map do |item|
+              item.is_a?(AST::DeclarationList) ? AST::NestedDeclarationRules.new(child: item) : item
+            end
+
+            # TODO: If rule is valid in the current context, return it; otherwise
+            # return an invalid rule error.
+            return rule
+
+          else
+            rule.prelude << consume_component_value
+          end
+        end
+      end
+
+      def consume_block
+        return unless assert_next_token(:left_curly)
+
+        stream.discard
+        rules = consume_block_contents
+        stream.discard
+        rules
+      end
+
+      def consume_block_contents
+        rules = []
+        decls = AST::DeclarationList.new
+
+        loop do
+          case stream.peek.kind
+          when :whitespace, :semicolon
+            stream.discard
+          when :eof, :right_curly
+            rules << decls unless decls.empty?
+            return rules
+          when :at_keyword
+            unless decls.empty?
+              rules << decls
+              decls = AST::DeclarationList.new
+            end
+            at = consume_at_rule(nested: true)
+            rules << at if at.is_a? AST::AtRule
+          else
+            stream.mark
+            decl = consume_declaration(nested: true)
+            if decl.is_a? AST::Declaration
+              decls << decl
+              stream.pop
+              next
+            end
+
+            stream.restore
+            rule = consume_qualified_rule(nested: true)
+            if rule.is_a? InvalidRuleError
+              unless decls.empty?
+                rules << decls
+                decls = AST::DeclarationList.new
+              end
+            elsif rule.is_a? AST::QualifiedRule
+              unless decls.empty?
+                rules << decls
+                decls = AST::DeclarationList.new
+              end
+              rules << rule
+            end
+          end
+        end
+      end
+
+      def consume_declaration(nested: false)
+        decl = AST::Declaration.new
+        if stream.peek.kind == :ident
+          decl.name = stream.consume
+        else
+          consume_bad_declaration(nested:)
+          return nil
+        end
+
+        stream.discard_whitespace
+
+        if stream.peek.kind == :colon
+          stream.discard
+        else
+          consume_bad_declaration(nested:)
+          return nil
+        end
+
+        stream.discard_whitespace
+
+        decl.value = consume_component_value_list(nested:, stop: :semicolon)
+
+        l1, l2 = decl.value.reject { it.kind == :whitespace }.last(2)
+        if l1 && l2 && l1.kind == :delim && l1.literal == "!" && l2.kind == :ident && l2.literal.downcase == "important"
+          decl.value.delete(l1)
+          decl.value.delete(l2)
+          decl.important = true
+        end
+        decl.value.pop while decl.value.last&.kind == :whitespace
+        decl.original_text = decl.value.map(&:literal).join if decl.name.literal.start_with?("--")
+
+        # Otherwise, if decl’s value contains a top-level simple block
+        # with an associated token of <{-token>, and also contains any other
+        # non-<whitespace-token> value, return nothing. (That is, a top-level
+        # {}-block is only allowed as the entire value of a non-custom property.)
+        block = decl.value.find { it.is_a?(AST::SimpleBlock) && it.associated_token == :left_curly }
+        if block
+          invalid = decl.value.any? { it != block && it.kind != :whitespace }
+          return nil if invalid
+        end
+
+        decl
+      end
+
+      def consume_bad_declaration(nested:)
+        loop do
+          case stream.peek.kind
+          when :eof, :semicolon
+            stream.discard
+            return nil
+          when :right_curly
+            return if nested
+
+            stream.discard
+          else
+            consume_component_value
+          end
+        end
+      end
+
+      def consume_component_value_list(stop: nil, nested: false)
+        values = []
+        loop do
+          case stream.peek.kind
+          when :eof, stop
+            return values
+
+          when :right_curly
+            return values if nested
+
+            values << stream.consume
+
+          else
+            values << consume_component_value
+          end
+        end
+      end
+
+      def consume_component_value
+        case stream.peek.kind
+        when :left_curly, :left_square_bracket, :left_parenthesis
+          consume_simple_block
+        when :function
+          consume_function
+        else
+          stream.consume
+        end
+      end
+
+      def consume_simple_block
+        return if !assert_next_token(:left_curly) && !assert_next_token(:left_square_bracket) && !assert_next_token(:left_parenthesis)
+
+        block = AST::SimpleBlock.new(associated_token: stream.consume.kind)
+        ending_token = {
+          left_curly: :right_curly,
+          left_parenthesis: :right_parenthesis,
+          left_square_bracket: :right_square_bracket
+        }[block.associated_token]
+
+        loop do
+          case stream.peek.kind
+          when :eof, ending_token
+            stream.discard
+            return block
+          else
+            block.value << consume_component_value
+          end
+        end
+      end
+
+      def consume_function
+        return unless assert_next_token(:function)
+
+        func = AST::Function.new(name: stream.consume)
+
+        loop do
+          case stream.peek.kind
+          when :eof, :right_parenthesis
+            stream.discard
+            return func
+          else
+            func.value << consume_component_value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/minicss/css/position.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module MiniCSS
+  module CSS
+    class Position
+      attr_reader :offset, :line, :column
+
+      def initialize(offset, line, column)
+        @offset = offset
+        @line = line
+        @column = column
+      end
+    end
+  end
+end