Mon Jan 4 01:07:02 UTC 2010 pix@kepibu.org

* subject-p makes more sense as (selector, element)

For future reference, I used the following code to do this automatically, plus a

few minor manual edits (e.g., swapping rcurry and curry):

(defun seek-forward (term)

(let ((p (search-forward term nil t)))

(when p

(goto-char p))))

(defun swap-args ()

(interactive)

(save-excursion

(while (seek-forward "defmethod subject-p (")

(forward-sexp)

(transpose-sexps 1)))

(save-excursion

(while (seek-forward "(subject-p")

(forward-sexp)

(transpose-sexps 1))))

--- old-Oh, Ducks!/selectors.lisp 2015-11-25 15:38:21.000000000 +0000

+++ new-Oh, Ducks!/selectors.lisp 2015-11-25 15:38:21.000000000 +0000

@@ -109,15 +109,15 @@

(when (subject-p element selector) (list element))

(subjects-in-list selector (element-children element))))

-(defgeneric subject-p (element selector))

+(defgeneric subject-p (selector element))

-(defmethod subject-p (element (selector type-selector))

+(defmethod subject-p ((selector type-selector) element)

(element-type-equal element (selector-arg selector)))

-(defmethod subject-p (element (selector id-selector))

+(defmethod subject-p ((selector id-selector) element)

(string= (element-id element) (selector-arg selector)))

-(defmethod subject-p (element (selector nth-child-selector))

+(defmethod subject-p ((selector nth-child-selector) element)

(when-let* ((parent (element-parent element))

(pos (position element (funcall (typecase selector

(nth-last-child-selector #'reverse)

@@ -134,42 +134,42 @@

(t (and (zerop (mod (- pos b) a))

(not (minusp (/ (- pos b) a)))))))))

-(defmethod subject-p (element (selector class-selector))

+(defmethod subject-p ((selector class-selector) element)

(member (selector-arg selector)

(element-classes element)

:test #'string=))

-(defmethod subject-p (element (selector universal-selector))

+(defmethod subject-p ((selector universal-selector) element)

(declare (ignore element selector))

t)

-(defmethod subject-p (element (selector %implicit-element-selector))

+(defmethod subject-p ((selector %implicit-element-selector) element)

(eq element *implicit-element*))

-(defmethod subject-p (element (selector list))

- (every (curry #'subject-p element) selector))

+(defmethod subject-p ((selector list) element)

+ (every (rcurry #'subject-p element) selector))

-(defmethod subject-p (element (selector child-combinator))

- (subject-p (element-parent element) (matcher selector)))

+(defmethod subject-p ((selector child-combinator) element)

+ (subject-p (matcher selector) (element-parent element)))

-(defmethod subject-p (element (selector descendant-combinator))

- (some (rcurry #'subject-p (matcher selector)) (element-ancestors element)))

+(defmethod subject-p ((selector descendant-combinator) element)

+ (some (curry #'subject-p (matcher selector)) (element-ancestors element)))

-(defmethod subject-p (element (selector adjacent-combinator))

+(defmethod subject-p ((selector adjacent-combinator) element)

(let* ((parent (element-parent element))

(siblings (element-children parent))

(ourpos (position element siblings :test #'eq)))

(and ourpos

(> ourpos 0)

- (subject-p (elt siblings (1- ourpos)) (matcher selector)))))

+ (subject-p (matcher selector) (elt siblings (1- ourpos))))))

-(defmethod subject-p (element (selector sibling-combinator))

+(defmethod subject-p ((selector sibling-combinator) element)

(let* ((parent (element-parent element))

(siblings (element-children parent))

(ourpos (position element siblings :test #'eq)))

(and ourpos

(> ourpos 0)

- (find-if (rcurry #'subject-p (matcher selector)) siblings :end ourpos))))

+ (find-if (curry #'subject-p (matcher selector)) siblings :end ourpos))))

;; Hello excessively long name

(defun terminating-implicit-sibling-combinator-p (selector)