;;; rails-rake.el --- emacs-rails integraions with rake tasks.

;; Copyright (C) 2006 Dmitry Galinsky <dima dot exe at gmail dot com>

;; Authors: Dmitry Galinsky <dima dot exe at gmail dot com>,

;; Keywords: ruby rails languages oop

;; $URL: svn+ssh://rubyforge/var/svn/emacs-rails/trunk/rails-scripts.el $

;; $Id: rails-scripts.el 117 2007-03-25 23:37:37Z dimaexe $

;;; License

;; This program is free software; you can redistribute it and/or

;; modify it under the terms of the GNU General Public License

;; as published by the Free Software Foundation; either version 2

;; of the License, or (at your option) any later version.

;; This program is distributed in the hope that it will be useful,

;; but WITHOUT ANY WARRANTY; without even the implied warranty of

;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License

;; along with this program; if not, write to the Free Software

;; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

(eval-when-compile

  (require 'rails-scripts))

(defcustom rails-rake-use-bundler-when-possible t

  "t when rake should be run with 'bundle exec' whenever possible. (Gemfile present)"

  :group 'rails

  :type 'boolean)

(defvar rails-rake:history (list))

(defvar rails-rake:tasks-regexp "^rake \\([^ ]*\\).*# \\(.*\\)"

  "Regexp to match tasks list in `rake --tasks` output.")

(defun rails-rake:create-tasks-cache (file-name)

  "Create a cache file from rake --tasks output."

  (let ((tasks (loop for str in (split-string (rails-cmd-proxy:shell-command-to-string (rails-rake:rake-command "--task")) "\n")

                     for task = (when (string-not-empty str)

                                  (string=~ rails-rake:tasks-regexp str $1))

                     when task collect task)))

    (write-string-to-file file-name (prin1-to-string tasks))

    tasks))

(defun rails-rake:list-of-tasks ()

  "Return all available tasks and create tasks cache file."

  (rails-project:in-root

   (let* ((cache-file (rails-core:file "tmp/.tasks-cache")))

     (if (file-exists-p cache-file)

         (read-from-file cache-file)

       (rails-rake:create-tasks-cache cache-file)))))

(defun rails-rake:list-of-tasks-without-tests ()

  "Return available tasks without test actions."

  (when-bind

   (tasks (rails-rake:list-of-tasks))

   (sort (delete* nil

                  (mapcar

                   #'(lambda (it) (if (string=~ "^test\\($\\|:\\)" it t) nil it))

                   (rails-rake:list-of-tasks))

                  :if 'null)

         'string<)))

(defun rails-rake:task (task &optional major-mode mode-line-string)

  "Run a Rake task in RAILS_ROOT with MAJOR-MODE, using mode-line-string as the script name."

  (interactive (rails-completing-read "What task run" (rails-rake:list-of-tasks-without-tests)

                                      'rails-rake:history nil))

  (when task

    (rails-script:run (rails-rake:rake-command) (list task) major-mode (or mode-line-string (concat (rails-rake:rake-command " ") task)))))

(defun rails-rake:migrate (&optional version)

  "Run the db:migrate task"

  (interactive)

  (rails-rake:task

   (concat

    "db:migrate"

    (typecase version

      (integer (format " VERSION=%.3i" version))

      (string (format " VERSION=%s" version))))))

(defun rails-rake:migrate-to-version (version)

  "Run migrate with VERSION."

  (interactive (rails-completing-read "Version of migration"

                                      (rails-core:migration-versions t)

                                      nil

                                      t))

  (when version

    (rails-rake:migrate version)))

(defun rails-rake:migrate-to-prev-version ()

  "Migrate to a previous version."

  (interactive)

  (let ((versions (rails-core:migration-versions t)))

    (rails-rake:migrate

     (when (< 2  (length versions))

       (nth 1 versions)))))

(defun rails-rake:migrate-version (&optional version direction)

  "Run the db:migration:(up|down) task"

  (interactive)

  (if (string-equal "" version)

      (setq version (rails-core:current-migration-version)))

  (rails-rake:task

   (concat

    "db:migrate"

    (cond ((string-equal direction "up") ":up")

          ((string-equal direction "down") ":down"))

    (typecase version

      (integer (format " VERSION=%.3i" version))

      (string (format " VERSION=%s" version))))))

(defun rails-rake:migration-version-up (&optional version)

  "Run up migration with VERSION."

  (interactive (rails-completing-read "Version of migration"

                                      (rails-core:migration-versions t)

                                      nil

                                      t))

  (when version

    (rails-rake:migrate-version version "up")))

(defun rails-rake:migration-version-down (&optional version)

  "Run up migration with VERSION."

  (interactive (rails-completing-read "Version of migration"

                                      (rails-core:migration-versions t)

                                      nil

                                      t))

  (when version

    (rails-rake:migrate-version version "down")))

;; This function was originally defined anonymously in ui. It was defined here so keys

;; can be added to it dryly

(defun rails-rake:clone-development-db-to-test-db ()

  "Clone development DB to test DB."

  (interactive) (rails-rake:task "db:test:clone"))

(defun rails-rake:rake-command (&optional args)

  (if (and rails-rake-use-bundler-when-possible (file-exists-p (rails-core:file "Gemfile")))

      (concat "bundle exec rake " args) (concat "rake " args)))

(provide 'rails-rake)