Emacs Journey

Search Your Open Buffers

2012-01-10T07:25:00.000-08:00

I've been using emacs for years, and it still amazes me how many features that I would consider "basic" I'm still learning about even now. For a while I've always thought it would be handy to search my open buffers. However, since I'm typically programming, most of the buffers I want to search are tied to files, so in the past I've just made sure all my buffers are saved and used with rgrep or find-grep-dired.

Now, I know there's a way to do what I originally wanted. Using multi-occur or multi-occur-in-matching-buffers you can search your open buffers for a regular expressing, and limit the searched buffers by regular expressing using the latter. I foresee this being very handy, and thought I'd share.

It's 2012!

2012-01-05T04:49:00.000-08:00

Where's my flying car?

Seriously, though, I haven't had much time to do much with emacs over the holidays, other than use it at work. We're still working on zf-mode, and I've improved my emacs-setup package a bit (not sure if I've ever mentioned that on this blog before, but its another emacs package I wrote).

Basically, long story short, emacs still rocks.

Pondering the future of this blog

2011-11-16T14:48:00.001-08:00

So, I'm torn on a decision about the blog. It seems that lately I'm doing so much with zf-mode that's all I really post about. That's not necessarily a bad thing. However, the point of this blog was to post neat things about emacs that I've learned or discovered, not just to post about zf-mode.

So, I'm trying to decide if I should:

a.) convert this blog to a zf-mode blog,
b.) keep this blog a combination of zf-mode and non-zf-mode posts, or
c.) create a separate blog entirely for zf-mode and continue using this blog for other miscellaneous emacs posts.

Decisions, decisions.

zf-mode features teaser #1

2011-11-16T14:30:00.001-08:00

Interactive class/method modification.

Oh yeah. That's right. Be jealous. ^_^

We're working on getting it out. I promise it will be worth the wait.

We've created a monster... and it's call zf-mode!

2011-11-01T12:44:00.000-07:00

Ok, so it's been quite a while since I've posted anything here. I've been busy. Sue me. However, I've been busy writing php apps with zf-mode. Why, you may ask? Because 1.) it's awesome, 2.) I'm testing it for bugs, and 3.) its the single most useful emacs mode I've ever used.

Here's the exciting part: I think we're getting really close to a release! I still don't have a date, but it's definitely coming. Prepare yourselves; this is not the little zf-mode you knew before. Here's just a few of the new abilities you can look forward to:

Automatic, correct line/statement breaking (with customizable options)
Integrated support for php testing using phpunit, phpcs, and phpmd
Easy navigation between files and parts of files (methods, properties, etc).
Project handling
So much more....

We're really excited about releasing zf-mode, but we really want to make sure we have as many bugs worked out as we can find prior to release. We're working on the last couple of features we want for the first release right now, so it can't be *too* long before the release. Please, be patient.

Also, just as a side note, zf-mode is now its own major-mode, no longer dependent upon using php-mode. zf-mode is currently well over 7000 lines of code (actual lines of code, not including comments or blank lines). Its hard to believe its come so far since its initial creation back in 2008 as a single function to insert a Zend_Debug::dump() statement with or without a die afterwards. My little program is all grown up!

Regular Expressions made easy!

2011-07-17T07:23:00.000-07:00

I'm still fairly new to regular expressions. I've read many tutorials and web pages on how to use them, and while I understand and remember a lot of what I read, I often find myself using regular expressions incorrectly. I often find myself writing a regular expression, testing it, finding out its wrong, and starting over.

Once again, emacs has come to my rescue! There is an emacs function called `re-builder` and it is a life saver when it comes to building regular expressions. Say you're in a buffer and trying to write a regular expression to match certain point(s) inside the buffer. Just run `M-x re-builder` and you'll get a small window below the one you're in. That is the re-builder window. It should be empty except for two double-quotes.

You can begin typing a regular expression in between the quotes and the appropriate matches to the expression will be instantly highlighted and filtered as you type! If you have any sub-expressions, they'll even be highlighted in different colors so you can see exactly what each sub-expression is matching! If you type something that is wrong, you'll know immediately since the correct match will no longer be highlighted in the buffer. Once you have the perfect regular expression, you can simply copy and paste (*ahem* sorry, kill and yank) it to where you need it, be it a function you're writing, input to an interactive function call via M-x, or somewhere else.

There are a couple of things to remember when using re-builder. If you start a grouping (brackets) or a sub-expression (parentheses), nothing will be matched or highlighted in the target buffer until you close it. So, when you're writing those, don't think its all wrong when all the highlighting goes away. re-builder just can't match anything until you close off the expression.

Secondly, when working in re-builder, you'll need to escape backslash. For instance, sub-expressions would be \\(...\\) as opposed to \(...\). However, if you are going to use the finished regular expression as an argument to, say, M-x query-replace-regexp, you'll need to remove the extra slashes (and the beginning and ending quotes, for that matter).

Also, if you need to match a newline, you can do so with [\n]. The \n needs to be in a grouping brackets. However, once again, if you'll be using the expression with, for instance, M-x query-replace-regexp, after you put the expression into the minibuffer, you'll need to delete the \n and type C-q C-j to put a literal newline in its place.

Demo video of zend-mode now available!

2011-06-27T14:17:00.000-07:00

You can check it out here on YouTube.

I'm not dead... I feel happy! Especially for my zend-mode updates!

2011-06-24T07:32:00.000-07:00

Well, I've put in quite a bit of time with zend-mode. Hopefully I'm getting close to a public release.

For those who don't know, zend-mode is a minor-mode for use with php-mode in emacs. Simple enough, right? O_o

Anyway, Zend Framework is a PHP framework that I have taken to using which incorporates a pretty strict but quite customizable MVC/templating system that just makes writing applications in PHP nicer, in my opinion. Of course, there's a lot of duplication of efforts (e.g. creating classes, creating php-doc blocks, etc) when writing PHP apps, with or without Zend.

That's why I began working on zend-mode. To make myself more productive, and boy have I succeeded. What started out as just a few elisp functions in a single file has turned into a suite of functions and customizable variables that make up what I now call zend-mode.

Don't let the name fool you, though. While zend-mode is developed with Zend in mind, it can be used by any PHP developers as there are plenty of non-Zend-specific functions and abilities, including php lint, phpunit, and phpcs support.

Like I said, I hope to be coming out with a public release soon. I'll most likely put it on Emacs Wiki. Also, I'm thinking that I may make a screencast soon basically showing zend-mode in action. Haven't decided for sure, yet, so if it doesn't happen don't sue me. If it does happen, I'll put it on my personal YouTube channel and link to it here.

P.S. shameless lulz@my own Holy Grail reference...

Back to the Terminal

2011-06-09T14:50:00.000-07:00

Well, I've decided to start using emacs via the terminal again, for a few reasons.

1.) Performance

Keeping in mind I run Mac OS X and use the emacs from MacPorts, the terminal emacs loads much quicker than Emacs.app.

2.) Portability

I've recently begun using tmux (like screen, but in my opinion better). I can run my emacs inside tmux at work, then if I need to do some work remotely, I can just ssh into my work computer and reattach the tmux session to continue my work. At least, that's the theory. Haven't actually done this yet.

3.) Because I Want To

Really, I just felt like getting back to a terminal work style, partially for reason numbers 1 and 2 above, and partially just to do it because I can.

I've had a couple of hiccups here and there, and I've definitely had to relearn and unlearn habits (its amazing how much I use the mouse, even though I consider myself a mostly keyboard kinda guy). So far, though, just about everything seems to be working.

Proper (Ansi-)Term Yank/Paste

2011-02-10T17:49:00.000-08:00

So, I've found myself using ansi-term quite a bit, including to run finch for my instant messaging needs. However, there's one main issue with which I found myself becoming frustrated: yanking (aka pasting).

Ansi-term has two "mode": line and char. One acts as a terminal would (e.g. the up arrow will scroll through the output, as in scrolling through a call to `less`), and the other acts as an emacs buffer. The default is to be in the former, which sort of traps the cursor (mostly correctly), since no raw cursor movement commands are sent to the terminal just because you click elsewhere in the buffer.

This becomes mostly frustrating because it keeps yank from working properly. For example, if I wish to copy/paste a url into an instant message to a friend using finch inside ansi-term, the paste part doesn't work unless I enter the second ansi-term "mode". However, this makes the buffer not treat anything as special (i.e. window bounds, text areas, etc) and can wreak havoc on the message I'm trying to send.

For this reason, I wrote a quick little function that allows me to yank text into a terminal properly without switch modes. I present to you, my-term-paste:


(defun my-term-paste (&optional string)
  (interactive)
  (process-send-string
   (get-buffer-process (current-buffer))
   (if string string (current-kill 0))))

Basically all this does is send the current copied text (current-kill 0) to the terminal using process-send-string which sends it as raw terminal input, as if I had manually typed each letter. The result? I can copy some text, for instance a url from Chrome, then focus my ansi-term and run (my-term-paste) to paste the copied text properly into the buffer. Very handy for those who use terminal modes in emacs.

Google Maps in Emacs

2010-11-10T20:30:00.000-08:00

Awesome. 'nuff said...

Bring out your dead!

2010-10-25T07:30:00.000-07:00

I'm not dead. Honest.

I've just been really busy with a lot of things. I hadn't posted here in a while, so I thought I'd at least let you all know that I haven't stopped. In fact, I been spending a lot of time working on a new suite for emacs that makes it a lot better for programming in PHP, especially (but not necessarily) if you use the Zend Framework.

I've still got some tweaks and testing to do, but I'm really excited about this. Trust me, when I have something I feel comfortable releasing, I will post about it here.

Until then, sorry for the lack of posts or updates.

Comment Moderation

2010-05-24T11:27:00.001-07:00

Well folks, I don't get many comments, but I do get quite a few spam comments (which I try to promptly delete). I have therefore enabled comment moderation. Please, still feel free to comment on posts, but know that the comment will not show up immediately anymore.

It saddens me that I have to do this, but at this point its less work adding proper comments than deleting spam comments.

I'm Slowly Getting ORGanized

2010-05-11T15:04:00.000-07:00

I've found myself using ORG mode a LOT lately, mostly at work. I'm really come to like it, and it has basically because my todo list for work. Of all the useful features ORG has, there is one that I never learned about until recently: links. I'm sure I should have known about these long ago, but for some reason I didn't.

Anyway, links are just what the name implies: clickable links to other places (though, the mouse is not necessary). This can be to a url, a file, or even a specific place in a file (i.e. line number, certain word, etc). I find this extremely useful as a programmer.

For example, I find a bug in a program. I place a TODO item in my org document to fix the bug. Inside the description, I can then place a link to the file where the code to be fixed is, or more specifically, I can link it to an exact function/method or even line number! Then, when I get around to that TODO item, I simply activate the link, and the file loads up, ready to fix!

There is one small caveat though. By default, org will open the file in a different window. Some might like this, but I have one main window in my emacs frame that is for working in (org files, source code, etc). So, when I've viewing my org document and activate a link, I want the file to load in that same window. A quick Google search revealed a simple fix for this: customize the variable `org-link-frame-setup` and change `file` to use the function `find-file` instead of `find-file-other-window`. Easy enough!

Robust Startup

2010-03-30T14:17:00.000-07:00

I've spent quite a bit of time working on my start-up files for emacs. Maybe its my OCD, but I want them as clean as possible (using customize and the ELPA helps) and I want as few annoyances as possible.

One thing that really annoys me is when I take my .emacs to a different computer or emacs installation, emacs tends to complain about missing libraries and such. Then it just stops loading the rest of the .emacs file and often I'm stuck with default emacs, which defeats the purpose of me using the .emacs file at all. The way I see it, if a library doesn't load, go ahead and let me know, but continue on, because the next might load just fine!

That's why I wrote the following code:


(let ((invalid-packages '())
      (invalid-found nil))
  (dolist (package-to-load packages-to-load)
    (condition-case nil
        (progn 
          (require (intern (car package-to-load)))
          (if (cdr package-to-load)
              (mapcar 'eval (cdr package-to-load))))
      (error
       (setq invalid-found t)
       (setq invalid-packages (push (car package-to-load) invalid-packages)))))
  (if invalid-found
      (progn
        (get-buffer-create "*invalid-packages*")
        (switch-to-buffer "*invalid-packages*")
        (let ((package-names ""))
          (dolist (package-name invalid-packages)
            (setq package-names (concat package-names package-name ", ")))
          (setq package-names (substring package-names 0 -2))
          (insert (concat "These packages were not loaded: " package-names "\n"))))))

I have this just before the Custom section of my .emacs file. This will take a variable called

packages-to-load

and load the libraries it references. It also will run any extra commands for a library (like turning on a mode). The defined variable looks something like this:


(setq packages-to-load 
      '(("my-setup-emacs")
        ("my-funcs" 
         (load-library "my-keymap"))
        ("hideshow")
        ("revive")
        ("uniquify")
        ("window-number")
        ("ido" 
         (ido-mode)
         (icomplete-mode 99))
        ("smex-autoloads" 
         (smex-initialize))
        ("org" 
         (setq org-directory "~/Documents/org")
         (add-hook 'org-mode-hook
                   (lambda ()
                     (auto-fill-mode t))))))

Notice I'm loading several libraries (ido, smex, my own my-setup, etc) and that some of them after post-load configurations. Ido, for instance, gets turned on and icomplete-mode gets set to 99.

Now, so far nothing is different than the standard "require package, run config". However, the difference comes when a package fails to load or an initialization fails to execute. Instead of completely stopping the execution of .emacs, the emacs stores the name of the library in a variable, then if any libraries failed by the time execution is done, a buffer called *invalid-packages* is created to tell you which libraries did not load. This way, all possible libraries will load, even if one fails.

--

Another change I've made to my .emacs is setting the load path. Its easy enough to just set each directory and sub-directory, but I found this ugly and annoying, especially when I have to load, for instance, ~/.emacs.d/org/lisp and ~/.emacs.d/org/contrib/lisp. The following code lets me just add paths to (or remove paths from) a list that will be added to the load path (relative to the given elisp directory). It makes more sense when you see/use it:


; adds the elisp directories to the load path if they are existing directories
; and not already in the load path
(let ((el-dir (file-name-as-directory "~/.emacs.d"))
      (el-subdirs (list "jira"
                        "mmm-mode" 
                        "org-6.34c/lisp"
                        "org-6.34c/contrib/lisp"
                        "php")))
  (setq load-path (cons el-dir load-path))
  (dolist (subdir el-subdirs)
    (setq dir-to-load (file-name-as-directory (concat el-dir subdir)))
    (if (file-directory-p dir-to-load)
        (unless (member dir-to-load load-path)
          (setq load-path (cons dir-to-load load-path))))))

Adding a sub-directory (for instance, ~/.emacs.d/mypackage) is as simple as adding "mypackage" to the el-subdirs list and executing the code. The code checks to make sure it doesn't place duplicates in the load-path, so running this several times will not infinitely increase the size of the load-path with paths that are already a part of the string. Also, this code checks to make sure that the sub-directory actually exists. If it doesn't , once again, emacs doesn't complain and stop executing, it just skips it and goes along its merry way.

I'm working on a nice way to be able to remove sub-directories from the list, execute the code, and have them removed from the load-path. I can think of a few ways, I just have to figure out which is most elegant.

--

A couple of other side notes:

I always have toolbars and scrollbars turned off. This can cause a problem when running emacs in a terminal. The following code takes care of that:


; get rid of scroll bars and menus
; check for each function because window-system doesn't seem to work in macosx
(if (fboundp 'toggle-scroll-bar)
    (toggle-scroll-bar nil))
(if (fboundp 'tool-bar-mode)
    (tool-bar-mode 0))

If you use ELPA like I do, they standard code they give you to place in .emacs references a particular file. If this file exists, once again, emacs complains. Wrapping this in a statement that checks for the existence of the file solves this:


(let ((elpa-dir "~/.emacs.d/elpa/package.el"))
  (if (file-exists-p elpa-dir)
      (when
          (load
           (expand-file-name "~/.emacs.d/elpa/package.el"))
        (package-initialize))))

--

Well, that all I've got for now. Stay tuned for more, and as always feel free to comment!

Seek and Hide

2009-12-21T14:49:00.000-08:00

Recently I've found myself using HideShow more. Its a package that makes it easy to hide or show blocks of code. However, I found it a bit lacking in a particular manner. I wanted to be able to hide all PHP doc blocks and the contents of all methods in a class. There's no one command in HideShow to do this, so I wrote my own (and then added it to my php-mode hook). Here's the code:


(defun hide-class-contents ()
  (interactive)
  (save-excursion
    (beginning-of-buffer)
    (while (re-search-forward "[ \t]+{\\|/\\*\\*" nil t)
      (hs-hide-block)
      (move-end-of-line nil))))

To really get a feel for what this function does, get HideShow and use it a bit, then use my function. You'll see that HideShow can do a "hide all", but in a class that simply hides everything in the class. You can do a "hide level" inside a class, but that will hide all the function's contents, but not the doc blocks. It also *will* hide the arguments to a function if they are on multiple lines. My function is, in my opinion and for my usage at least, cleaner and more exact in what i want to hide (or not hide) when first opening a php code file.

You might notice that in the regexp, I search for opening curly braces with at least one space or tab in front. I do this to bypass the opening class brace, since hiding that will hide everything in the class. Of course, this regexp can be change to meet your coding style. I put my class and function opening curly braces on the line below the definition, like this:


class SomeClass 
{
    function someFunction()
    {
    }
}

If you code like this instead (which I used to):


class SomeClass {
    function someFunction() {
    }
}

you can change the regexp to search for something like


"\\(function\\)[ \t.]+{|/\\*\\*"

I haven't tested this, but it gives you an idea for a starting point, at least. Don't take it as a copy/paste, as its probably wrong.

Of course, there's nothing saying this only for PHP, as HideShow is generic. I find this function useful and hope others will too.

Version Control Conundrum

2009-11-27T05:34:00.000-08:00

Ok, so its not really a conundrum, so much as a simple question.

Recently, I've found myself using emacs to program both on my MacBook at home, as well as my Gentoo Linux box at work. I've noticed that when I make changes to my .emacs file, add a .el file to my .emacs.d, etc. on one machine, I manually make the same changes to the other. This had made me begin thinking about putting my .emacs and .emacs.d into version control, probably either svn or git, though I'm open to others.

My question to you all is: should I just set up my own at home (on my <7MB cable connection) or are there any free version control services out there any of you would recommend? I want my data safe and secure, not shared unless I share it, and up when I need it to be.

Happy belated Thanksgiving (to all who celebrate it), and I hope the shoppers among you survive this Black Friday!

jira-mode 0.3.3 available!

2009-10-12T14:30:00.000-07:00

I have uploaded the latest version of jira-mode (0.3.3) to Emacs Wiki. Information about jira-mode, including the newest features, can be found here. The source can be downloaded here. Enjoy!

Oh yeah.... its a text editor!

2009-09-25T20:25:00.000-07:00

First off, so much for trying to have weekly posts. Sorry for slacking so bad. It's a fail on my end.

However, my lack of anything to post got me thinking. The reason I haven't posted is because I haven't really been doing anything that interesting, different, or in the spirit of learning and exploration as far as Emacs is concerned. I just haven't been playing with it. Instead, I've found myself simply using it, mostly for work. No playing around, no trying out new elisp files or functions, no new customizing.

This has been good for me, though, as its helped remind me of something that I was definitely taking for granted and almost forgetting altogether: Emacs is a text editor. It's so easy to get caught up in the fun of using Emacs as an email client, or a web browser, or a twitter client, or lots of other things and have the very base function of Emacs become overshadowed by all the extensions available.

Yes, Emacs can do lots of things (dare I say, almost anything). It even does a lot of these things extremely well (others, though, not so much). Let us not forget, though, that Emacs is, first and foremost, a really, really good text editor.

Let's Tag and Load!

2009-08-18T14:21:00.000-07:00

Not too long ago, I learned the wonders of using tags for programming projects, in my case, PHP applications. I read an article (geared towards VIM, actually) that talked about tags and how they can be used for completion, reference, etc. I was intrigued and looked into using tags for Emacs.

Before I knew it, I had tagged a project and was able to auto-complete function and variable names and could even jump to a function definition if I forgot its arguments or just needed to see its code! Very handy. However, I realized that every time I switched projects, I had to load the correct tags file. Sometimes I forgot and still have the tags for the other project loaded. Also, it was a pain having to manually load a tags file every time I switched projects. Sure, I could have one big tags file for all projects, but what if I have the same function name in both? Plus, that just seems like a waste of resources.

That prompted me to look for a way to auto-load the correct tags for a given buffer or file. I didn't really find any solutions, though I did find bits of code and script that helped me write my own. I figured I'd share this with you all so you can use or improve it.

First of all, I keep all my tags in one location, specifically a folder named "tags". I name them whatever the project is called. So inside "tags" I might have, for example, "app1", "myproject", "phpgame", etc. (All fake names, of course). I modified the linux script I got from the article above to make my tags:


#!/bin/bash
exec exuberant-ctags -e -f /path/to/tags/$1 \
-h ".php" -R \
--exclude="\.svn" \
--totals=yes \
--tag-relative=yes \
--PHP-kinds=+cf \
--regex-PHP='/abstract class ([^ ]*)/\1/c/' \
--regex-PHP='/interface ([^ ]*)/\1/c/' \
--regex-PHP='/(public |static |abstract |protected |private )+function ([^ (]*)/\2/f/'

This script will also work on Mac OS X. Windows users: sorry, you'll have to make your tags another way. You can modify this script to suit your own needs. Make sure you have exuberant-ctags installed (I don't use the etags that comes with Emacs) and check the documentation for how to change the script.

I named the script "tag-php". This script takes one argument: the tag file name to create. You go to to the top directory of the project in a terminal, and run:


$ tag-php tag-file-name

Next, I needed a way to get Emacs to load the tags for a buffer or file when I open it. That way, I'll always have the right tags for the file/buffer I'm current working on. In order for that to work, I wrote this bit of code in my .emacs file:


(setq tags-directory "/path/to/tags/")
(setq tag-list 
  (list
   (cons '"/path/to/project1" (concat tags-directory "tags1"))
   (cons '"/path/to/project2" (concat tags-directory "tags2"))))

(defun load-tags ()
  (interactive)
  (if (buffer-file-name)
      (progn
        (dolist (tag-cons tag-list)
          (if (string-match (regexp-quote (car tag-cons)) (buffer-file-name))
              (progn
                (if (not (equal tags-file-name (cdr tag-cons)))
                  (progn
                    (message (concat "loading tags" (cdr tag-cons)))
                    (setq tags-file-name nil)
                    (setq tags-table-list nil)
                    (visit-tags-table (cdr tag-cons))))))))))

(defun switch-to-buffer-and-load-tags ()
  (interactive)
  (ido-switch-buffer)
  (load-tags))

(add-hook 'find-file-hook 'load-tags)

***
Note that I typically only work on one file/buffer at a time, and only change to another via switching buffers or opening files. I never have two windows or frames with code open. That's why I only have the function running when I switch buffers or find a file. This function could probably be set to run when switching windows or frames, but I haven't tried it.
***

Anyway, the last line hooks the "load-tags" function to "find-file" so tags are loaded whenever a files is opened. The function above that is a custom buffer switching function. Since I use ido-mode and couldn't find an hook that would work (like the find-file-hook does), I wrote the function "switch-to-buffer-and-load-tags" and rebound the normal "C-x b" to perform that function instead:


(global-set-key "\C-xb" 'switch-to-buffer-and-load-tags)

Obviously, the "tags-directory" variable needs to be set to the path where the tag files are located. The "tag-list" variable is a list that associates project directories with their tag file. Just fill them in appropriately.

What happens here is that when I switch buffers or open files, load-tags looks to see if the directory of the buffer/file is one of the directories in "tag-list". If so, it loads the appropriate tags file, overwriting the previously loaded one so you don't waste resources.

Ok. You've got your tags file. You've got your directories and projects all set up in your .emacs file. You've loaded a file and the tags were automatically loaded. Now what?

The two main uses I get from tags are completion and reference. For this, Emacs actually has two built-in commands: "complete-tag" and "find-tag". I bind these to keys:


(global-set-key "\C-cj" 'find-tag)
(global-set-key [(control tab)] 'complete-tag)

When typing a function or variable name, "complete-tag" will attempt to complete the name. Simple enough.

However, "find-tag" is an interesting function. Let's say I define a function in a file. Then, in another file, I am using that function. If I put the point somewhere on the function name and call "find-tag" (which takes one argument: a tag name, in this case a function, and will default to whatever is under the point), Emacs will actually load the file where the function is defined, and put focus at the definition.

Its difficult to describe it in writing, so just go try it out! Its really neat and very handy. It's not perfect, mind you. I do suggest reading what the GNU Emacs Manual has to say about using tags in Emacs. There are more functions that I haven't covered (because I rarely make use of them).

Q&A: To dired or Not To dired

2009-08-04T07:32:00.000-07:00

Ok, emacs community, it's Q&A time. I ask the question, and you answer!

Q: It seems everywhere I look, I keep seeing people discussing dired: irc, forums, blogs, etc. I don't use dired, as I don't really see its purpose when I have a perfectly good terminal (both inside and outside of emacs). Do you use dired? If so/not, why/why not? Looking for insight here folks.

Keep in mind, I'm not looking to be swayed one way or the other, so please don't try. I just want to know what other people think of dired, how they find it useful (or not), how they use it to GTD, etc. Opinions, examples, anecdotes, references, etc. are all welcome.

jira-mode pt. 2

2009-07-10T09:42:00.000-07:00

Well, folks, you asked and I'm delivering! I've creating a page on EmacsWiki for jira-mode. There you will find information, instructions, and a link to the source code!

Many thanks go to Dave Benjamin, who first wrote jira.el and has allowed me to improve it and, basically, take over the project code and wiki page.

A bit of a bad news, though. As stated in the known issues section of the wiki page, XMLRPC (which jira-mode uses) does not support all functions, for instance, resolving tickets or changing status. There is nothing I can do about this. Therefore, as long as jira-mode uses XMLRPC, these abilities will never be available.

However, many other functions are there, and are quite usable and just a keystroke away! I figure I spend more time working on tickets (i.e. creating, commenting, assigning, etc.) than closing them anyway, so jira-mode still has some use.

So, please, check it out and let me know what you think! If anyone wants to improve on it, let me know as I am definitely interested. Also, if anyone wants to convert jira-mode to use SOAP instead of XMLRPC, by all means do! Supposedly, Jira allows SOAP access to the functions that XMLRPC can not perform.

I Got This (key)Board On Lockdown

2009-06-30T20:23:00.000-07:00

The longer I use emacs, I find myself sticking to my keyboard's home row. Even in my pre-emacs days I was already starting to ignore my mouse, but these days if I can't do something without mostly remaining on "asdf" and "jkl;", I either find a way, create a way, or (rarely) learn to deal with it (and/or try to avoid it). That is not just for emacs either. Other programs, even my tiling window manager, are all used mostly by keyboard. As you can imagine, I've learned a lot of keyboard shortcuts.

As a side note (but not a tangent, I promise!), one of the things I like about vi and vim (yeah, yeah, boo, hiss, etc.) is its use of h, j, k, and l for movement. (I don't like having to switch modes to do so, however, which requires leaving the home row to press escape [though I have read of techniques to set, for instance, 'jj' or 'jk' (typed really fast) to the same as escape for going from insert mode back to visual mode], but that's getting into tangent land, so I digress.) I like using these keys for movement because it allows me to stay on the home row and not have to move my hands to the arrow keys. While I have thought about what emacs would be like if its movement keybindings were closer to vi's (i.e. C-j instead of C-n for next-line), I've become quite accustomed to using emacs' defaults for moving around.

This, of course, sometimes requires extended and extensive holding down of the control key. This is also true when doing something like cutting/pasting lines and moving. For instance, to switch two lines of text, I have to go to the beginning of the first line then press: C-k, C-n, C-y. Of course, I don't actually press control three times, since I (improperly, I think) use only my left hand for control. I hold down control and press k, n, y, then release. While this small, three command example is no problem, sometimes I do major editing which requires holding down the control key for quite some time. This can be uncomfortable, problematic, and lead to the infamous emacs pinky, even if using caps lock as a control key.

Certain that someone else has found this a hassle and done something about it, I looked around and found control-lock. It works much like caps lock: you turn it on (with C-z) then all keys pressed are interpreted as if control is being pressed. So, instead of pressing C-n ten times to move down ten lines (I know, I know, prefix arguments and all that... this is just an example!), I can simply press C-z, then press (or hold down) n. Pressing z, which translates into C-z, exits control-lock.

I have to say, I have found control-lock extremely helpful mostly when editing a file. Typically, when I'm writing or coding, I don't do much that requires the control key except deleting a few characters and slight cursor movement. It's when I'm going back and editing that I use a lot of control commands back-to-back. That is where control-lock comes in very handy. It saves time, effort, and discomfort. I highly recommend it.

jira-mode pt. 1

2009-06-25T16:13:00.000-07:00

Well, folks, it's been only a matter of time. I've begun working on my first major mode project. Where I work we use Jira for bug tracking, ticketing, and support requests. Naturally, like any obsessed emacs user, I found myself wondering "how can I work with Jira without leaving emacs?" Of course, the first obvious answer was to use the Jira web interface via the w3m web browser in emacs. However, not everything worked.

So, I did what I always do in situations like these: I went to EmacsWiki. After a quick search I found jira.el, an elisp file for working with Jira via XMLRPC written by Dave Benjamin. I tried it out, and it worked. It is quite incomplete, though. Therefore, I decided to start adding to it.

For instance, it could get the information for a ticket, but couldn't add comments or even add new tickets. I started adding all this functionality and found myself thinking it would be great to have a jira-mode that I could set in a buffer where I could do things like press "r" to refresh a ticket, "c" to create a new one, etc. I looked around, and noone else seems to have made anything like this, so I decided I would.

As of now, I have a working mode, with some customizable faces, that can create tickets, refresh tickets, update tickets, list projects, and a few other basic functions. I am adding more and more to jira-mode and will definitely keep an update on it. I will probably re-post it back to EmacsWiki at some point. For now, I just want to get it useable and practical.

That said, I have to say, its incredibly easier to write a major mode than I had anticipated. Of course, the more complicated the application, the more complicated the mode will be to write. I'm rather pleased with what I've done so far and, as I've said, will post updates about jira-mode here as I make more breakthroughs.

So, keep an eye out for pt. 2!

Buffers and Windows and Frames, Oh My!

2009-06-16T16:13:00.000-07:00

One thing that I really like about emacs is how it manages open files (buffers) and the diversity one has in customizing the workspace. Of course, I didn't always like it. It took some getting used to, but after not that long of a time frame I got the hang of it and started to enjoy it. Soon after that, I started customizing my emacs workspace to be even more efficient and productive for me.

One thing I've found is that I really like to see everything thats going on, if possible. This is why I typically use a tiling window manager (preferably StumpWM or Ratpoison). I also try to avoid using the mouse. This has been the basis for the way I work in emacs and has led to the setup I'm current using. I run lots of processes inside emacs: Mew for email, elim for instant messaging, twitter.el for checking Twitter, ansi-term for a terminal, etc. (I'm sure I'll go into more detail on these in later posts). Of course, in order to see all these at once, I have two choices: multiple frames or multiple windows.

First things first: what emacs calls a "frame" and a "window" is opposite of what just about every other program calls them. For instance, a web browser "window" can be split into multiple "frames" (top heading, menu on the left, copyright footer, content in the middle, etc). A "window" is usually thought of as being one of the windows open in a window manager, complete with maximize, minimize, and close buttons. Emacs is the reverse. When you first open emacs, the "window" that pops up is actually called a "frame". There can be multiple frames open that can be switched between like normal "windows", using Alt-. Each of these "frames" can then be split into "windows" of various sizes. Each window can show a different (or the same) buffer: whether its a source code file, a terminal, or a web browser, whatever.

I think that most people work with mutliple frames and a few windows in some frames. I work with one maximized frame (at my work, this means 1900x1280) split into many windows, and I mean many. My current setup uses 17 different windows inside one emacs frame. (Screenshot) If I has multiple frames, I would have to Alt- a bunch of times or use the mouse to switch between the frames. My way, I can use emacs commands to switch between windows in the same frame. The basic command is C-x o (other-window) which basically moves focus to the next window. With 17 windows, that's no better than using Alt- as I would have to type C-x o many times, or prefix it with a number of times (i.e. C-u 1 0 C-x o to run other-window 10 times). The latter, of course, requires me to know exactly how many windows are in between where I am and where I want to be.

This brings me to a very useful mode I have found and was actually brought up in the comments of my last post: window-number-mode. This is a wonderful minor mode that gives each window in a frame a number (in red in the mode line by default) from the top-left to the bottom-right. You can then use a command (mine is C-x j ) to switch directly to the window with number . There is a short version allowing M-, but it has the drawback (for me, anyway) of only taking one digit, meaning it is only useful for 10 or less windows. I suggest window-number-mode to anyone who works with any number of multiple-window frames regularly.

Somehow, though, 17 windows isn't always enough to show me every buffer I have open! (Ok, granted, I don't always want to see *every* buffer, and of the 17 windows, only one is used for editing/programming). Therefore, I still have to do some buffer switching. The standard C-x b (switch-to-buffer) works fine for a bit, but I found myself wanting to type less and be more efficient. I found several switch-to-buffer modifiers and replacements, and I've come to really enjoy and rely on ido-mode. Ido-mode adds context and matching to switch-to-buffer. Using ido-mode, when I type C-x b, I get (in the echo area) a list of the files in the current directory. I can start typing to filter the list (typing 'ser' would match, for instance, User.php, server.txt, etc.). I can use C-s and C-r to cycle through the currently shown files, so if I type 'ser' and am left with User.php first and server.txt second, I can hit enter to open the first item or type C-s to "slide over" to the second item, and press enter to open it instead. Ido also has "smart matching" (I can't remember what its actually called off hand) meaning I can type U.p and basically get matches for U*.p* (i.e. User.php, Ultimate.perl, etc). One of my favorite features is that, if I want to go back a directory, I only have to type delete once instead of once for each letter in the directory name. Finally, ido-mode works when opening new files, not just switching buffers. Ido offers many other features and commands as well.

I've heard some people speak ill of ido-mode. Some people prefer iswitchb, others prefer other solutions. Ido-mode works great for me and I really enjoy it. It has definitely made switching buffers much faster, easier, and more efficient for me.

So, that's a breakdown of how I handle all of the buffers I usually have open in emacs. I hope that it provides some insight into one of many ways of Getting Things Done in emacs, even if my way is (most likely) not a very common practice.

Some Improved Navigation

2009-05-26T09:55:00.000-07:00

I've added some functions and keybindings to my .emacs file that make navigation quite a bit better for me. Of course, you can bind them to whatever you like:


(global-set-key (kbd "C-v") 'my-scroll-up)
(global-set-key (kbd "M-v") 'my-scroll-down)
(global-set-key (kbd "M-n") 'scroll-up-without-moving-point)
(global-set-key (kbd "M-p") 'scroll-down-without-moving-point)
(global-set-key "\C-xp" 'other-window-backwards)
(global-set-key (kbd "C-o") 'open-new-line)

By default, scroll-up and scroll-down will not move to the bottom or top of the buffer if you are already on the last or first page. This adds that functionality:


(defun my-scroll-up ()
  "Scroll unless on last page of buffer, in which case go to end of buffer."
  (interactive)
  (condition-case nil
      (scroll-up)
    (error 
     (goto-char (point-max)))))

(defun my-scroll-down ()
  "Scroll unless on first page of buffer, in which case go to beginning of buffer."
  (interactive)
  (condition-case nil
      (scroll-down)
    (error 
     (goto-char (point-min)))))

Sometimes its nice to scroll without moving the cursor/point. This can be done easily, I just added it as a function to I could bind it. I realize I could add it as a lambda function directly in the global-set-key call, but I prefer to have it as a separate function.


(defun scroll-up-without-moving-point ()
  "Scroll up without moving the cursor/point."
  (interactive)
  (scroll-up 1))

(defun scroll-down-without-moving-point ()
  "Scroll down without moving the cursor/point."
  (interactive)
  (scroll-down 1))

other-window is nice, but only for going forwards. This is an easy function for binding going backwards with other-window:


(defun other-window-backwards ()
  "Move to the previous window."
  (interactive)
  (other-window -1))

As blasphemous as it might be, I like a little more "vi-like" functionality when I open a new line. Try open-line in the middle of a line, then try this one to get a feel for the differences. Got this one from EmacsWiki:


(defun open-new-line (arg)
  "Move to the next line and then opens a line. See also `newline-and-indent'."
  (interactive "p")
  (beginning-of-line)
  (open-line arg)
  (when newline-and-indent
    (indent-according-to-mode)))

The Journey Begins (sort of...)

2009-05-26T09:17:00.001-07:00

Welcome to my new blog: Emacs Journey! I'd like to take some time at first to explain what this blog is and will be. (If you care, my personal blog is here.)

In the past couple of years, I have become an avid user of Emacs. I use it mostly at work to code PHP, check mail, instant message, browse the web, and be productive in a number of other ways. One thing I've learned about Emacs is that there is always something new to learn and try. These days, I spend more time on EmacsWiki than I do on Wikipedia, finding new modes, functions, and packages to try out in Emacs.

What this has lead me to believe is that Emacs is a journey, at least for me. I'm constantly updating my .emacs file and trying out different modes and .el files, and I never cease to be amazed at just how versatile Emacs can be (even the default emacs: check out artist-mode!).

However, I have a terrible memory, so I have decided to start this blog to record my experiences with Emacs for future reference. I invite anyone and everyone to read my posts and share them: new packages and elisp files I've tried, functions and macros I've written, modes I'm using (or not), etc. One caveat: I will be posting things as I discover them, so don't be surprised if one week I post how great some new package is, then the next week post about how I had to fix it or stop using it. Like I said, this is a journey, and I am inviting everyone along!

The title of this entry says "sort of". This is just my way of reminding that my emacs journey is not beginning now, just the blog I will use to keep track of it. Better late than never, right?

Finally, here's some generic information about my emacs setup: I run GNU Emacs 22.3.1 on Gentoo Linux. Any and all information posted on this site will pertain to this version only, as I can't guarantee that anything will work on previous or future versions. If I update versions, or have something to say about any other emacs version, I will make sure to clarify it.

So, off we go into the wild GNU yonder...