caps 0.1.0

data/lib/caps/parser/entrypoints.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Caps
+  class Parser
+    module Entrypoints
+      using Caps::Parser::Helpers
+
+      def parse_full_sheet
+        base = parse_stylesheet
+        base[:value].map! do |obj|
+          if obj[:type] == :qualified_rule
+            p = Parser.new(obj.dig(:block, :value))
+            obj[:block][:value] = p.parse_style_block_contents
+          elsif obj[:type] == :at_rule && obj.dig(:name, :value).downcase == "font-face"
+            p = Parser.new(obj.dig(:block, :value))
+            obj[:block][:value] = p.parse_declaration_list
+          end
+          obj
+        end
+
+        base
+      end
+
+      def parse_stylesheet(location: nil)
+        {
+          type: :stylesheet,
+          location:,
+          value: consume_list_of_rules(top_level: true)
+        }
+      end
+
+      def parse_rule_list
+        consume_list_of_rules(top_level: false)
+      end
+
+      def parse_rule
+        consume_whitespace
+        val = peek
+        if val.eof?
+          # EOF. Raise syntax error.
+          syntax_error! "Unexpected EOF"
+        end
+
+        ret_val = if val.at_rule?
+          consume_at_rule
+        else
+          consume_qualified_rule
+        end
+
+        consume_whitespace
+
+        syntax_error! "Expected EOF, found #{peek.type} instead" unless peek.eof?
+
+        ret_val
+      end
+
+      def parse_declaration
+        consume_whitespace
+        syntax_error! "Unexpected #{peek.type}, expected ident" unless peek.ident?
+
+        consume_declaration.tap do |decl|
+          syntax_error! "Expected declaration to be consumed" if decl.nil?
+        end
+      end
+
+      def parse_style_block_contents
+        consume_style_block_contents
+      end
+
+      def parse_declaration_list
+        consume_declaration_list
+      end
+
+      def parse_component_value
+        consume_whitespace
+        syntax_error! "Unexpected EOF" if peek.eof?
+
+        ret_val = consume_component_value
+        consume_whitespace
+        return ret_val if peek.eof?
+
+        syntax_error! "Expected EOF"
+      end
+
+      def parse_component_value_list
+        arr = []
+        loop do
+          obj = consume_component_value
+          break if obj.eof?
+
+          arr << obj
+        end
+        arr
+      end
+
+      def parse_comma_separated_component_values
+        cvls = []
+
+        loop do
+          cv = consume_component_value
+          if cv.comma?
+            next
+          elsif cv.eof?
+            break
+          end
+
+          cvls << cv
+        end
+
+        cvls
+      end
+    end
+  end
+end

data/lib/caps/parser/helpers.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Caps
+  class Parser
+    module Helpers
+      refine Hash do
+        def self.helper(name, &)
+          define_method(name, &)
+        end
+
+        def self.tassert(tname)
+          helper("#{tname}?".to_sym) { type == tname }
+        end
+
+        def start_line
+          dig(:position, :start, :line)
+        end
+
+        def start_column
+          dig(:position, :start, :column)
+        end
+
+        def end_column
+          dig(:position, :end, :column)
+        end
+
+        def end_line
+          dig(:position, :end, :line)
+        end
+
+        def type
+          self[:type]
+        end
+
+        def value
+          self[:value]
+        end
+
+        tassert(:eof)
+        tassert(:ident)
+        tassert(:whitespace)
+        tassert(:at_keyword)
+        tassert(:comma)
+        tassert(:semicolon)
+        tassert(:left_curly)
+        tassert(:delim)
+        tassert(:colon)
+        tassert(:bang)
+        tassert(:left_square)
+        tassert(:right_square)
+        tassert(:left_parens)
+        tassert(:right_parens)
+        tassert(:function)
+        tassert(:at_rule)
+        tassert(:cdo)
+        tassert(:cdc)
+      end
+
+      refine NilClass do
+        def self.helper(name, &)
+          define_method(name, &)
+        end
+
+        def self.tassert(tname)
+          helper("#{tname}?") { false }
+        end
+
+        def type
+          :eof
+        end
+
+        def eof?
+          true
+        end
+
+        tassert(:ident)
+        tassert(:whitespace)
+        tassert(:at_keyword)
+        tassert(:comma)
+        tassert(:semicolon)
+        tassert(:left_curly)
+        tassert(:delim)
+        tassert(:colon)
+        tassert(:bang)
+        tassert(:left_square)
+        tassert(:right_square)
+        tassert(:left_parens)
+        tassert(:right_square)
+        tassert(:function)
+        tassert(:at_rule)
+        tassert(:cdo)
+        tassert(:cdc)
+      end
+    end
+  end
+end

data/lib/caps/parser/infra.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "helpers"
+
+module Caps
+  class Parser
+    using Caps::Parser::Helpers
+
+    def initialize(tokens)
+      @tokens = tokens
+      @idx = 0
+    end
+
+    def peek
+      return nil if @idx >= @tokens.length
+
+      @tokens[@idx]
+    end
+
+    def prev
+      return @tokens.first if @idx.zero?
+
+      @tokens[@idx - 1]
+    end
+
+    def advance
+      return nil if peek.nil?
+
+      peek.tap { @idx += 1 }
+    end
+
+    def consume_whitespace
+      advance while peek.whitespace?
+    end
+
+    def tracking
+      start = peek.dig(:position, :start)
+      result = yield
+      finish = prev.dig(:position, :end)
+      result.merge({
+        position: {
+          start:,
+          end: finish
+        }
+      })
+    end
+
+    def syntax_error!(reason)
+      token = peek.nil? ? prev : peek
+      raise "Syntax Error: #{reason} at line #{token.end_line} " \
+            "column #{token.end_column}"
+    end
+  end
+end

data/lib/caps/parser.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "parser/infra"
+require_relative "parser/helpers"
+require_relative "parser/entrypoints"
+require_relative "parser/consumers"
+
+module Caps
+  class Parser
+    using Caps::Parser::Helpers
+    include Caps::Parser::Consumers
+    include Caps::Parser::Entrypoints
+  end
+end

data/lib/caps/tokenizer/helpers.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Caps
+  class Tokenizer
+    module Helpers
+      refine String do
+        def self.helper(name, &)
+          define_method(name, &)
+        end
+
+        helper(:uni) { unpack1("U") }
+        helper(:between?) { |a, b| uni >= a && uni <= b }
+        helper(:digit?) { between? 0x30, 0x39 }
+        helper(:hex?) { digit? || between?(0x41, 0x46) || between?(0x61, 0x66) }
+        helper(:uppercase?) { between? 0x41, 0x5a }
+        helper(:lowercase?) { between? 0x61, 0x7a }
+        helper(:letter?) { uppercase? || lowercase? }
+
+        def non_ascii?
+          uni == 0xb7 ||
+            between?(0xc0, 0xd6) ||
+            between?(0xd8, 0xf6) ||
+            between?(0xf8, 0x37d) ||
+            between?(0x37f, 0x1fff) ||
+            uni == 0x200c ||
+            uni == 0x200d ||
+            uni == 0x203f ||
+            uni == 0x2040 ||
+            between?(0x2070, 0x218f) ||
+            between?(0x2c00, 0x2fef) ||
+            between?(0x3001, 0xd7ff) ||
+            between?(0xf900, 0xfdcf) ||
+            between?(0xfdf0, 0xfffd) ||
+            uni >= 0x10000
+        end
+
+        helper(:ident_start?) { letter? || non_ascii? || uni == 0x5f }
+        helper(:ident_char?) { ident_start? || digit? || uni == 0x2d }
+        helper(:non_printable?) { between?(0x00, 0x08) || uni == 0xb || between?(0xe, 0x1f) || uni == 0x7f }
+        helper(:newline?) { uni == 0xa }
+        helper(:whitespace?) { newline? || uni == 0x9 || uni == 0x20 }
+        helper(:bad_escape?) { newline? }
+        helper(:surrogate?) { between?(0xd800, 0xdfff) }
+      end
+
+      refine NilClass do
+        def self.helper(name, &)
+          define_method(name, &)
+        end
+
+        helper(:uni) { 0x00 }
+        helper(:between?) { |_a, _b| false }
+        helper(:digit?) { false }
+        helper(:hex?) { false }
+        helper(:uppercase?) { false }
+        helper(:lowercase?) { false }
+        helper(:letter?) { false }
+        helper(:non_ascii?) { false }
+        helper(:ident_start?) { false }
+        helper(:ident_char?) { false }
+        helper(:non_printable?) { false }
+        helper(:newline?) { false }
+        helper(:whitespace?) { false }
+        helper(:bad_escape?) { false }
+        helper(:surrogate?) { false }
+      end
+    end
+  end
+end

data/lib/caps/tokenizer/infra.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Caps
+  class Tokenizer
+    using Caps::Tokenizer::Helpers
+    attr_accessor :contents, :tokens
+
+    def self.parse(src)
+      new(src).parse!
+    end
+
+    def initialize(contents)
+      @contents = self.class.preprocess(contents)
+      setup
+    end
+
+    def parse!
+      consume_token until eof?
+      @tokens
+    end
+
+    def pos
+      { idx: @idx, line: @line, column: @column }
+    end
+
+    private
+
+    def self.preprocess(contents)
+      codepoints = []
+      clusters = contents.grapheme_clusters
+      i = 0
+      until i == clusters.length
+        code = clusters[i]
+
+        if code.uni == 0x0d && clusters[i + 1].uni == 0x0a
+          codepoints << LINE_FEED
+          i += 1
+          next
+        end
+
+        code = LINE_FEED if code.uni == 0x0d || code.uni == 0x0c
+
+        code = REPLACEMENT_CHARACTER if code.between?(0xd800, 0xdbff) || code.between?(0xdc00, 0xdfff) || code.uni.zero?
+
+        codepoints << code
+        i += 1
+      end
+
+      codepoints
+    end
+
+    def setup
+      @idx = 0
+      @len = @contents.length
+      @line = 1
+      @column = 1
+      @last_line_length = 0
+      @tokens = []
+    end
+
+    def eof?
+      @idx >= @contents.length
+    end
+
+    def peek(qty = 0)
+      return nil if @idx + qty >= @len
+
+      @contents[@idx + qty]
+    end
+
+    def peek1
+      peek(1)
+    end
+
+    def peek2
+      peek(2)
+    end
+
+    def advance
+      chr = @contents[@idx]
+      @idx += 1
+      if @idx > @len
+        raise "[BUG] Over-read! @idx=#{@idx} @len=#{@len} #advance without #peek or #eof?\n#{Thread.current.backtrace.reject do |v|
+                                                                                               v.start_with?("/opt") || v.start_with?("/usr")
+                                                                                             end.join("\n")}"
+      end
+
+      return chr if eof?
+
+      if @contents[@idx].newline?
+        @line += 1
+        @last_line_length = @column
+        @column = 1
+      else
+        @column += 1
+      end
+
+      chr
+    end
+
+    def scoped
+      start = @idx
+      yield
+      @contents[start...@idx]
+    end
+
+    def isolated
+      old = pos
+      begin
+        yield
+      ensure
+        @idx = old[:idx]
+        @line = old[:line]
+        @column = old[:column]
+      end
+    end
+
+    def mark_pos
+      Location.new(self)
+    end
+
+    def pack_while(type)
+      start = mark_pos
+      data = scoped do
+        loop do
+          break if !yield || eof?
+
+          advance
+        end
+      end
+
+      start.push_node(type, value: data.join)
+    end
+
+    def pack_one(type)
+      pack = true
+      pack_while(type) { pack.tap { pack = !pack } }
+    end
+
+    def valid_escape?(offset: 0)
+      check = -> { peek == REVERSE_SOLIDUS && peek1 != LINE_FEED }
+      if offset.positive?
+        isolated do
+          offset.times { advance }
+          check.call
+        end
+      else
+        check.call
+      end
+    end
+
+    def ident_sequence_start?
+      case peek
+      when HYPHEN_MINUS
+        (peek1.ident_start? || peek1 == HYPHEN_MINUS) || valid_escape?(offset: 1)
+      when REVERSE_SOLIDUS
+        valid_escape?
+      else
+        peek.ident_start?
+      end
+    end
+  end
+end

data/lib/caps/tokenizer/location.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Caps
+  class Tokenizer
+    class Location
+      attr_reader :start
+
+      def initialize(parser)
+        @parser = parser
+        @start = parser.pos
+      end
+
+      def push_node(type, **opts)
+        @parser.push_node(type, **opts.merge({ position: finish }))
+      end
+
+      def finish
+        {
+          start: @start,
+          end: @parser.pos
+        }
+      end
+    end
+  end
+end