Shave nst yak

clcss-tests.asd

@@ -1,8 +1,13 @@
 ;; -*- mode: Lisp;  -*-
 (asdf:defsystem #:clcss-tests
-  :serial t
   :depends-on (#:clcss
                #:nst)
+
   :components ((:module "tests"
                 :components ((:file "package")
-                             (:file "tests" :depends-on ("package"))))))
+
+                             (:file "helpers" :depends-on ("package"))
+                             (:file "groups" :depends-on ("package"))
+
+                             (:module "tests" :depends-on ("helpers" "groups") :components
+                                      ((:file "parse")))))))

src/clcss.lisp

@@ -21,22 +21,23 @@
 (defun transform-css-path (path)
   (flet ((paren-syms (s)
            "Replace all symbols as CSS sees them with (:word symbol) to separate compund statements"
-                  (ppcre:regex-replace-all "([\\w_-]+)" s
-                                           "(:word \\1)"))
+           (ppcre:regex-replace-all "([\\w_-]+)" s
+                                    "(:word \\1)"))
 
          (group-compound (s)
            "Wrap groups of lists joined by a non-space into lists. e.g.:
              (:word p)#(:word my-p) => (:compound (:word p)#(:word my-p))"
-           (ppcre:regex-replace-all "(\\([^\\(]+?\\)[^\\w_-\\s]\\([^\\(]+?\\))+" s
+           (ppcre:regex-replace-all "(\\([^\\(]+?\\)[^\\w_\\s-]\\([^\\(]+?\\))+" s
                                     "(:compound \\1)"))
+
          (dot-to-bang (s)
            "Convert . to ! for lazy parsing"
            (ppcre:regex-replace-all "\\." s
                                     "!")))
 
-  (reduce #'(lambda (res proc) (funcall proc res))
-          (list #'paren-syms #'group-compound #'dot-to-bang)
-          :initial-value path)))
+    (reduce #'(lambda (res proc) (funcall proc res))
+            (list #'dot-to-bang #'paren-syms #'group-compound)
+            :initial-value path)))
 
 
 (defun read-css (path)

tests/groups.lisp

@@ -0,0 +1,12 @@
+(in-package :clcss-tests)
+
+;; Groups
+(def-test-group parse-tests ()
+  (:documentation "Tests basics of CSS string parsing"))
+
+;; Root Group
+(def-test-group all-tests ()
+  (:documentation "Root of the test tree")
+  (:include-groups parse-tests))
+
+

tests/helpers.lisp

@@ -0,0 +1,21 @@
+(in-package :clcss-tests)
+
+;; Helpers
+(defgeneric is-word (form)
+  (:method ((form list))
+    (is-word (car form)))
+  (:method ((form symbol))
+    (equal form :word)))
+
+;; Criteria
+(def-criterion-alias (:is-word) '(:predicate is-word))
+
+(def-criterion-alias (:word value) `(:seq :is-word
+                                          (:equal ,value)))
+
+(def-criterion-alias (:id value) `(:seq (:equal :id)
+                                        (:word ,value)))
+
+(def-criterion-alias (:class value) `(:seq (:equal :class)
+                                           (:word ,value)))
+

tests/tests/parse.lisp

@@ -0,0 +1,41 @@
+(in-package :clcss-tests)
+
+;; Old test data, using as reference
+;; TODO: Remove when cases are covered
+(defparameter *css-tests* `("h1" "div span" "div span p#poop" "ul#nav"
+                            "#my-id" ".my-class" "div#body" "div.my-class" ".indent p"))
+
+;; Tests
+(def-test (can-parse-nothing-to-nothing :group parse-tests)
+    (:not :true)
+  (read-css ""))
+
+(def-test (can-parse-simple-element :group parse-tests)
+    (:seq (:word :h1))
+  (read-css "h1"))
+
+(def-test (can-parse-nested-elements :group parse-tests)
+    (:seq (:word :div)
+          (:word :span))
+  (read-css "div span"))
+
+(def-test (can-parse-compound-tag-with-id :group parse-tests)
+    (:seq (:seq (:equal :compound)
+                (:word :ul)
+                (:id :nav)))
+  (read-css "ul#nav"))
+
+(def-test (can-parse-just-id :group parse-tests)
+    (:seq (:id :my-id))
+  (read-css "#my-id"))
+
+(def-test (can-parse-just-class :group parse-tests)
+    (:seq (:class :my-class))
+  (read-css ".my-class"))
+
+(def-test (can-parse-tag-with-id-and-class :group parse-tests)
+    (:seq (:seq (:equal :compound)
+                (:word :div)
+                (:id :wrap)
+                (:class :main)))
+  (read-css "div#wrap.main"))