~ubuntu-branches/ubuntu/wily/ess/wily-proposed

;; published by the Free Software Foundation; either version 3, or

;; (at your option) any later version.

;;

;; This file 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 GNU Emacs; see the file COPYING.  If not, write to

;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

;;  customise inferior-julia-program-name to point to your julia-basic

;;; Code:

 

(require 'ess-utils)

 

(autoload 'inferior-ess "ess-inf" "Run an ESS process.")

(autoload 'ess-mode     "ess-mode" "Edit an ESS process.")

  "Syntax table for `julia-mode'.")

  "Syntax table for `julia-mode'.")

  "Syntax table for `julia-mode'.")

(defconst julia-font-lock-keywords

  (list '("\\<\\(\\|Uint\\(8\\|16\\|32\\|64\\|128\\)\\|Int\\(8\\|16\\|32\\|64\\|128\\)\\|BigInt\\|Integer\\|BigFloat\\|FloatingPoint\\|Float16\\|Float32\\|Float64\\|Complex128\\|Complex64\\|ComplexPair\\|Bool\\|Char\\|Number\\|Real\\|Int\\|Uint\\|Array\\|DArray\\|AbstractArray\\|AbstractVector\\|AbstractMatrix\\|AbstractSparseMatrix\\|SubArray\\|StridedArray\\|StridedVector\\|StridedMatrix\\|VecOrMat\\|StridedVecOrMat\\|Range\\|Range1\\|SparseMatrixCSC\\|Tuple\\|NTuple\\|Symbol\\|Function\\|Vector\\|Matrix\\|Union\\|Type\\|Any\\|Complex\\|None\\|String\\|Ptr\\|Void\\|Exception\\|Task\\|Signed\\|Unsigned\\|Associative\\|Dict\\|IO\\|IOStream\\|Ranges\\|Rational\\|Regex\\|RegexMatch\\|Set\\|IntSet\\|ASCIIString\\|UTF8String\\|ByteString\\|Expr\\|WeakRef\\|Nothing\\|ObjectIdDict\\|SubString\\)\\>" .

            "finally" "typealias" "break" "continue" "type" "global" "@\\w+"

            "module" "using" "import" "export" "const" "let" "bitstype" "do"

            "baremodule" "importall" "immutable")

    '("\\<\\(true\\|false\\|C_NULL\\|Inf\\|NaN\\|Inf32\\|NaN32\\|nothing\\)\\>" . font-lock-constant-face)

        "quote" "do" "immutable"))

  (list "end" "else" "elseif" "catch" "finally"))

  "Return the word at point if it matches any keyword in KW-LIST.

KW-LIST is a list of strings.  The word at point is not considered

a keyword if used as a field name, X.word, or quoted, :word."

  "Move back and return the position of the last open block, if one found.

Do not move back beyond position MIN."

                        (not (ess-inside-comment-p))

                        (not (ess-inside-brackets-p)))

  "Move back and return indentation level for last open block.

Do not move back beyond MIN."

  "Return indent implied by a special form opening on the previous line."

  "Return indent by last opening paren."

  (let* ((p (parse-partial-sexp

             (save-excursion

               ;; only indent by paren if the last open

               ;; paren is closer than the last open

               ;; block

               (or (julia-last-open-block-pos (point-min))

                   (point-min)))

             (progn (beginning-of-line)

                    (point))))

  "Indent current line of julia code."

  (end-of-line)

  (indent-line-to

   (or (and (ess-inside-string-p (point-at-bol)) 0)

       (save-excursion (ignore-errors (julia-form-indent)))

       (save-excursion (ignore-errors (julia-paren-indent)))

       ;; previous line ends in =

       (save-excursion

         (beginning-of-line)

         (skip-chars-backward " \t\n")

         (when (eql (char-before) ?=)

           (+ julia-basic-offset (current-indentation))))

       (save-excursion

         (let ((endtok (progn

                         (beginning-of-line)

                         (forward-to-indentation 0)

                         (julia-at-keyword julia-block-end-keywords))))

           (ignore-errors (+ (julia-last-open-block (point-min))

                             (if endtok (- julia-basic-offset) 0)))))

       ;; take same indentation as previous line

       (save-excursion (forward-line -1)

                       (current-indentation))

       0))

  (when (julia-at-keyword julia-block-end-keywords)

    (forward-word 1)))

    (font-lock-defaults           . '(julia-font-lock-keywords nil nil ((?\_ . "w"))))

  "Send the Julia STRING to the PROCESS.

VISIBLY is not currently used."

    (process-send-string process (format ess-load-command file))))

 

;;; HELP

  (append (ess-get-words-from-vector "ESS.all_help_topics()\n")

          (julia--get-objects)))

(defun julia--retrive-topics (url)

  (with-current-buffer (url-retrieve-synchronously url)

    (require 'url)

    (goto-char (point-min))

    (let (out)

      (while (re-search-forward "toctree.*href=\"\\(.+\\)\">\\(.+\\)</a" nil t)

        (push (propertize (match-string 2)

                          :manual (concat url (match-string 1)))

              out))

      (kill-buffer)

      (nreverse out))))

 

(defvar julia--manual-topics nil)

(defun julia-manual-lookup-function (&rest args) ; args are not used

  (interactive)

  "Look up topics at http://docs.julialang.org/en/latest/manual/"

  ;; <li class="toctree-l1"><a class="reference internal" href="introduction/">Introduction</a></li>

  (let* ((pages (or julia--manual-topics

                    (setq julia--manual-topics

                          (julia--retrive-topics "http://docs.julialang.org/en/latest/manual/"))))

         (page (ess-completing-read "Lookup:" pages nil t)))

    (browse-url (get-text-property 1 :manual page))))

 

(defvar julia--reference-topics nil)

(defun julia-reference-lookup-function (&rest args) ; args are not used

  (interactive)

  "Look up reference topics"

  ;; <li class="toctree-l1"><a class="reference internal" href="introduction/">Introduction</a></li>

  (let* ((pages (ess-get-words-from-vector "ESS.help_categories()\n")))

    (ess-display-help-on-object

     (ess-completing-read "Category" pages nil t))))

 

 

 

;;; COMPLETION

(defun julia-object-completion ()

  "Return completions at point in a format required by `completion-at-point-functions'. "

  (let ((proc (ess-get-next-available-process ess-dialect t))

        (beg (ess-symbol-start)))

    (if proc

        (when beg

          (let* ((prefix (buffer-substring-no-properties beg (point)))

                 (obj (and (string-match "\\(.*\\)\\..*$" prefix)

                           (match-string 1 prefix)))

                 (beg (if obj

                          (+ beg 1 (length obj))

                        beg)))

            (list beg (point)

                  (nreverse (mapcar 'car (julia--get-objects proc obj)))

                  :exclusive 'no)))

      (when (string-match "complet" (symbol-name last-command))

        (message "No ESS process of dialect %s started" ess-dialect)

        nil))))

 

(defun julia--get-objects (&optional proc obj)

  "Return all available objects.

Local caching might be used. If MODULE is givven, return only

objects from that MODULE."

  (setq proc (or proc

                 (get-process ess-local-process-name)))

  (when (process-live-p proc)

    (let ((objects (process-get proc 'objects)))

     (if (process-get proc 'busy)

         (if obj

             (assoc obj objects)

           (process-get proc 'objects))

       (if obj

           (or (cdr (assoc obj objects))

               ;; don't cache composite objects and datatypes

               (julia--get-components proc obj))

         ;; this segment is entered when user completon at top level is

         ;; requested, either Tab or AC. Hence Main is always updated.

         (let ((modules (ess-get-words-from-vector

                         "ESS.main_modules()\n" nil nil proc))

               (loc (process-get proc 'last-objects-cache))

               (lev (process-get proc 'last-eval)))

           (prog1

               (mapcan (lambda (mod)

                         ;; we are caching all modules, and reinit Main every

                         ;; time user enters commands

                         (copy-sequence

                          (or (and (or (not (equal mod "Main"))

                                       (ignore-errors (time-less-p lev loc)))

                                   (cdr (assoc mod objects)))

                              (julia--get-components proc mod t))))

                       modules)

             (process-put proc 'last-objects-cache (current-time)))))))))

 

(defun julia--get-components (proc obj &optional cache?)

  (with-current-buffer (ess-command (format "ESS.components(%s)\n" obj)

                                    nil nil nil nil proc)

    (goto-char (point-min))

    (let (list)

      (while (re-search-forward

              "^\\([^ \t\n]+\\) +\\([^ \t\n]+\\)$" nil t)

        (push (cons (match-string 1) (match-string 2)) list))

      (when cache?

        (let ((objects (process-get proc 'objects)))

         (push (cons obj list) objects)

         (process-put proc 'objects objects)))

      list)))

 

 

;;; AC

(defvar  ac-source-julia-objects

  '((prefix     . ess-symbol-start)

    (requires   . 2)

    (candidates . ess-ac-julia-objects)

    (document   . ess-ac-help-object)

    )

  "Auto-completion source for julia objects")

 

(defun ess-ac-julia-objects ()

  "Get all cached objects"

  (let ((aprf ac-prefix))

    (let ((proc (ess-get-next-available-process nil t)))

      (when aprf

        (if (string-match "\\(.*\\)\\..*$" aprf)

            (let ((module (match-string 1 aprf)))

              (mapcar (lambda (el) (concat module "." (car el)))

                      (julia--get-objects proc module)))

          (julia--get-objects proc))))))

 

 

 

;;; ERRORS

(defvar julia-error-regexp-alist '(julia-in julia-at)

 

 

;;; ELDOC

(defun julia-eldoc-function ()

  "Return the doc string, or nil.

If an ESS process is not associated with the buffer, do not try

to look up any doc strings."

  (interactive)

  (when (and (ess-process-live-p)

             (not (ess-process-get 'busy)))

    (let ((funname (or (and ess-eldoc-show-on-symbol ;; aggressive completion

                            (symbol-at-point))

                       (car (ess--funname.start)))))

      (when funname

        (let* ((args (copy-sequence (nth 2 (ess-function-arguments funname))))

               (W (- (window-width (minibuffer-window)) (+ 4 (length funname))))

               (doc (concat (propertize funname 'face font-lock-function-name-face) ": ")))

          (when args

            (setq args (sort args (lambda (s1 s2)

                                    (< (length s1) (length s2)))))

            (setq doc (concat doc (pop args)))

            (while (and args (< (+ (length doc) (length (car args))) W))

              (setq doc (concat doc "  "

                                (pop args))))

            (when (and args (< (length doc) W))

              (setq doc (concat doc " {--}"))))

          doc)))))

 

 

;;; IMENU

(defvar julia-imenu-generic-expression

  ;; don't use syntax classes, screws egrep

  '(("Function (_)" "[ \t]*function[ \t]+\\(_[^ \t\n]*\\)" 1)

    ("Function" "^[ \t]*function[ \t]+\\([^_][^\t\n]*\\)" 1)

    ("Const" "[ \t]*const \\([^ \t\n]*\\)" 1)

    ("Type"  "^[ \t]*[a-zA-Z0-9_]*type[a-zA-Z0-9_]* \\([^ \t\n]*\\)" 1)

    ("Require"      " *\\(\\brequire\\)(\\([^ \t\n)]*\\)" 2)

    ("Include"      " *\\(\\binclude\\)(\\([^ \t\n)]*\\)" 2)

    ))

 

 

;;; CORE

    (ess-eldoc-function                 . 'julia-eldoc-function)

    (inferior-ess-font-lock-defaults    . julia-font-lock-keywords)

    (ess-manual-lookup-command          . 'julia-manual-lookup-function)

    (ess-reference-lookup-command       . 'julia-reference-lookup-function)

    (ess-load-command                   . "include(\"%s\")\n")

    (ess-error-regexp-alist             . julia-error-regexp-alist)

    (inferior-ess-help-command          . "ESS.help(\"%s\")\n")

    (ess-ac-sources                     . '(ac-source-julia-objects))

    (ess-object-name-db-file            . "ess-jl-namedb.el" )

(defvar julia-versions '("julia")

command for that version of Julia is made available.")

  ;; These arguments are currently not passed to other versions of julia that have

  ;; been created using the variable `ess-r-versions'."

  (remove-hook 'completion-at-point-functions 'ess-filename-completion 'local) ;; should be first

  (add-hook 'completion-at-point-functions 'julia-object-completion nil 'local)

  (add-hook 'completion-at-point-functions 'ess-filename-completion nil 'local)

(defvar julia-mode-hook nil)

(defvar julia-post-run-hook nil

  "Functions run in process buffer after starting julia process.")

  "Call 'julia'.

      (error "'inferior-julia-program-name' does not point to 'julia-basic' executable")

      (inferior-ess jl-start-args)

 

      (remove-hook 'completion-at-point-functions 'ess-filename-completion 'local) ;; should be first

      (add-hook 'completion-at-point-functions 'julia-object-completion nil 'local)

      (add-hook 'completion-at-point-functions 'ess-filename-completion nil 'local)

 

        (run-mode-hooks 'julia-post-run-hook))

(add-to-list 'auto-mode-alist '("\\.jl\\'" . julia-mode))

 

;;; ess-julia.el ends here