WikEmacs - User contributions [en]

Talk:Java

2016-09-19T10:43:01Z

Matthias:

I have added a paragraph with a list of articles that talk about java editing with emacs. I hope it is filled soon and gives a nice collection of emacs and java related reading sources.

[[User:Elvince|Elvince]] ([[User talk:Elvince|talk]]) 12:45, 13 September 2016 (EDT) It's a good initiative, however imo it's actually better to incorporate the interesting parts of those articles into wikemacs.

[[User:Matthias|Matthias]] Would that not get to lengthy once a couple of articles are collected?

[[User:Elvince|Elvince]] ([[User talk:Elvince|talk]]) 16:51, 18 September 2016 (EDT) It may become lengthy, but I believe it's a good thing, because we can structure the content very well, and that is the goal of a wiki, to document stuff as well as possible. I really think it's good to have a lot of doc in one, well structured place, rather than in many blog posts. I hope that the python page, that I edited a lot, is readable: http://wikemacs.org/wiki/Python It has a big table of contents that help find what we're interested in quickly. You can also write a guick summary and refer to the post if it's big, that's a good start already. (anyway, any edit on wikemacs is cool :) )

[[User:Matthias|Matthias]] Admitted - Python article looks good! However my level as a "Java Developer using Emacs" is absolut beginner. So the article collection I have in mind supports my current level: I collect advice and try to find my preferences. I think this is integral part of every learning process and a good wiki entry on any topic should support me.

Python

2016-09-19T10:39:55Z

Matthias: There are rumors about emacs 23 supporting packages.

== Default modes ==

There are a number of python modes for Emacs.
fgallina's [https://github.com/fgallina/python.el python.el] is the python.el included in Emacs 24.2 and onwards.

== All-in-one solutions ==

=== emacs-for-python ===

'''emacs-for-python''' is a bundle of the above modes (and more), and it's an easy way to turn Emacs into a Python IDE.

[https://github.com/gabrielelanaro/emacs-for-python/ emacs-for-python at github]

=== Elpy ===

'''Elpy''' is a collection of elisp packages for Python too.

https://github.com/jorgenschaefer/elpy/wiki/Features

=== EMP: EMacs Python ===

The goal of '''emp''' is to take all the best development components available for Python, and combine it conveniently under Emacs. It builds on top of elpy, and provides even more bindings.

https://kootenpv.github.io/2016-01-01-emacs-python

== Refactoring ==

=== rope & ropemacs ===

==== Presentation ====

'''rope''' is a library for refactoring and manipulating Python code, '''pymacs''' is an interface between emacs lisp and python, and '''{{ModeLink|ropemacs}}''' is an Emacs interface to the rope library which uses rope and pymacs.

If you do some search and replace of code objects in your code and find it sometimes tricky, and/or you need to do it in more than one file, then you should consider a good tool of refactoring.

But Rope can do more than this simple example, it can:

* Rename anything
* Extract method/local variable
* Change method signature
* Perform cross-project refactorings
* Support Mercurial, GIT, Darcs and SVN in refactorings

Rope can also help IDE's with:

* Auto-completion
* Finding definition location
* Getting pydoc
* Finding occurrences
* Organizing imports (removing unused and duplicate imports and sorting them)
* Generating python elements

==== Installation ====

===== With el-get =====

So an easy way is to use an [[el-get]] recipe: '''M-x el-get-install ropemacs'''. It installs and build Pymacs, rope and ropemacs. The difference from the solution using pip is that it setups the Emacs side of Pymacs correctly.

===== Manually =====

You can follow the instructions as given [http://stackoverflow.com/a/22496541/4018217 here] ,if you don't want to use marmalade you can use the following instructions .

sudo pip install rope ropemacs

As of February 2014 you can't install Pymacs via pip, therefore:

git clone http://github.com/pinard/pymacs
cd pymacs
make check
sudo make install

make check ensures the prerequisites. sudo make install puts Pymacs module in Python local modules path, usually /usr/local/lib/python2.7/dist-packages/. People generally frown upon make install, because if you lose the Makefile, it can become hard to cleanly uninstall. But you shouldn't fear it, as pip uses the same directory, so pip uninstall pymacs will work.

'''After you do the make install of pymacs do not delete the folder.Copy the file pymacs.el to ~/.emacs.d/site-lisp/'''

Now add path of pyamcs.el to your ~/.emacs file,using this code:
(setq emacs-config-path "~/.emacs.d/")
(setq base-lisp-path "~/.emacs.d/site-lisp/")
(setq site-lisp-path (concat emacs-config-path "/site-lisp"))
(defun add-path (p)
(add-to-list 'load-path (concat base-lisp-path p)))
(add-path "")
(add-to-list 'load-path "~/.emacs.d")

You can now lazily load ropemacs or load it at runtime.For lazy evaluation add this to your .emacs file:
(defun load-ropemacs ()
"Load pymacs and ropemacs"
(interactive)
(require 'pymacs)
(pymacs-load "ropemacs" "rope-")
;; Automatically save project python buffers before refactorings
(setq ropemacs-confirm-saving 'nil)
)
(global-set-key "\C-xpl" 'load-ropemacs)

use c-xpl to load ropemacs.Read more about it [https://github.com/python-rope/ropemacs#setting-up here]

=== Rope & traad ===

[https://github.com/abingham/traad Traad] is a client-server approach to using the rope Python refactory library. It involves two basic components:
* A HTTP server exposing the rope API via JSON, and
* Client libraries for talking to the server
Since rope is written in Python, any tool that wants to use rope needs to either embed Python, or it needs to find a way to communicate with a Python process running rope. The embedding approach is difficult if the target environment is not written in Python, and it also faces challenges when dealing with more than one Python version.

So traad aims to simplify communication with rope running in an independent process. HTTP communication and JSON data handling is well supported in many, many languages, so any environment that wants to use rope should be able to easily communicate with traad.

=== Projectile - replace in project ===

This is not specific to Python but is very helpful anyway. [[Projectile]] has a function '''projectile-replace''' which interactively offers to replace all occurrences of a term in all the files of the project. So it's handy to rename a method.

=== Refactor with Elpy ===

See Elpy's documentation: http://elpy.readthedocs.io/en/latest/ide.html?highlight=django#refactoring

One can refactor code (with rope), format code, edit all the occurences of the symbol at point simultaneously, and fix imports.

== Auto-Completion ==

=== Jedi ===

Jedi.el is a Python auto-completion package for Emacs. It aims at helping your Python coding in a non-destructive way. It also helps you to find information about Python objects, such as docstring, function arguments and code location.

Jedi is simple to install and it works out of the box.

See screenshots and get the full documentation : http://tkf.github.io/emacs-jedi/released/

Jedi's official page: http://jedi.jedidjah.ch/en/latest/

==== Installation ====

Install Jedi.el via el-get, Marmalade or MELPA (see install for more info) and add this to your Emacs configuration:
(add-hook 'python-mode-hook 'jedi:setup)
(setq jedi:setup-keys t) ; optional
(setq jedi:complete-on-dot t) ; optional

or call M-x jedi:setup

''Note'': it's nice to use it in a python interpreter inside emacs :)

=== Anaconda ===

'''Anaconda-mode''' is a mode for '''code navigation, documentation lookup''' and '''completion''' for Python.

It runs on '''emacs 24.3''' with python >= 2.6.

It provides:

* context-sensitive code completion for Python
* jump to definition
* find references
* view documentation
* virtualenv management

The package is available in [[MELPA]]. For more information, [https://github.com/proofit404/anaconda-mode read its documentation].

== Code Checker ==

=== Flymake ===

[[Flymake|flymake]] is a on-the-fly syntax checker for Emacs.
We can use it alongside with [[flyspell|flyspell]].

To run pep8, pylint, pyflakes and unit-tests (with nose), you can be interested in using [https://github.com/akaihola/flymake-python flymake-python].

Don't forget about '''pylint''' too.

== Indexing sources: ctags, cscope, pycscope ==

Indexing sources allows you to do neat things, like going to the definition of a function or finding which functions are calling another one.

=== etags, ctags ===

'''Etags''' (Exuberant Ctags) generates an index (or tag) file of language objects found in source files that allows these items to be quickly and easily located by a text editor or other utility. A tag signifies a language object for which an index entry is available (or, alternatively, the index entry created for that object). Etags is a multilingual implementation of '''ctags'''.

The primary use for the tags files is looking up class/method/function/constant/etc declaration/definitions. Cscope is more powerful (see below).

==== usage ====

Generate the tags with this command at the root of your project:

find . -name "*.py" -print | etags -

it creates the file TAGS.

Note that projects like [[Projectile]] or [[Helm]] provide an integrated use of etags (finding one, re-generating the index, etc).

=== cscope ===

'''cscope''' is a much more powerful beast. While it operates on more or less the same principle (generating a file of useful metadata) it allows you do some fancier things like find all references to a symbol, see where a function is being invoked, etc.+ (you can find definitions as well).

It was originally designed for C and C++, but thanks to version 0.3 of '''pycscope''', pythonistas can make use of it.

==== usage ====

The following commands should get you running:

apt-get install cscope
pip install pycscope
# in project base dir:
find . -name '*.py' > cscope.files
cscope -R

now install the '''xcscope''' emacs package with [[ELPA]] and require it:
(require 'xcscope)

When done, you can either enable the mode with '''cscope-minor-mode''' (which will add a menu you are free to explore) or call some functions like {{Command|cscope-find-global-definition}}, {{Command|cscope-find-functions-calling-this-function}}, etc.

==== Interactivity with helm-cscope ====

You can do all that interactively with [https://github.com/sergey-pashaev/helm-cscope helm-cscope]: when you are on symbol, just call {{Command|helm-cscope-find-global-definition}} (for example) and enjoy the nice interactive interface.

== Running tests ==

Elpy has commands to run either all tests of the current buffer or only the test we are on. It supports launchers for '''Django''' (thus using "manage.py test"), '''pytest''' and '''nose'''. See http://elpy.readthedocs.io/en/latest/ide.html?highlight=django#testing

If you wish to modify the way it runs test, set the following variable:

<source lang="lisp">
(setq elpy-test-<django, nose, pytest>-runner-command '("./manage.py" "test"))
</source>

== Debugging ==

Well, let's start with the debuggers documentation:

* [https://docs.python.org/3/library/pdb.html pdb doc]
* [https://pypi.python.org/pypi/pdbpp/ pdb++] has a few more commands
* [https://pypi.python.org/pypi/ipdb ipdb] to make use of ipython (aka jupyter)

=== Ipdb, ipython debugger ===

If you call ipdb, the execution will stop and give a nice ipython-looking prompt.
Just add the line

import ipdb; ipdb.set_trace()

Now you can use the usual commands: '''c''' to continue the execution, '''n''' to execute the next one, '''s''' to step into the next function call, '''l''' to list the source code, '''!''' to execute a statement in the current context, etc.

Note: You can use [[yasnippet]] to quickly enter this sentence, or just a simple function:

<source lang="lisp">
(defun python-add-breakpoint ()
"Add a break point"
(interactive)
(newline-and-indent)
(insert "import ipdb; ipdb.set_trace()")
(highlight-lines-matching-regexp "^[ ]*import ipdb; ipdb.set_trace()"))
</source>

You can use the following to highlight this line, and not forget it :
<source lang="scheme">
; Highlight the call to ipdb
; src http://pedrokroger.com/2010/07/configuring-emacs-as-a-python-ide-2/
(defun annotate-pdb ()
(interactive)
(highlight-lines-matching-regexp "import ipdb")
(highlight-lines-matching-regexp "ipdb.set_trace()"))
(add-hook 'python-mode-hook 'annotate-pdb)
</source>

And just delete every breakpoints of the buffer:
<source lang="list">
(defun ipdb-cleanup ()
(interactive)
(save-excursion
(replace-regexp ".*ipdb.set_trace().*\n" "" nil (point-min) (point-max))
;; (save-buffer)
))
</source>

=== pdb track ===

If you use emacs-for-python given above, you can track your source code while debugging with pdbtrack.

A tool to use in a non-emacs terminal would be [https://pypi.python.org/pypi/pdbpp/ pdbpp]

=== Realgud, a front end to many debuggers to stay in the source window ===

See [https://github.com/realgud/realgud Realgud]. The goal is to call the debugger from within emacs and manipulate it ('''c'''ontinue, '''n'''ext commands, setting breakpoints, etc) within the source window.

=== Redefine the code being run in the debugger session ===

The tip in [http://wenshanren.org/?p=351 this article] makes use of the pdb feature to execute code in the context of the current stack frame with the "!" command (which can actually be omitted. See [https://docs.python.org/3/library/pdb.html the pdb doc]) and it uses an emacs package to make it much easier to write code blocks for the (i)pdb prompt (à la org-mode code blocks).

=== M-x compile and breakpoints ===

You may run your script from a real terminal, from emacs with M-x shell or with M-x compile. If you like the latter you'll notice that it hangs if you set breakpoints inside your code. The function below checks if your code has breakpoints and if so, it gives you the hand for the debugger prompt:

<source lang="lisp">
; thanks to https://masteringemacs.org/article/compiling-running-scripts-emacs (slightly modified)
(defadvice compile
(before ad-compile-smart activate)
"Advises `compile' so it sets the argument COMINT to t if breakpoints are present in `python-mode' files"
(when (derived-mode-p major-mode 'python-mode)
(save-excursion
(save-match-data (goto-char (point-min))
(if (search-forward "ipdb.set_trace()"
(point-max)
t)
(progn (ad-set-arg 1 t)
(switch-to-buffer-other-window "*compilation*")))))))
</source>
Now just run '''M-x compile''' as usual.

== Documentation ==

=== Eldoc: argument list in the echo area ===

Eldoc is a MinorMode which shows you, in the echo area, the argument list of the function call you are currently writing. It works out of the box for elisp editing and for modes that implement its support, such as python-mode. You just have to call '''eldoc-mode'''.

To always enable it:

(add-hook 'python-mode-hook 'eldoc-mode)

=== helm-pydoc ===

'''helm-pydoc''' is a little utility that lets you interactively select a module you want read the doc and displays it in another buffer.

=== pydoc linkification ===

If you've ever used the emacs lisp documentation system, you may find that the pydoc is poorer in functionnalities:
* there is no direct link to code source
* there is no "back" button

John Kitchin's pydoc aims at fixing that with more enhancements, like a bit of source fontification. See more at [http://kitchingroup.cheme.cmu.edu/blog/2014/12/20/A-new-mode-for-Python-documentation/ his presentation] and [https://github.com/jkitchin/jmax/blob/master/pydoc.el on github].

=== info format ===

Another way to read the python documentation is in the texinfo format. You'll need to install the package '''python-info''' [http://melpa.org/#/python-info on MELPA] and go through [https://bitbucket.org/jonwaltman/pydoc-info/ the installation process].

== Other tools ==

=== Virtual environments ===

Some tools allow to apply the changes of virtual environment activation inside emacs. They make '''M-x compile''' aware of the environment, etc.

* [https://github.com/porterjamesj/virtualenvwrapper.el virtualenvwrapper] emulates much of the functionnality of '''virtualenvwrapper''', integrates well with '''M-x shell''' or '''eshell''', is aware of hooks, has an automatic activation by project and integrates in the mode line.

* [https://github.com/jorgenschaefer/pyvenv pyvenv] sets the python path, uses virtualwrapper's hooks, ...

=== Pymacs ===

'''{{ModeLink|Pymacs}}''' is an Emacs extension that enables the use of Python alongside with Emacs Lisp.

[http://pymacs.progiciels-bpi.ca/index.html Pymacs homepage]

=== include import statements or remove unused ===

[[Ropemacs]] (see above) is a plugin for performing python refactorings in emacs. It uses rope library and pymacs. It has '''rope-auto-import''', so if you write

rmtree

and then execute {{Command|rope-auto-import}},

from shutil import rmtree

is inserted at the top of the file.

Unfortunately Ropemacs can not do non-relative imports, it can only create imports of the "from X import Y" variety (if you type ''shutil.rmtree'' it doesn't write ''import shutil'').

[https://github.com/Wilfred/pyimport pyimport] can add import statements or remove the unused ones (with pyflakes).

[http://elpy.readthedocs.io/en/latest/ide.html?highlight=django#refactoring Elpy] too can import missing ones.

See also [https://gitlab.com/emacs-stuff/python-import-add/ a snippet] to add many imports at once.

=== Sort import statements ===

See the '''py-isort''' [[Melpa]] package to automatically sort import statements.

=== pip-requirements mode ===

[http://melpa.org/#/pip-requirements pip-requirements] (in MELPA) is a major mode for editing pip requirements files, with the following features:
* syntax highlighting
* Auto completion of package names from PyPI
* togglable comments

=== Code coverage with Python 3 ===

There's a tool to highlight in real time the lines that are (not) covered by your unit tests. It's called [https://github.com/mattharrison/pycoverage.el pycoverage.el] and it is in [[melpa]].

== See also ==

You'll be certainly interested in the following packages (that you will find on [[ELPA]] or MELPA):

=== '''Magit''', a git interface ===

Emacs + git is magic : see [[magit]]

=== Code navigation ===

Get started with [[imenu]] and '''helm-imenu''' (see [[helm]]).

=== '''Yasnippet''', a template system ===

[[yasnippet]]

=== '''helm-pydoc''' to browse the documentation of installed packages and import one ===

=== '''pungi''' to integrate jedi, virtualenv and buildout ===

=== How to do code folding ===

See [[folding]]

=== other '''ELPA packages''' ===

If you're running Emacs with package support (usually Emacs 24 and later), check out what is available in [[ELPA]]:
; {{Command | list-packages}} : and see flymake-pyhon-pyflakes, flymake-shell, abl-mode (a python TDD minor-mode), nose (easy python test-running in emacs), visual-regexp / visual-regexp-steroids, python-magic and more.

[[Category:Programming languages]]
[[Category:Programming]]

Talk:Java

2016-09-12T08:23:34Z

Matthias: Talk about if its a good idea to have a list of java and emacs related articles

I have added a paragraph with a list of articles that talk about java editing with emacs. I hope it is filled soon and gives a nice collection of emacs and java related reading sources.

Java

2016-09-12T07:56:53Z

Matthias: Added new hopefully to be extended list of articles that talk about editing java with emacs.

'''Java''' support comes shipped with Emacs in the form of [[java-mode]].

==List of notable Java modes==
* [https://github.com/espenhw/malabar-mode malabar-mode] is a Java mode which was originally by Espen Wiborg. It has Maven integration, JUnit integration, support for Java generics, simple refactoring support and more. (no longer maintained)
* [https://github.com/jdee-emacs/jdee JDEE], Java Development Environment for Emacs, has intelligent Java code completion among other things. (jdee is currently maintained on github)
* {{ModeLink|java-mode}} provides basic Java 1.4 syntax highlighting.
* [https://github.com/senny/emacs-eclim emacs-eclim] communicates with the [http://eclim.org/ eclim] plugin in Eclipse to get a headless Eclipse instance do the heavy-lifting of completion, simple refactoring, building, and code navigation when editing files in Emacs.
* [https://github.com/mopemope/meghanada-emacs meghanada-emacs] aims to help with Gradle and Maven, code completion, jumping to declarations and more. It's based on meghanada-server written in Java, for JDB >= 1.8.

==See also ==
[[java-mode]]

==List of Java editing related Articles==
* [http://mp.vv.si/blog/emacs/coding-in-java-with-emacs-and-jdee/ jdee and checkstyle]
[[Category:Programming languages]]
[[Category:Java]]

Java

2016-09-12T07:53:57Z

Matthias: Jdee moved to github

'''Java''' support comes shipped with Emacs in the form of [[java-mode]].

==List of notable Java modes==
* [https://github.com/espenhw/malabar-mode malabar-mode] is a Java mode which was originally by Espen Wiborg. It has Maven integration, JUnit integration, support for Java generics, simple refactoring support and more. (no longer maintained)
* [https://github.com/jdee-emacs/jdee JDEE], Java Development Environment for Emacs, has intelligent Java code completion among other things. (jdee is currently maintained on github)
* {{ModeLink|java-mode}} provides basic Java 1.4 syntax highlighting.
* [https://github.com/senny/emacs-eclim emacs-eclim] communicates with the [http://eclim.org/ eclim] plugin in Eclipse to get a headless Eclipse instance do the heavy-lifting of completion, simple refactoring, building, and code navigation when editing files in Emacs.
* [https://github.com/mopemope/meghanada-emacs meghanada-emacs] aims to help with Gradle and Maven, code completion, jumping to declarations and more. It's based on meghanada-server written in Java, for JDB >= 1.8.

==See also ==
[[java-mode]]

[[Category:Programming languages]]
[[Category:Java]]