renamed make-covered? symboles

info.rkt

@@ -4,7 +4,7 @@
 (define deps '("base" "errortrace-lib" "rackunit-lib"
                "syntax-color-lib"))
 (define build-deps
-  '("racket-doc" "scribble-lib"))
+  '("racket-doc" "scribble-lib" "typed-racket-doc"))
 
 (define raco-commands
   '(("cover" (submod cover/raco main) "a code coverage tool" 30)))

main.rkt

@@ -12,7 +12,7 @@
    (-> file-coverage/c path-string?
        (->* (exact-positive-integer?)
             (#:byte? boolean?)
-            (or/c 'yes 'no 'missing)))]
+            (or/c 'covered 'uncovered 'irrelevant)))]
   [generate-coveralls-coverage coverage-gen/c]
   [generate-html-coverage coverage-gen/c]
   [generate-raw-coverage coverage-gen/c]))

private/coveralls.rkt

@@ -120,20 +120,20 @@
   (define file-coverage (hash-ref coverage file))
   (define (process-coverage value rst-of-line)
     (case (covered? value)
-      ['yes (if (equal? 'no rst-of-line) rst-of-line 'yes)]
-      ['no 'no]
+      ['covered (if (equal? 'uncovered rst-of-line) rst-of-line 'covered)]
+      ['uncovered 'uncovered]
       [else rst-of-line]))
   (define (process-coverage-value value)
     (case value
-      ['yes 1]
-      ['no 0]
+      ['covered 1]
+      ['uncovered 0]
       [else (json-null)]))
 
   (define-values (line-cover _)
     (for/fold ([coverage '()] [count 1]) ([line split-src])
       (cond [(zero? (string-length line)) (values (cons (json-null) coverage) (add1 count))]
             [else (define nw-count (+ count (string-length line) 1))
-                  (define all-covered (foldr process-coverage 'missing (range count nw-count)))
+                  (define all-covered (foldr process-coverage 'irrelevant (range count nw-count)))
                   (values (cons (process-coverage-value all-covered) coverage) nw-count)])))
   (reverse line-cover))
 

private/format-utils.rkt

@@ -18,7 +18,7 @@
 
 ;;;;; utils
 
-;;; a Cover is (U 'yes 'no 'missing)
+;;; a Cover is (U 'covered 'uncovered 'irrelevant)
 
 ;; [Hashof PathString [Hashof Natural Cover]]
 
@@ -47,7 +47,7 @@
      (define cache
        (for/hash ([i (range 1 (add1 file-length))])
          (values i
-                 (cond [(irrelevant? i) 'missing]
+                 (cond [(irrelevant? i) 'irrelevant]
                        [else (raw-covered? i c)]))))
      cache)))
 
@@ -113,9 +113,9 @@
              (values m start)
              (values mode last-start))])))
   (case mode
-    [(#t) 'yes]
-    [(#f) 'no]
-    [else 'missing]))
+    [(#t) 'covered]
+    [(#f) 'uncovered]
+    [else 'irrelevant]))
 
 ;; use for determining character/byte offsets for a given
 ;; 1 indexed character location
@@ -146,14 +146,14 @@
    (test-files! f)
    (define coverage (hash-ref (get-test-coverage) f))
    (define covered? (make-covered? coverage f))
-   (check-equal? (covered? 14) 'missing)
-   (check-equal? (covered? 14 #:byte? #t) 'missing)
-   (check-equal? (covered? 17) 'missing)
-   (check-equal? (covered? 28) 'missing)
-   (check-equal? (covered? 35) 'yes)
-   (check-equal? (covered? 50) 'no)
-   (check-equal? (covered? 51 #:byte? #t) 'no)
-   (check-equal? (covered? 52) 'missing)
-   (check-equal? (covered? 53) 'missing)
-   (check-equal? (covered? 54) 'missing)
+   (check-equal? (covered? 14) 'irrelevant)
+   (check-equal? (covered? 14 #:byte? #t) 'irrelevant)
+   (check-equal? (covered? 17) 'irrelevant)
+   (check-equal? (covered? 28) 'irrelevant)
+   (check-equal? (covered? 35) 'covered)
+   (check-equal? (covered? 50) 'uncovered)
+   (check-equal? (covered? 51 #:byte? #t) 'uncovered)
+   (check-equal? (covered? 52) 'irrelevant)
+   (check-equal? (covered? 53) 'irrelevant)
+   (check-equal? (covered? 54) 'irrelevant)
    (clear-coverage!)))

private/html.rkt

@@ -175,9 +175,9 @@
 (define (mode-xml mode body)
   (define class
     (case mode
-      [(yes) "covered"]
-      [(no) "uncovered"]
-      [(missing) "missing"]))
+      [(covered) "covered"]
+      [(uncovered) "uncovered"]
+      [(irrelevant) "irrelevant"]))
   `(span ((class ,class)) ,body))
 
 (module+ test
@@ -198,7 +198,7 @@
           ,@(for/list ([l (rest (string-split (file->string f) "\n"))])
               `(li ()
                 ,@(for/list ([c l])
-                    `(span ((class ,(if (equal? c #\space) "missing" "covered")))
+                    `(span ((class ,(if (equal? c #\space) "irrelevant" "covered")))
                       ,(encode-char c))))))))
 
 
@@ -247,10 +247,10 @@
     (values (e->n e) (a->n e)))
   (define (a->n e)
     (case (is-covered? e)
-      [(yes no) 1]
+      [(covered uncovered) 1]
       [else 0]))
   (define (e->n e)
-    (if (eq? (is-covered? e) 'yes) 1 0))
+    (if (eq? (is-covered? e) 'covered) 1 0))
   (define-values (covered count)
     (let recur ([e e])
       (syntax-parse e

private/main.css

@@ -10,4 +10,4 @@
     color:green;
 }
 
-.missing {}
+.irrelevant {}

scribblings/api.scrbl

@@ -39,7 +39,7 @@ Test coverage info is added to existing coverage info.}
 @defproc[(make-covered? (coverage file-coverage/c) (path path-string?))
          (->* (exact-positive-integer?)
               (#:byte? boolean?)
-              (or/c 'yes 'no 'missing))
+              (or/c 'covered 'uncovered 'irrelevant))
          ]{
 Given some location in a file and the
 coverage information for that file @racket[make-covered?] returns
@@ -47,11 +47,12 @@ a functions that determines if some @racket[1] indexed character or byte locatio
 in that file is covered. By default it checks character locations.
 
 There are three possible results:
-@itemize[@item{@racket['missing] --- The location is not considered relevant to coverage information.
-It might be in a submodule or lexes (in the sense of that languages
+@itemize[@item{@racket['irrelevant] --- The location is not considered relevant to coverage information.
+It is either not in the coverage information, is in a submodule, or lexes (in the sense of that languages
 @racket[_color-lexer]) as a comment or whitespace.}
-@item{@racket['yes] --- The location is not @racket['missing] and is
-covered} @item{@racket['no] --- The location is not @racket['missing]
+@item{@racket['covered] --- The location is not @racket['irrelevant] and is
+covered}
+@item{@racket['uncovered] --- The location is not @racket['uncovered]
 and is not covered}]
                                    }