;;; taskrunner-web.el --- Provide functions to retrieve tasks for web build systems-*- lexical-binding: t; -*-
;; Copyright (C) 2019 Yavor Konstantinov

;;; Commentary:
;; This file adds support for taskrunners which are mainly used for
;; javascript/web projects.
;; Support included for:
;; - yarn/npm
;; - gulp
;; - grunt
;; - jake

;;; Code:

;;;; Required

(require 'json)
(require 'subr-x)
(require 'cl-lib)

;;;; Variables

(defcustom taskrunner-preferred-js-package-manager nil
  "The preferred package manager to be used for tasks from package.json.
The package manager name should be a string which can be either `npm' or `yarn'.
If its value is nil then the package manager to be used is determined by the presence
of either a `yarn.lock' or `package-lock.json'.  If none are present and this
variable is nil then `npm' is used as default."
  :type 'string
  :options '("npm" "yarn")
  :group 'taskrunner)

(defconst taskrunner--js-gulp-tasks-command "gulp --tasks-simple"
  "Command used to retrieve the tasks for Gulp.")

;;;; Functions

;; These are here just to silence the bytecompiler. They are defined in
;; `taskrunner.el' and will be loaded later on but due to these files being
;; required before the function being loaded, a warning is emitted.
(declare-function taskrunner--narrow-to-line "ext:taskrunner")
(declare-function taskrunner--make-task-buff-name "ext:taskrunner")

(defun taskrunner--yarn-or-npm (DIR)
  "Detect if the current project in directory DIR is using `yarn' or `npm'.
If `taskrunner-preferred-js-package-manager' is not nil then its value is used.
Otherwise,  if `yarn.lock' is present then yarn is used.  If `package-lock.json'
is present then NPM is used.  If none are present and
`taskrunner-preferred-js-package-manager' is nil then the default is `npm'."
  (let ((dir-files  (directory-files DIR)))
    (cond
     ((member "yarn.lock" dir-files)
      "YARN")
     ((member "package-lock.json" dir-files)
      "NPM")
     ((stringp taskrunner-preferred-js-package-manager)
      (upcase taskrunner-preferred-js-package-manager))
     ;; Default if no files are present and the preferred package manager is
     ;; not set
     (t
      "NPM"))))

(defun taskrunner-get-package-json-tasks (DIR)
  "Retrieve all tasks in the scripts section of the package.json file in DIR.
This function returns a list of the form:
\(\PM TASK1\" \"PM TASK2\"...)
where PM is the package manager used(yarn or npm)."
  (let* ((package-path (expand-file-name "package.json" DIR))
         (package-json-scripts (alist-get 'scripts (json-read-file package-path)))
         (task-prefix (taskrunner--yarn-or-npm DIR))
         (tasks))
    (when package-json-scripts
      (setq tasks (cl-map 'list (lambda (elem)
                                  (concat task-prefix " " (symbol-name (car elem))))
                          package-json-scripts)))
    tasks))

(defun taskrunner-get-gulp-tasks (DIR)
  "Retrieve the gulp tasks for the project in directory DIR.
This function returns a list of the form:
\(\"GULP TASK1\" \"GULP TASK2\"...)"
  (let ((default-directory DIR))
    (butlast (cl-map 'list (lambda (elem)
                             (concat "GULP" " " elem))
                     (split-string (shell-command-to-string taskrunner--js-gulp-tasks-command) "\n")))))

(defun taskrunner--get-grunt-tasks-from-buffer ()
  "Retrieve the grunt tasks from the current buffer and return them as a list.
This function is not meant to be used externally.  Use
`taskrunner--get-grunt-tasks' instead."
  (goto-char (point-min))
  (let ((beg (re-search-forward "Available tasks.+\n" nil t))
        ;; The end of the region is simply an empty line
        (end (re-search-forward "^$" nil t)))
    (when beg
      (narrow-to-region beg end)
      (cl-map 'list (lambda (elem)
                      (concat "GRUNT" " " (car (split-string (string-trim elem) " "))))
              (split-string (buffer-string) "\n")))))

(defun taskrunner-get-grunt-tasks (DIR)
  "Retrieve the grunt tasks for the project in directory DIR.
This function returns a list of the form:
\(\"GRUNT TASK1\" \"GRUNT TASK2\"...)"
  (let ((default-directory DIR)
        (tasks))
    (call-process "grunt" nil (taskrunner--make-task-buff-name "grunt") nil "--help")
    (with-temp-buffer
      (set-buffer (taskrunner--make-task-buff-name "grunt"))
      (setq tasks (taskrunner--get-grunt-tasks-from-buffer))
      (kill-current-buffer))
    (butlast tasks)))

(defun taskrunner--get-jake-tasks-from-buffer ()
  "Retrieve the rake tasks from the current buffer.
This function returns a list of the form:
\(\"JAKE TASK1\" \"JAKE TASK2\"...)"
  (goto-char (point-min))
  (taskrunner--narrow-to-line)
  (if (not (string-match-p ".+aborted\." (buffer-string)))
      (progn
        (widen)
        (goto-char (point-min))
        (let ((jake-tasks '()))
          (while (search-forward-regexp "^jake[[:space:]]+" nil t)
            (taskrunner--narrow-to-line)
            (push (concat "JAKE" " " (cadr (split-string (buffer-string) " " t))) jake-tasks)
            (widen))
          (kill-current-buffer)
          jake-tasks))
    nil))

(defun taskrunner-get-jake-tasks (DIR)
  "Retrieve the ant tasks for the project in directory DIR.
This function returns a list of the form:
\(\"JAKE TASK1\" \"JAKE TASK2\"...)"
  (let ((default-directory DIR))
    (call-process "jake"  nil (taskrunner--make-task-buff-name "jake")  nil "-T")
    (with-temp-buffer
      (set-buffer (taskrunner--make-task-buff-name "jake"))
      (taskrunner--get-jake-tasks-from-buffer))))

(provide 'taskrunner-web)
;;; taskrunner-web.el ends here