clucumber 0.1.1 → 0.2.0

data/lib/clucumber/vendor/cl-ppcre/charmap.lisp

@@ -0,0 +1,152 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/charmap.lisp,v 1.19 2009/09/17 19:17:30 edi Exp $
+
+;;; An optimized representation of sets of characters.
+
+;;; Copyright (c) 2008-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre)
+
+(defstruct (charmap  (:constructor make-charmap%))
+  ;; a bit vector mapping char codes to "booleans" (1 for set members,
+  ;; 0 for others)
+  (vector #*0 :type simple-bit-vector)
+  ;; the smallest character code of all characters in the set
+  (start 0 :type fixnum)
+  ;; the upper (exclusive) bound of all character codes in the set
+  (end 0 :type fixnum)
+  ;; the number of characters in the set, or NIL if this is unknown
+  (count nil :type (or fixnum null))
+  ;; whether the charmap actually represents the complement of the set  
+  (complementp nil :type boolean))
+
+;; seems to be necessary for some Lisps like ClozureCL
+(defmethod make-load-form ((map charmap) &optional environment)
+  (make-load-form-saving-slots map :environment environment))
+
+(declaim (inline in-charmap-p))
+(defun in-charmap-p (char charmap)
+  "Tests whether the character CHAR belongs to the set represented by CHARMAP."
+  (declare #.*standard-optimize-settings*)
+  (declare (character char) (charmap charmap))
+  (let* ((char-code (char-code char))
+         (char-in-vector-p
+          (let ((charmap-start (charmap-start charmap)))
+            (declare (fixnum charmap-start))
+            (and (<= charmap-start char-code)
+                 (< char-code (the fixnum (charmap-end charmap)))
+                 (= 1 (sbit (the simple-bit-vector (charmap-vector charmap))
+                            (- char-code charmap-start)))))))
+    (cond ((charmap-complementp charmap) (not char-in-vector-p))
+          (t char-in-vector-p))))
+
+(defun charmap-contents (charmap)
+  "Returns a list of all characters belonging to a character map.
+Only works for non-complement charmaps."
+  (declare #.*standard-optimize-settings*)
+  (declare (charmap charmap))
+  (and (not (charmap-complementp charmap))
+       (loop for code of-type fixnum from (charmap-start charmap) to (charmap-end charmap)
+             for i across (the simple-bit-vector (charmap-vector charmap))
+             when (= i 1)
+             collect (code-char code))))
+
+(defun make-charmap (start end test-function &optional complementp)
+  "Creates and returns a charmap representing all characters with
+character codes in the interval [start end) that satisfy
+TEST-FUNCTION.  The COMPLEMENTP slot of the charmap is set to the
+value of the optional argument, but this argument doesn't have an
+effect on how TEST-FUNCTION is used."
+  (declare #.*standard-optimize-settings*)
+  (declare (fixnum start end))
+  (let ((vector (make-array (- end start) :element-type 'bit))
+        (count 0))
+    (declare (fixnum count))
+    (loop for code from start below end
+          for char = (code-char code)
+          for index from 0
+          when char do
+          (incf count)
+          (setf (sbit vector index) (if (funcall test-function char) 1 0)))
+    (make-charmap% :vector vector
+                   :start start
+                   :end end
+                   ;; we don't know for sure if COMPLEMENTP is true as
+                   ;; there isn't a necessary a character for each
+                   ;; integer below *REGEX-CHAR-CODE-LIMIT*
+                   :count (and (not complementp) count)
+                   ;; make sure it's boolean
+                   :complementp (not (not complementp)))))
+
+(defun create-charmap-from-test-function (test-function start end)
+  "Creates and returns a charmap representing all characters with
+character codes between START and END which satisfy TEST-FUNCTION.
+Tries to find the smallest interval which is necessary to represent
+the character set and uses the complement representation if that
+helps."
+  (declare #.*standard-optimize-settings*)
+  (let (start-in end-in start-out end-out)
+    ;; determine the smallest intervals containing the set and its
+    ;; complement, [start-in, end-in) and [start-out, end-out) - first
+    ;; the lower bound
+    (loop for code from start below end
+          for char = (code-char code)
+          until (and start-in start-out)
+          when (and char
+                    (not start-in)
+                    (funcall test-function char))
+          do (setq start-in code)
+          when (and char
+                    (not start-out)
+                    (not (funcall test-function char)))
+          do (setq start-out code))
+    (unless start-in
+      ;; no character satisfied the test, so return a "pseudo" charmap
+      ;; where IN-CHARMAP-P is always false
+      (return-from create-charmap-from-test-function
+        (make-charmap% :count 0)))
+    (unless start-out
+      ;; no character failed the test, so return a "pseudo" charmap
+      ;; where IN-CHARMAP-P is always true
+      (return-from create-charmap-from-test-function
+        (make-charmap% :complementp t)))
+    ;; now determine upper bound
+    (loop for code from (1- end) downto start
+          for char = (code-char code)
+          until (and end-in end-out)
+          when (and char
+                    (not end-in)
+                    (funcall test-function char))
+          do (setq end-in (1+ code))
+          when (and char
+                    (not end-out)
+                    (not (funcall test-function char)))
+          do (setq end-out (1+ code)))
+    ;; use the smaller interval
+    (cond ((<= (- end-in start-in) (- end-out start-out))
+           (make-charmap start-in end-in test-function))
+          (t (make-charmap start-out end-out (complement* test-function) t)))))

data/lib/clucumber/vendor/cl-ppcre/charset.lisp

@@ -0,0 +1,242 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/charset.lisp,v 1.10 2009/09/17 19:17:30 edi Exp $
+
+;;; A specialized set implementation for characters by Nikodemus Siivola.
+
+;;; Copyright (c) 2008, Nikodemus Siivola. All rights reserved.
+;;; Copyright (c) 2008-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre)
+
+(defconstant +probe-depth+ 3
+  "Maximum number of collisions \(for any element) we accept before we
+allocate more storage.  This is now fixed, but could be made to vary
+depending on the size of the storage vector \(e.g. in the range of
+1-4).  Larger probe-depths mean more collisions are tolerated before
+the table grows, but increase the constant factor.")
+
+(defun make-char-vector (size)
+  "Returns a vector of size SIZE to hold characters.  All elements are
+initialized to #\Null except for the first one which is initialized to
+#\?."
+  (declare #.*standard-optimize-settings*)
+  (declare (type (integer 2 #.(1- array-total-size-limit)) size))
+  ;; since #\Null always hashes to 0, store something else there
+  ;; initially, and #\Null everywhere else
+  (let ((result (make-array size
+                            :element-type #-:lispworks 'character #+:lispworks 'lw:simple-char
+                            :initial-element (code-char 0))))
+    (setf (char result 0) #\?)
+    result))
+
+(defstruct (charset (:constructor make-charset ()))
+  ;; this is set to 0 when we stop hashing and just use a CHAR-CODE
+  ;; indexed vector
+  (depth +probe-depth+ :type fixnum)
+  ;; the number of characters in this set
+  (count 0 :type fixnum)
+  ;; the storage vector
+  (vector (make-char-vector 12) :type (simple-array character (*))))
+
+;; seems to be necessary for some Lisps like ClozureCL
+(defmethod make-load-form ((set charset) &optional environment)
+  (make-load-form-saving-slots set :environment environment))
+
+(declaim (inline mix))
+(defun mix (code hash)
+  "Given a character code CODE and a hash code HASH, computes and
+returns the \"next\" hash code.  See comments below."
+  (declare #.*standard-optimize-settings*)
+  ;; mixing the CHAR-CODE back in at each step makes sure that if two
+  ;; characters collide (their hashes end up pointing in the same
+  ;; storage vector index) on one round, they should (hopefully!) not
+  ;; collide on the next
+  (sxhash (logand most-positive-fixnum (+ code hash))))
+
+(declaim (inline compute-index))
+(defun compute-index (hash vector)
+  "Computes and returns the index into the vector VECTOR corresponding
+to the hash code HASH."
+  (declare #.*standard-optimize-settings*)
+  (1+ (mod hash (1- (length vector)))))
+
+(defun in-charset-p (char set)
+  "Checks whether the character CHAR is in the charset SET."
+  (declare #.*standard-optimize-settings*)
+  (declare (character char) (charset set))
+  (let ((vector (charset-vector set))
+        (depth (charset-depth set))
+        (code (char-code char)))
+    (declare (fixnum depth))
+    ;; as long as the set remains reasonably small, we use non-linear
+    ;; hashing - the first hash of any character is its CHAR-CODE, and
+    ;; subsequent hashes are computed by MIX above
+    (cond ((or
+            ;; depth 0 is special - each char maps only to its code,
+            ;; nothing else
+            (zerop depth)
+            ;; index 0 is special - only #\Null maps to it, no matter
+            ;; what the depth is
+            (zerop code))
+           (eq char (char vector code)))
+          (t
+           ;; otherwise hash starts out as the character code, but
+           ;; maps to indexes 1-N
+           (let ((hash code))
+             (tagbody
+              :retry
+              (let* ((index (compute-index hash vector))
+                     (x (char vector index)))
+                (cond ((eq x (code-char 0))
+                       ;; empty, no need to probe further
+                       (return-from in-charset-p nil))
+                      ((eq x char)
+                       ;; got it
+                       (return-from in-charset-p t))
+                      ((zerop (decf depth))
+                       ;; max probe depth reached, nothing found
+                       (return-from in-charset-p nil))
+                      (t
+                       ;; nothing yet, try next place
+                       (setf hash (mix code hash))
+                       (go :retry))))))))))
+
+(defun add-to-charset (char set)
+  "Adds the character CHAR to the charset SET, extending SET if
+necessary.  Returns CHAR."
+  (declare #.*standard-optimize-settings*)
+  (or (%add-to-charset char set t)
+      (%add-to-charset/expand char set)
+      (error "Oops, this should not happen..."))
+  char)
+
+(defun %add-to-charset (char set count)
+  "Tries to add the character CHAR to the charset SET without
+extending it.  Returns NIL if this fails.  Counts CHAR as new
+if COUNT is true and it is added to SET."
+  (declare #.*standard-optimize-settings*)
+  (declare (character char) (charset set))
+  (let ((vector (charset-vector set))
+        (depth (charset-depth set))
+        (code (char-code char)))
+    (declare (fixnum depth))
+    ;; see comments in IN-CHARSET-P for algorithm
+    (cond ((or (zerop depth) (zerop code))
+           (unless (eq char (char vector code))
+             (setf (char vector code) char)
+             (when count
+               (incf (charset-count set))))
+           char)
+          (t
+           (let ((hash code))
+             (tagbody
+              :retry
+              (let* ((index (compute-index hash vector))
+                     (x (char vector index)))
+                (cond ((eq x (code-char 0))
+                       (setf (char vector index) char)
+                       (when count
+                         (incf (charset-count set)))
+                       (return-from %add-to-charset char))
+                      ((eq x char)
+                       (return-from %add-to-charset char))
+                      ((zerop (decf depth))
+                       ;; need to expand the table
+                       (return-from %add-to-charset nil))
+                      (t
+                       (setf hash (mix code hash))
+                       (go :retry))))))))))
+
+(defun %add-to-charset/expand (char set)
+  "Extends the charset SET and then adds the character CHAR to it."
+  (declare #.*standard-optimize-settings*)
+  (declare (character char) (charset set))
+  (let* ((old-vector (charset-vector set))
+         (new-size (* 2 (length old-vector))))
+    (tagbody
+     :retry
+     ;; when the table grows large (currently over 1/3 of
+     ;; CHAR-CODE-LIMIT), we dispense with hashing and just allocate a
+     ;; storage vector with space for all characters, so that each
+     ;; character always uses only the CHAR-CODE
+     (multiple-value-bind (new-depth new-vector)
+         (if (>= new-size #.(truncate char-code-limit 3))
+           (values 0 (make-char-vector char-code-limit))
+           (values +probe-depth+ (make-char-vector new-size)))
+       (setf (charset-depth set) new-depth
+             (charset-vector set) new-vector)
+       (flet ((try-add (x)
+                ;; don't count - old characters are already accounted
+                ;; for, and might count the new one multiple times as
+                ;; well
+                (unless (%add-to-charset x set nil)
+                  (assert (not (zerop new-depth)))
+                  (setf new-size (* 2 new-size))
+                  (go :retry))))
+         (try-add char)
+         (dotimes (i (length old-vector))
+           (let ((x (char old-vector i)))
+             (if (eq x (code-char 0))
+               (when (zerop i)
+                 (try-add x))
+               (unless (zerop i)
+                 (try-add x))))))))
+    ;; added and expanded, /now/ count the new character.
+    (incf (charset-count set))
+    t))
+
+(defun map-charset (function charset)
+  "Calls FUNCTION with all characters in SET.  Returns NIL."
+  (declare #.*standard-optimize-settings*)
+  (declare (function function))
+  (let* ((n (charset-count charset))
+         (vector (charset-vector charset))
+         (size (length vector)))
+    ;; see comments in IN-CHARSET-P for algorithm
+    (when (eq (code-char 0) (char vector 0))
+      (funcall function (code-char 0))
+      (decf n))
+    (loop for i from 1 below size
+          for char = (char vector i)
+          unless (eq (code-char 0) char) do
+          (funcall function char)
+          ;; this early termination test should be worth it when
+          ;; mapping across depth 0 charsets.
+          (when (zerop (decf n))
+            (return-from map-charset nil))))
+  nil)
+
+(defun create-charset-from-test-function (test-function start end)
+  "Creates and returns a charset representing all characters with
+character codes between START and END which satisfy TEST-FUNCTION."
+  (declare #.*standard-optimize-settings*)
+  (loop with charset = (make-charset)
+        for code from start below end
+        for char = (code-char code)
+        when (and char (funcall test-function char))
+        do (add-to-charset char charset)
+        finally (return charset)))

data/lib/clucumber/vendor/cl-ppcre/chartest.lisp

@@ -0,0 +1,98 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/chartest.lisp,v 1.5 2009/09/17 19:17:30 edi Exp $
+
+;;; Copyright (c) 2008-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre)
+
+(defun create-hash-table-from-test-function (test-function start end)
+  "Creates and returns a hash table representing all characters with
+character codes between START and END which satisfy TEST-FUNCTION."
+  (declare #.*standard-optimize-settings*)
+  (loop with hash-table = (make-hash-table)
+        for code from start below end
+        for char = (code-char code)
+        when (and char (funcall test-function char))
+        do (setf (gethash char hash-table) t)
+        finally (return hash-table)))
+
+(defun create-optimized-test-function (test-function &key
+                                                     (start 0)
+                                                     (end *regex-char-code-limit*)
+                                                     (kind *optimize-char-classes*))
+  "Given a unary test function which is applicable to characters
+returns a function which yields the same boolean results for all
+characters with character codes from START to \(excluding) END.  If
+KIND is NIL, TEST-FUNCTION will simply be returned.  Otherwise, KIND
+should be one of:
+
+* :HASH-TABLE - builds a hash table representing all characters which
+                satisfy the test and returns a closure which checks if
+                a character is in that hash table
+
+* :CHARSET - instead of a hash table uses a \"charset\" which is a
+             data structure using non-linear hashing and optimized to
+             represent \(sparse) sets of characters in a fast and
+             space-efficient way \(contributed by Nikodemus Siivola)
+
+* :CHARMAP - instead of a hash table uses a bit vector to represent
+             the set of characters
+
+You can also use :HASH-TABLE* or :CHARSET* which are like :HASH-TABLE
+and :CHARSET but use the complement of the set if the set contains
+more than half of all characters between START and END.  This saves
+space but needs an additional pass across all characters to create the
+data structure.  There is no corresponding :CHARMAP* kind as the bit
+vectors are already created to cover the smallest possible interval
+which contains either the set or its complement."
+  (declare #.*standard-optimize-settings*)
+  (ecase kind
+    ((nil) test-function)
+    (:charmap
+     (let ((charmap (create-charmap-from-test-function test-function start end)))
+       (lambda (char)
+         (in-charmap-p char charmap))))
+    ((:charset :charset*)
+     (let ((charset (create-charset-from-test-function test-function start end)))
+       (cond ((or (eq kind :charset)
+                  (<= (charset-count charset) (ceiling (- end start) 2)))
+              (lambda (char)
+                (in-charset-p char charset)))
+             (t (setq charset (create-charset-from-test-function (complement* test-function)
+                                                                 start end))
+                (lambda (char)
+                  (not (in-charset-p char charset)))))))
+    ((:hash-table :hash-table*)
+     (let ((hash-table (create-hash-table-from-test-function test-function start end)))
+       (cond ((or (eq kind :hash-table)
+                  (<= (hash-table-count hash-table) (ceiling (- end start) 2)))
+              (lambda (char)
+                (gethash char hash-table)))
+             (t (setq hash-table (create-hash-table-from-test-function (complement* test-function)
+                                                                       start end))
+                (lambda (char)
+                  (not (gethash char hash-table)))))))))

data/lib/clucumber/vendor/cl-ppcre/cl-ppcre-test.asd

@@ -0,0 +1,34 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/cl-ppcre-test.asd,v 1.14 2008/06/25 14:04:27 edi Exp $
+
+;;; This ASDF system definition was kindly provided by Marco Baringer.
+
+;;; Copyright (c) 2002-2008, Dr. Edmund Weitz.  All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(asdf:defsystem :cl-ppcre-test
+  :depends-on (:cl-ppcre)
+  :components ((:file "ppcre-tests")))

data/lib/clucumber/vendor/cl-ppcre/cl-ppcre-unicode/packages.lisp

@@ -0,0 +1,38 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-USER; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/cl-ppcre-unicode/packages.lisp,v 1.3 2009/09/17 19:17:34 edi Exp $
+
+;;; Copyright (c) 2002-2009, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-user)
+
+(defpackage :cl-ppcre-unicode
+  #+:genera
+  (:shadowing-import-from :common-lisp :lambda :string)
+  (:use #-:genera :cl #+:genera :future-common-lisp
+        :cl-ppcre :cl-unicode)
+  (:import-from :cl-ppcre :signal-syntax-error)
+  (:export :unicode-property-resolver))

data/lib/clucumber/vendor/cl-ppcre/cl-ppcre-unicode/resolver.lisp

@@ -0,0 +1,61 @@
+;;; -*- Mode: LISP; Syntax: COMMON-LISP; Package: CL-PPCRE; Base: 10 -*-
+;;; $Header: /usr/local/cvsrep/cl-ppcre/cl-ppcre-unicode/resolver.lisp,v 1.5 2008/07/23 02:14:08 edi Exp $
+
+;;; Copyright (c) 2008, Dr. Edmund Weitz. All rights reserved.
+
+;;; Redistribution and use in source and binary forms, with or without
+;;; modification, are permitted provided that the following conditions
+;;; are met:
+
+;;;   * Redistributions of source code must retain the above copyright
+;;;     notice, this list of conditions and the following disclaimer.
+
+;;;   * Redistributions in binary form must reproduce the above
+;;;     copyright notice, this list of conditions and the following
+;;;     disclaimer in the documentation and/or other materials
+;;;     provided with the distribution.
+
+;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED
+;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+;;; ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(in-package :cl-ppcre-unicode)
+
+(defun unicode-property-resolver (property-name)
+  "A property resolver which understands Unicode properties using
+CL-UNICODE's PROPERTY-TEST function.  This resolver is automatically
+installed in *PROPERTY-RESOLVER* when the CL-PPCRE-UNICODE system is
+loaded."
+  (or (property-test property-name :errorp nil)
+      (signal-syntax-error "There is no property named ~S." property-name)))
+
+(setq *property-resolver* 'unicode-property-resolver)
+
+(pushnew :cl-ppcre-unicode *features*)
+
+;; stuff for Nikodemus Siivola's HYPERDOC
+;; see <http://common-lisp.net/project/hyperdoc/>
+;; and <http://www.cliki.net/hyperdoc>
+;; also used by LW-ADD-ONS
+
+(defvar *hyperdoc-base-uri* "http://weitz.de/cl-ppcre/")
+
+(let ((exported-symbols-alist
+       (loop for symbol being the external-symbols of :cl-ppcre-unicode
+             collect (cons symbol
+                           (concatenate 'string
+                                        "#"
+                                        (string-downcase symbol))))))
+  (defun hyperdoc-lookup (symbol type)
+    (declare (ignore type))
+    (cdr (assoc symbol
+                exported-symbols-alist
+                :test #'eq))))