[nongnu] elpa/d-mode b40a7ab 328/346: Unbundle undercover.el

[ELPA Syncer]

branch: elpa/d-mode
commit b40a7abd33d56ce20fbb51697d54f9cc68dcbb8d
Author: Vladimir Panteleev <git@thecybershadow.net>
Commit: Vladimir Panteleev <git@thecybershadow.net>

    Unbundle undercover.el
    
    Fixes #99.
---
 Cask                   |   3 +-
 coverage/undercover.el | 564 -------------------------------------------------
 d-mode-test.el         |   1 -
 3 files changed, 1 insertion(+), 567 deletions(-)

diff --git a/Cask b/Cask
index ef8cc9c..5336cec 100644
--- a/Cask
+++ b/Cask
@@ -2,5 +2,4 @@
 (source melpa)
 
 (development
- (depends-on "dash")
- (depends-on "shut-up"))
+ (depends-on "undercover"))
diff --git a/coverage/undercover.el b/coverage/undercover.el
deleted file mode 100644
index afd6624..0000000
--- a/coverage/undercover.el
+++ /dev/null
@@ -1,564 +0,0 @@
-;;; undercover.el --- Test coverage library for Emacs Lisp -*- 
lexical-binding: t -*-
-
-;; Copyright (c) 2014 Sviridov Alexander
-
-;; Author: Sviridov Alexander <sviridov.vmi@gmail.com>
-;; URL: https://github.com/sviridov/undercover.el
-;; Created: Sat Sep 27 2014
-;; Keywords: lisp, tests, coverage, tools
-;; Version: 0.6.1
-;; Package-Requires: ((emacs "24") (dash "2.0.0") (shut-up "0.3.2"))
-
-;;; Commentary:
-
-;; Provides a test coverage tools for Emacs packages.
-
-;;; Code:
-
-(eval-when-compile (require 'cl))
-
-(require 'edebug)
-(require 'json)
-(require 'dash)
-(require 'shut-up)
-
-(defconst undercover-version "0.6.1")
-
-(defvar undercover-force-coverage nil
-  "Always collect test coverage.
-
-If nil, test coverage will be collected only when running under a
-continuous integration service.
-
-Can also be set through the environment, by defining UNDERCOVER_FORCE.")
-(setq undercover-force-coverage (getenv "UNDERCOVER_FORCE"))
-
-(defvar undercover--report-format nil
-  "Indicates the format of the report file and CI service to submit to.
-
-If nil, autodetect from CI environment.")
-
-(defvar undercover--send-report t
-  "If not nil, test coverage report will be sent to coveralls.io.")
-
-(defvar undercover--report-file-path "/tmp/undercover_coveralls_report"
-  "Path to save coveralls.io report.")
-
-(defvar undercover--files nil
-  "List of files for test coverage check.")
-
-(defvar undercover--files-coverage-statistics (make-hash-table :test 'equal)
-  "Table of coverage statistics for each file in `undercover--files'.")
-
-(defvar undercover--old-edebug-make-form-wrapper
-  (symbol-function 'edebug-make-form-wrapper))
-
-;; Utilities
-
-(defun undercover--fill-hash-table (hash-table &rest keys-and-values)
-  "Fill HASH-TABLE from KEYS-AND-VALUES."
-  (loop for (key value) on keys-and-values by #'cddr
-        do (puthash key value hash-table))
-  hash-table)
-
-(defun undercover--make-hash-table (&rest keys-and-values)
-  "Create new hash-table and fill it from KEYS-AND-VALUES."
-  (apply #'undercover--fill-hash-table (make-hash-table :test 'equal) 
keys-and-values))
-
-(defun undercover--wildcards-to-files (wildcards)
-  "Return list of files matched by WILDCARDS.
-Example of WILDCARDS: (\"*.el\" \"subdir/*.el\" (:exclude \"exclude-*.el\"))."
-  (destructuring-bind (exclude-clauses include-wildcards)
-      (--separate (and (consp it) (eq :exclude (car it))) wildcards)
-    (let* ((exclude-wildcards (-mapcat #'cdr exclude-clauses))
-           (exclude-files (-mapcat #'file-expand-wildcards exclude-wildcards))
-           (include-files (-mapcat #'file-expand-wildcards include-wildcards)))
-      (-difference include-files exclude-files))))
-
-;; `edebug' related functions and hacks:
-
-;; http://debbugs.gnu.org/cgi/bugreport.cgi?bug=6415
-(def-edebug-spec cl-destructuring-bind (sexp form body))
-(def-edebug-spec destructuring-bind (sexp form body))
-
-(def-edebug-spec cl-symbol-macrolet ((&rest (symbolp sexp)) cl-declarations 
body))
-(def-edebug-spec symbol-macrolet ((&rest (symbolp sexp)) cl-declarations body))
-
-(def-edebug-spec cl-type-spec sexp)
-
-(def-edebug-spec when-let ([&or (symbolp form) (&rest (symbolp form))] body))
-
-(defun undercover--fallback-file-handler (operation args)
-  "Handle any file OPERATION with ARGS."
-  (let ((inhibit-file-name-handlers
-         (cons 'undercover-file-handler
-               (and (eq inhibit-file-name-operation operation)
-                    inhibit-file-name-handlers)))
-        (inhibit-file-name-operation operation))
-    (apply operation args)))
-
-(defun undercover--load-file-handler (file)
-  "Handle `load' FILE operation."
-  (let ((edebug-all-defs (undercover--coverage-enabled-p))
-        (load-file-name (file-truename file))
-        (load-in-progress t))
-    (unwind-protect
-        (progn
-          (save-excursion (eval-buffer (find-file load-file-name)))
-          (push load-file-name undercover--files))
-      (switch-to-buffer (current-buffer)))))
-
-(defun undercover--show-load-file-error (filename)
-  (message "UNDERCOVER: error while covering %s" filename)
-  (message "UNDERCOVER: please open a new issue at 
https://github.com/sviridov/undercover.el/issues";))
-
-(defun undercover-file-handler (operation &rest args)
-  "Handle `load' OPERATION.  Ignore all ARGS except first."
-  (if (eq 'load operation)
-      (condition-case nil
-          (undercover--load-file-handler (car args))
-        (error
-         (undercover--show-load-file-error (car args))
-         (undercover--fallback-file-handler operation args)))
-    (undercover--fallback-file-handler operation args)))
-
-(defun undercover--edebug-files (files)
-  "Use `edebug' package to instrument all macros and functions in FILES."
-  (when files
-    (let ((regexp (->> files (regexp-opt) (format "/%s$"))))
-      (add-to-list 'file-name-handler-alist (cons regexp 
'undercover-file-handler)))))
-
-(setf (symbol-function 'undercover--stop-point-before)
-      (lambda (before-index)
-        "Increase number of times that stop point at BEFORE-INDEX was covered."
-        (when (boundp 'edebug-freq-count)
-          (incf (aref edebug-freq-count before-index)))
-        before-index))
-
-(setf (symbol-function 'undercover--stop-point-after)
-      (cons 'macro
-        (lambda (before-index after-index form)
-          "Increase number of times that stop point at AFTER-INDEX was 
covered."
-         `(let ((before-index ,before-index)
-                (after-index ,after-index))
-            (unwind-protect ,form
-              (when (boundp 'edebug-freq-count)
-                (aset edebug-freq-count after-index (+ 1 (aref 
edebug-freq-count after-index)))
-                (undercover--align-counts-between-stop-points before-index 
after-index)))))))
-
-(setf (symbol-function 'undercover--align-counts-between-stop-points)
-      (lambda (before-index after-index)
-        "Decrease number of times that stop points between BEFORE-INDEX and 
AFTER-INDEX are covered."
-        (do ((index (1+ before-index) (1+ index)))
-            ((>= index after-index))
-          (setf (aref edebug-freq-count index)
-                (min (aref edebug-freq-count index)
-                     (aref edebug-freq-count before-index))))))
-
-(defun undercover--stop-points (name)
-  "Return stop points ordered by position for NAME."
-  (append (nth 2 (get name 'edebug)) nil))
-
-(defun undercover--stop-points-covers (name)
-  "Return number of covers for each stop point ordered by position for NAME."
-  (append (get name 'edebug-freq-count) nil))
-
-(defun undercover--shut-up-edebug-message ()
-  "Muffle `edebug' message \"EDEBUG: function\"."
-  ;; HACK: I don't use `defadvice' because of cryptic error with 
`shut-up-sink'.
-  ;; https://travis-ci.org/sviridov/multiple-cursors.el/builds/37529750#L1387
-  ;; https://travis-ci.org/sviridov/expand-region.el/builds/37576813#L285
-  (setf (symbol-function 'edebug-make-form-wrapper)
-        (lambda (&rest args)
-          (shut-up (apply undercover--old-edebug-make-form-wrapper args)))))
-
-(defun undercover--set-edebug-handlers ()
-  "Replace and advice some `edebug' functions with `undercover' handlers."
-  (defalias 'edebug-before 'undercover--stop-point-before)
-  (defalias 'edebug-after 'undercover--stop-point-after)
-  (undercover--shut-up-edebug-message)
-  ;; HACK: Ensures that debugger is turned off.
-  ;; https://travis-ci.org/sviridov/multiple-cursors.el/builds/37672312#L350
-  ;; https://travis-ci.org/sviridov/expand-region.el/builds/37577423#L336
-  (setq debug-on-error  nil
-        debug-on-signal nil
-        edebug-on-error nil))
-
-;; Coverage statistics related functions:
-
-(defun undercover--symbol-coverage-statistics (edebug-symbol statistics)
-  "Collect coverage statistics for EDEBUG-SYMBOL into STATISTICS hash."
-  (let* ((start-marker (car (get edebug-symbol 'edebug)))
-         (points (undercover--stop-points edebug-symbol))
-         (points-covers (undercover--stop-points-covers edebug-symbol))
-         (points-and-covers (map 'list #'cons points points-covers)))
-    (dolist (point-and-cover points-and-covers)
-      (let* ((point (car point-and-cover))
-             (line  (line-number-at-pos (+ point start-marker)))
-             (cover (cdr point-and-cover))
-             (previous-score (gethash line statistics cover))
-             (new-score (min previous-score cover)))
-        (puthash line new-score statistics)))))
-
-(defun undercover--file-coverage-statistics ()
-  "Collect coverage statistics for current-file into hash.
-Keys of that hash are line numbers.
-Values of that hash are number of covers."
-  (let ((statistics (make-hash-table)))
-    (dolist (edebug-data edebug-form-data)
-      (let ((edebug-symbol (car edebug-data)))
-        (when (get edebug-symbol 'edebug)
-          (undercover--symbol-coverage-statistics edebug-symbol statistics))))
-    statistics))
-
-(defun undercover--collect-file-coverage (file)
-  "Collect coverage statistics for FILE."
-  (save-excursion
-    (find-file file)
-    (if edebug-form-data
-        (undercover--fill-hash-table undercover--files-coverage-statistics
-          file (undercover--file-coverage-statistics))
-      (setq undercover--files (delq file undercover--files)))))
-
-(defun undercover--collect-files-coverage (files)
-  "Collect coverage statistics for each file in FILES."
-  (dolist (file files)
-    (undercover--collect-file-coverage file)))
-
-;; Continuous integration related functions:
-
-(defun undercover--under-travic-ci-p ()
-  "Check that `undercover' running under Travis CI service."
-  (getenv "TRAVIS"))
-
-(defun undercover--coveralls-repo-token ()
-  "Return coveralls.io repo token provided by user."
-  (getenv "COVERALLS_REPO_TOKEN"))
-
-(defun undercover--under-ci-p ()
-  "Check that `undercover' running under continuous integration service."
-  (or
-   (undercover--coveralls-repo-token)
-   (undercover--under-travic-ci-p)
-   undercover-force-coverage))
-
-;;; Reports related functions:
-
-(defun undercover--determine-report-format ()
-  "Automatic report-format determination."
-  (and (undercover--under-ci-p) 'coveralls))
-
-(defun undercover--get-git-info (&rest args)
-  "Execute Git with ARGS, returning the first line of its output."
-  (with-temp-buffer
-    (apply #'process-file "git" nil t nil "--no-pager" args)
-    (goto-char (point-min))
-    (buffer-substring-no-properties
-     (line-beginning-position)
-     (line-end-position))))
-
-(defun undercover--get-git-info-from-log (format)
-  "Get first line of Git log in given FORMAT."
-  (undercover--get-git-info "log" "-1" (format "--pretty=format:%%%s" format)))
-
-(defun undercover--get-git-remotes ()
-  "Return list of Git remotes."
-  (with-temp-buffer
-    (process-file "git" nil t nil "--no-pager" "remote")
-    (let ((remotes (split-string (buffer-string) "\n" t))
-          (config-path-format (format "remote.%%s.url"))
-          (remotes-info nil))
-      (dolist (remote remotes remotes-info)
-        (let* ((remote-url (undercover--get-git-info "config" (format 
config-path-format remote)))
-               (remote-table (undercover--make-hash-table
-                              "name" remote
-                              "url"  remote-url)))
-          (push remote-table remotes-info))))))
-
-;; coveralls.io report:
-
-(defun undercover--update-coveralls-report-with-repo-token (report)
-  "Update test coverage REPORT for coveralls.io with repository token."
-  (puthash "repo_token" (undercover--coveralls-repo-token) report))
-
-(defun undercover--try-update-coveralls-report-with-shippable (report)
-  "Update test coverage REPORT for coveralls.io with Shippable service 
information."
-  (when (getenv "SHIPPABLE")
-    (undercover--fill-hash-table report
-      "service_name"   "shippable"
-      "service_job_id" (getenv "BUILD_NUMBER"))
-    (unless (string-equal "false" (getenv "PULL_REQUEST"))
-      (undercover--fill-hash-table report
-        "service_pull_request" (getenv "PULL_REQUEST")))))
-
-(defun undercover--update-coveralls-report-with-travis-ci (report)
-  "Update test coverage REPORT for coveralls.io with Travis CI service 
information."
-  (undercover--fill-hash-table report
-    "service_name"   "travis-ci"
-    "service_job_id" (getenv "TRAVIS_JOB_ID")))
-
-(defun undercover--update-coveralls-report-with-git (report)
-  "Update test coverage REPORT for coveralls.io with Git information."
-  (undercover--fill-hash-table report
-    "git" (undercover--make-hash-table
-           "branch"  (undercover--get-git-info "rev-parse" "--abbrev-ref" 
"HEAD")
-           "remotes" (undercover--get-git-remotes)
-           "head"    (undercover--make-hash-table
-                      "id"              (undercover--get-git-info-from-log "H")
-                      "author_name"     (undercover--get-git-info-from-log 
"aN")
-                      "author_email"    (undercover--get-git-info-from-log 
"ae")
-                      "committer_name"  (undercover--get-git-info-from-log 
"cN")
-                      "committer_email" (undercover--get-git-info-from-log 
"ce")
-                      "message"         (undercover--get-git-info-from-log 
"s")))))
-
-(defun undercover--coveralls-file-coverage-report (statistics)
-  "Translate file coverage STATISTICS into coveralls.io format."
-  (let (file-coverage)
-    (dotimes (line (count-lines (point-min) (point-max)))
-      (push (gethash (1+ line) statistics) file-coverage))
-    (nreverse file-coverage)))
-
-(defun undercover--coveralls-file-report (file)
-  "Create part of coveralls.io report for FILE."
-  (save-excursion
-    (find-file file)
-    (let ((file-name (file-relative-name file (locate-dominating-file 
default-directory ".git")))
-          (file-content (buffer-substring-no-properties (point-min) 
(point-max)))
-          (coverage-report (undercover--coveralls-file-coverage-report
-                            (gethash file 
undercover--files-coverage-statistics))))
-      (undercover--make-hash-table
-       "name"     file-name
-       "source"   file-content
-       "coverage" coverage-report))))
-
-(defun undercover--fill-coveralls-report (report)
-  "Fill test coverage REPORT for coveralls.io."
-  (undercover--fill-hash-table report
-    "source_files" (mapcar #'undercover--coveralls-file-report 
undercover--files)
-    "parallel" (if (getenv "COVERALLS_PARALLEL") t json-false)))
-
-(defun undercover--merge-coveralls-report-file-lines-coverage (old-coverage 
new-coverage)
-  "Merge test coverage for lines from OLD-COVERAGE and NEW-COVERAGE."
-  (loop for (old-line-coverage . new-line-coverage)
-        in (-zip-fill 0 old-coverage new-coverage)
-        collect (cond
-                 ((null old-line-coverage) new-line-coverage)
-                 ((null new-line-coverage) old-line-coverage)
-                 (t (+ new-line-coverage old-line-coverage)))))
-
-(defun undercover--merge-coveralls-report-file-coverage (old-file-hash 
source-files-report)
-  "Merge test coverage from OLD-FILE-HASH into SOURCE-FILES-REPORT."
-  (let* ((file-name (gethash "name" old-file-hash))
-         (old-coverage (gethash "coverage" old-file-hash))
-         (new-file-hash (--first (string-equal file-name (gethash "name" it))
-                                 source-files-report)))
-    (if new-file-hash
-        (undercover--fill-hash-table new-file-hash
-          "coverage" (undercover--merge-coveralls-report-file-lines-coverage
-                      old-coverage (gethash "coverage" new-file-hash)))
-      (rplacd (last source-files-report)
-              (cons old-file-hash nil)))))
-
-(defun undercover--merge-coveralls-reports (report)
-  "Merge test coverage REPORT with existing from 
`undercover--report-file-path'."
-  (ignore-errors
-    (let* ((json-object-type 'hash-table)
-           (json-array-type 'list)
-           (old-report (json-read-file undercover--report-file-path))
-           (new-source-files-report (gethash "source_files" report)))
-      (dolist (old-file-hash (gethash "source_files" old-report))
-        (undercover--merge-coveralls-report-file-coverage
-         old-file-hash new-source-files-report)))))
-
-(defun undercover--create-coveralls-report ()
-  "Create test coverage report for coveralls.io."
-  (undercover--collect-files-coverage undercover--files)
-  (let ((report (make-hash-table :test 'equal)))
-    (cond
-     ((undercover--coveralls-repo-token)
-      (undercover--update-coveralls-report-with-repo-token report)
-      (undercover--try-update-coveralls-report-with-shippable report))
-     ((undercover--under-travic-ci-p) 
(undercover--update-coveralls-report-with-travis-ci report))
-     (t (unless undercover-force-coverage
-          (error "Unsupported coveralls.io report"))))
-    (undercover--update-coveralls-report-with-git report)
-    (undercover--fill-coveralls-report report)
-    (undercover--merge-coveralls-reports report)
-    (json-encode report)))
-
-(defun undercover--save-coveralls-report (json-report)
-  "Save JSON-REPORT to `undercover--report-file-path'."
-  (save-excursion
-    (shut-up
-      (find-file undercover--report-file-path)
-      (erase-buffer)
-      (insert json-report)
-      (save-buffer))))
-
-(defun undercover--send-coveralls-report ()
-  "Send report to coveralls.io."
-  (let ((coveralls-url "https://coveralls.io/api/v1/jobs";))
-    (message "Sending: report to coveralls.io")
-    (shut-up
-     (shell-command
-      (format "curl -v --include --form json_file=@%s %s" 
undercover--report-file-path coveralls-url)))
-    (message "Sending: OK")))
-
-(defun undercover--coveralls-report ()
-  "Create and submit test coverage report to coveralls.io."
-  (undercover--save-coveralls-report (undercover--create-coveralls-report))
-  (when undercover--send-report
-    (undercover--send-coveralls-report)))
-
-;; SimpleCov report:
-
-(defconst undercover--simplecov-report-name "undercover.el"
-  "The name of the generated result in the SimpleCov result set report.")
-
-(defalias 'undercover--simplecov-file-coverage-report
-  #'undercover--coveralls-file-coverage-report
-  "Translate file coverage STATISTICS into SimpleCov format (same as 
coveralls.io).")
-
-(defalias 'undercover--merge-simplecov-report-file-lines-coverage
-  #'undercover--merge-coveralls-report-file-lines-coverage)
-
-(defun undercover--simplecov-file-report (file)
-  "Create part of SimpleCov report for FILE."
-  (save-excursion
-    (find-file file)
-    (list file (undercover--simplecov-file-coverage-report
-                (gethash file undercover--files-coverage-statistics)))))
-
-(defun undercover--fill-simplecov-report (report)
-  "Fill SimpleCov test coverage REPORT."
-  (undercover--fill-hash-table report
-    undercover--simplecov-report-name
-    (undercover--make-hash-table
-     "timestamp" (truncate (time-to-seconds))
-     "coverage" (apply #'undercover--make-hash-table
-                       (apply #'append
-                              (mapcar #'undercover--simplecov-file-report
-                                      undercover--files))))))
-
-(defun undercover--merge-simplecov-report-file-coverage (old-coverage 
file-name new-file-coverage)
-  "Merge into OLD-COVERAGE the FILE-NAME's coverage data NEW-FILE-COVERAGE."
-  (let ((old-file-coverage (gethash file-name old-coverage)))
-    (puthash file-name
-             (if old-file-coverage
-                 (undercover--merge-simplecov-report-file-lines-coverage
-                  old-file-coverage
-                  new-file-coverage)
-               new-file-coverage)
-             old-coverage)))
-
-(defun undercover--merge-simplecov-reports (report)
-  "Merge test coverage REPORT with existing from 
`undercover--report-file-path'."
-  (if (file-readable-p undercover--report-file-path)
-      (let* ((json-object-type 'hash-table)
-             (json-array-type 'list)
-             (old-report (json-read-file undercover--report-file-path))
-             (old-coverage
-              (gethash "coverage" (gethash undercover--simplecov-report-name 
old-report)))
-             (new-coverage
-              (gethash "coverage" (gethash undercover--simplecov-report-name 
report))))
-        (maphash
-         (lambda (name new-file-coverage)
-           (undercover--merge-simplecov-report-file-coverage old-coverage name 
new-file-coverage))
-         new-coverage)
-        old-report)
-    report))
-
-(defun undercover--create-simplecov-report ()
-  "Create SimpleCov test coverage report."
-  (undercover--collect-files-coverage undercover--files)
-  (let ((report (make-hash-table :test 'equal)))
-    (undercover--fill-simplecov-report report)
-    (undercover--merge-simplecov-reports report)
-    (json-encode report)))
-
-(defun undercover--save-simplecov-report (json-report)
-  "Save JSON-REPORT to `undercover--report-file-path'."
-  (with-temp-buffer
-    (insert json-report)
-    (write-region nil nil undercover--report-file-path)))
-
-(defun undercover--simplecov-report ()
-  "Create test coverage report in SimpleCov format."
-  (undercover--save-simplecov-report (undercover--create-simplecov-report)))
-
-;; `ert-runner' related functions:
-
-(defun undercover-safe-report ()
-  "Version of `undercover-report' that ignore errors."
-  (with-demoted-errors
-    (undercover-report)))
-
-(defun undercover-report-on-kill ()
-  "Add `undercover-safe-report' to `kill-emacs-hook'."
-  (add-hook 'kill-emacs-hook 'undercover-safe-report))
-
-;;; Main functions:
-
-(defun undercover--coverage-enabled-p ()
-  "Check that `undercover' is enabled."
-  (or undercover-force-coverage (undercover--under-ci-p)))
-
-(defun undercover-report (&optional report-format)
-  "Create and submit (if needed) test coverage report based on REPORT-FORMAT.
-Posible values of REPORT-FORMAT: coveralls."
-  (if undercover--files
-    (case (or report-format undercover--report-format 
(undercover--determine-report-format))
-      (coveralls (undercover--coveralls-report))
-      (simplecov (undercover--simplecov-report))
-      (t (error "Unsupported report-format")))
-    (message
-     "UNDERCOVER: No coverage information. Make sure that your files are not 
compiled?")))
-
-(defun undercover--env-configuration ()
-  "Read configuration from UNDERCOVER_CONFIG."
-  (let ((configuration (getenv "UNDERCOVER_CONFIG")))
-    (when configuration
-      (condition-case nil
-          (car (read-from-string configuration))
-        (error
-         (error "UNDERCOVER: error while parsing configuration"))))))
-
-(defun undercover--set-options (configuration)
-  "Read CONFIGURATION.
-Set `undercover--send-report' and `undercover--report-file-path'.
-Return wildcards."
-  (destructuring-bind (wildcards options)
-      (--separate (or (stringp it) (eq :exclude (car-safe it))) configuration)
-    (dolist (option options wildcards)
-      (case (car-safe option)
-        (:report-file (setq undercover--report-file-path (cadr option)))
-        (:report-format (setq undercover--report-format (cadr option)))
-        (:send-report (setq undercover--send-report (cadr option)))
-        (otherwise (error "Unsupported option: %s" option))))))
-
-(defun undercover--setup (configuration)
-  "Enable test coverage for files matched by CONFIGURATION."
-  (when (undercover--coverage-enabled-p)
-    (let ((env-configuration (undercover--env-configuration))
-          (default-configuration '("*.el")))
-      (undercover--set-edebug-handlers)
-      (undercover-report-on-kill)
-      (let ((wildcards (undercover--set-options
-                        (or (append configuration env-configuration)
-                            default-configuration))))
-        (undercover--edebug-files (undercover--wildcards-to-files 
wildcards))))))
-
-;;;###autoload
-(defmacro undercover (&rest configuration)
-  "Enable test coverage for files matched by CONFIGURATION.
-Example of CONFIGURATION: (\"*.el\" \"subdir/*.el\" (:exclude 
\"exclude-*.el\")).
-
-If running under Travic CI automatically generate report
-on `kill-emacs' and send it to coveralls.io."
-  `(undercover--setup
-    (list
-     ,@(--map (if (atom it) it `(list ,@it))
-              configuration))))
-
-(provide 'undercover)
-;;; undercover.el ends here
diff --git a/d-mode-test.el b/d-mode-test.el
index d78f112..222485a 100644
--- a/d-mode-test.el
+++ b/d-mode-test.el
@@ -49,7 +49,6 @@
 ;;----------------------------------------------------------------------------
 ;;; Code:
 
-(load (expand-file-name "coverage/undercover.el"))
 (if (getenv "D_MODE_COVERAGE")
     (progn
       ;; Generate a coverage report viewable in Emacs.