Implements common css parser rules

Author: zmoazeni

lib/csscss.rb

@@ -11,3 +11,5 @@
 require "csscss/redundancy_analyzer"
 require "csscss/reporter"
 require "csscss/json_reporter"
+
+require "csscss/parser/common"

lib/csscss/parser/common.rb

@@ -0,0 +1,42 @@
+module Csscss
+  module Parser
+    module Common
+      include Parslet
+
+      rule(:spaces)  { match["\s"].repeat }
+      rule(:number)  { match["0-9"] }
+      rule(:numbers) { number.repeat(1) }
+      rule(:percent) { numbers >> (str(".") >> numbers).maybe >> symbol("%") }
+      rule(:inherit) { stri("inherit") }
+
+      def stri(str)
+        key_chars = str.split(//)
+        key_chars.
+          collect! { |char|
+            if char.upcase == char.downcase
+              str(char)
+            else
+              match["#{char.upcase}#{char.downcase}"]
+            end
+          }.reduce(:>>)
+      end
+
+      def symbol(s, label = nil)
+        if label
+          stri(s).as(label) >> spaces
+        else
+          stri(s) >> spaces
+        end
+      end
+
+      def between(left, right)
+        raise "block not given" unless block_given?
+        symbol(left) >> yield >> symbol(right)
+      end
+
+      def parens(&block)
+        between("(", ")", &block)
+      end
+    end
+  end
+end

test/csscss/parser/common_test.rb

@@ -0,0 +1,81 @@
+require "test_helper"
+
+module Csscss::Parser
+  describe Common do
+    class CommonTest
+      include Common
+    end
+
+    before { @parser = CommonTest.new }
+
+    describe "#stri" do
+      it "parses case insensitive strings" do
+        @parser.stri("a").must_parse "a"
+        @parser.stri("A").must_parse "a"
+        @parser.stri("A").must_not_parse "b"
+
+        @parser.stri("This too shall pass").must_parse "this TOO shall PASS"
+        @parser.stri("[").must_parse "["
+      end
+    end
+
+    describe "#spaces" do
+      it "parses series of spaces" do
+        @parser.spaces.must_parse ""
+        @parser.spaces.must_parse " "
+        @parser.spaces.must_parse "  "
+        @parser.spaces.must_not_parse "  a"
+      end
+    end
+
+    describe "#symbol" do
+      it "parses case insensitive characters followed by spaces" do
+        @parser.symbol("foo").must_parse "foo"
+        @parser.symbol("foo").must_parse "foo  "
+        @parser.symbol("foo").must_parse "Foo  "
+        @parser.symbol("foo").must_not_parse " Foo  "
+      end
+
+      it "optionally captures input" do
+        parsed = @parser.symbol("foo", :foo).parse("Foo  ")
+        parsed[:foo].must_equal "Foo"
+      end
+    end
+
+    describe "parens and between" do
+      it "parses input surrounded by parens" do
+        @parser.parens { @parser.symbol("foo") }.must_parse "(foo)"
+        @parser.parens { @parser.symbol("foo") }.must_parse "(FOo)  "
+        @parser.parens { @parser.symbol("foo") }.must_parse "(FOo  )  "
+        @parser.parens { @parser.symbol("food") }.must_not_parse "(FOo"
+      end
+
+      it "parses characters surrounded" do
+        @parser.between("[", "]") { @parser.symbol("foo") }.must_parse "[foo]"
+      end
+    end
+
+    describe "number and numbers" do
+      it "parses single numbers" do
+        @parser.number.must_parse "1"
+        @parser.number.must_not_parse "12"
+        @parser.number.must_not_parse "a"
+        @parser.number.must_not_parse "1 "
+      end
+
+      it "parses multiple numbers" do
+        @parser.numbers.must_parse "1"
+        @parser.numbers.must_parse "12"
+        @parser.numbers.must_not_parse "12 "
+        @parser.numbers.must_not_parse "1223a"
+      end
+
+      it "parses percentages" do
+        @parser.percent.must_parse "100%"
+        @parser.percent.must_parse "100% "
+        @parser.percent.must_parse "100.344%"
+        @parser.percent.must_not_parse "100 %"
+      end
+    end
+  end
+end

test/test_helper.rb

@@ -21,5 +21,24 @@ def cmatch(selectors, decs)
   end
 end
 
+module MiniTest::Assertions
+  def assert_parse(parser, string)
+    assert parser.parse(string)
+  rescue Parslet::ParseFailed => ex
+    assert false, ex.cause.ascii_tree
+  end
+
+  def assert_not_parse(parser, string)
+    parser.parse(string)
+    assert false, "expected #{parser} to not successfully parse \"#{string}\" and it did"
+  rescue Parslet::ParseFailed => ex
+    assert ex
+  end
+end
+
+Parslet::Atoms::DSL.infect_an_assertion :assert_parse, :must_parse, :do_not_flip
+Parslet::Atoms::DSL.infect_an_assertion :assert_not_parse, :must_not_parse, :do_not_flip
+
 Debugger.settings[:autoeval] = true
 Debugger.settings[:autolist] = 1
+