To extend this example, I wanted to use git and my github account. I can do this because github was nice enough to have port 443 available for ssh.

Like in my example before, I created a config entry for github:

host gh
     user git
     hostname ssh.github.com
     port 443
     proxycommand corkscrew my.http.proxy 8081 %h %p ~/.ssh/proxyauth

From there it’s really easy:

> git clone gh:jeffhemminger/dot-emacs.git

In such situations it’s common that you’ll be provided with an http-proxy, and this can be used if necessary to tunnel SSH.

I’ve recently had to do this, and this is how I did it, after installing corkscrew:

Create a config file in ~/.ssh

host myremoteserver
    user username
    hostname my.remote.domain
    port 443
    proxycommand corkscrew my.http.proxy 8081 %h %p ~/.ssh/proxyauth

Create an auth file containing your proxy username and password (I added mine to ~/.ssh/proxyauth in the above example)

username:password

Now, to ssh to the remote server:

ssh myremoteserver

During my daily routine I commit to a remote repo, and I update my existing repo. I regularly compare my local changes with existing ones, and I regularly look at commit history.

I rarely branch code, I rarely check out branches or commit to branches other than the trunk.

I’ve done this with CVS (which still remains my preferred vcs), Visual Source Safe, SVN, and StarTeam (which happens to be my least favorite vcs).

When I first learned about GIT a couple of years ago, I was interested to hear that it was somehow different than these other systems.

I’ve been using GIT very irregularly for the last couple of years, I have a small github account. But I haven’t used it enough to commit the standard commands (listed above) to memory. So this then is my meager attempt at doing so:
*** This assumes you’ve installed git and have configured the global settings.

• Creating a repo:

  mkdir project
  (create some code in the directory)
  cd project
  git init
  

  But wait there’s more…
  This is deceptively easy. In fact you’re more likely to want to create a local and remote repository, a la github style for example.
  In that case, you’re going to want to do this:

  1. Create a remote repo
  2. Generate your ssh-keys
  3. Git init, like above

  4. git add file_to_commit
     git commit -m 'first commit of all files added'
     git remote add origin git@github.com:user/git-repo.git
     

• Check out an existing repo:
  This is pretty straightforward, but assumes you’ve set up your ssh-keys.

   git clone [url] 

• Commit local changes:
  Once you start working, a benefit of having a local repository is that you can commit a lot, without having to worry about breaking a continuous integration environment in the process.
  This is pretty much the same as with other vcs.
  First add:

   git add somefile.txt 

  Then commit:

   commit -m 'my message' 

  Caveat:

  • It’s probably useful to add a couple of files at once, rather than one at a time:

     git add one.txt two.txt 

    or

     git add 'documentation/*.screen' 

    will recursively add all new files ending with .screen from the documentation directory

  •  git status -s 

    will tell you what has been added, and what has been changed since the add. (-s is for short format)

  • Commit changes to remote repo

     git push origin master 

• Remove stuff:

   git rm file 

  will remove the file from the staging area entirely and also off your disk.

   git rm -r dir 

  recursive delete

• Check what’s been committed:
  This is different than status because I want to know what’s different between my remote repo and my local one.

   git diff --stat master...origin

  Git will automatically figure out what the common commit of the two commit is and do the diff off of that.

Hat tips:
Git Reference – my favorite site I’ve found explaining git. It’s practical, provides examples, and the authors don’t go out of their way to make simple concepts seem complex. I’ve paraphrased a few of their examples here.

And with this change, I’ve suddenly been introduced to the world of JavaHL. So what is JavaHL? Per the previous link, it’s the Java language binding for the Subversion API. On Windows the subclipse project is able to package JavaHL, but not on other operating systems. So that’s why I’ve never had to deal with it before.

Fortunately, after finding out what JavaHL actually is, it’s pretty easy to install on Ubuntu, as you might expect:

sudo apt-get install libsvn-java

This will install JavaHL to /usr/lib/jni as a standard install, and this is where eclipse will look for it by default. If you’ve installed it in a non-standard way, you might want to look at this link regarding overwriting the java.library.path with an eclipserc file.


#!/bin/bash

echo $WORD > $TEMPFILE
aspell -c $TEMPFILE
cat $TEMPFILE
rm -f $TEMPFILE
rm -f $TEMPFILE.bak


I named this script “spell”. Simply use it like so:

$ spell reccomend


Aspell will run and you can make your changes.

reccomend

1) recommends 6) commend
2) recommend 7) recommenced
3) reckoned recommended
4) regiment 9) Redmond
5) recombined 0) rejoined
i) Ignore I) Ignore all
r) Replace R) Replace all
a) Add l) Add Lower
b) Abort x) Exit


In this case, if I type “2″, the correction will be made, aspell will exit and the spelling I chose gets printed out.

Here’s an example of how to use it with a sentence.

$ spell "I go to the storede and buy beakh clotes"


Now aspell will take you through each misspelled word. After you finish the corrections it will exit and print out the corrected sentence or series of words.

I go to the store and buy beach clothes


It’s nice to filter you list of users based on their status. If someone is offline, for example, I don’t want to see them in my list. Likewise if they’re away.

from inside mcabber, type:
/roster hide_offline

or, set an entry in your configuration. From the sample mcabber config:

# You can set up a mask to filter buddies and display them according to
# their status. The mask should contain the shortcut letters of the
# status you want to see ([o]nline, [f]ree_for_chat, [d]o_not_disturb,
# [n]ot_available, [a]way, [_]offline).
# For example, to display everybody the filter should be “ofdna_” (default).
# To display only the connected buddies, use “ofdna”.
# Please note that this option is only used at startup (once mcabber is
# running you can use “/roster display”).
#set roster_display_filter = ofdna_

! rxvt settings
rxvt*font: 12X15
rxvt*saveLines: 1500
rxvt*scrollBar_right: true

# Index
color index     cyan           black  ~l      # Mailing list
color index     yellow         black  ~N      # New
color index     yellow         black  ~O      # Old
color index     magenta        black  "! ~C ." # No To: or Cc: (newsdeliver)
color index     blue           black  ~T      # Tagged
color index     white          red    ~F      # Flagged (important)
color index     red            black  ~D      # Deleted

# Quoted messages
color quoted    yellow          black
color quoted1   red             black
color quoted2   cyan            black
color quoted3   green           black
color signature magenta         black

# Smileys:         :-/  
color body      brightwhite     black "[;:]-[)/(|]"

We’ve gone through several unit testing tools along the way trying to solve some logistical problems. We started with JSUnit, added Selenium, switched from JSUnitt to envjs, and are now using a hybrid approach I’ll describe in detail.

Some of the issues we wanted to address with our testing tools were:

• How easy is it to run the tests?
• How easy is it to debug the tests?
• How easy is it to integrate the tests into our existing continuous integration environment

Most of the tools we used easily met the first two logistical issues, but the last one was not as simple.

The following describes an approach that meets all of the above list (after the jump).

Here is a very simple JavaScript object to test and illustrate the example:

var swineFluIndicator = {
  hasSwineFlu: function(sample) {
    return !!sample.oink ? true : false;
  }
};

If the sample has a property “oink”, the sample is infected with swine flu. Simple.

To test our code in development, we used the Screw.Unit test framework.

We went with Screw.Unit for several reasons:

• Simple to implement- It’s just a JavaScript library
• It generates a simple DOM output, which makes integration easy – I’ll demonstrate later.
• It’s easy to customize, and the framework does not pollute the global namespace at all.
• It’s simple to run and debug.

Here is an example Screw.Unit test of the sample code:

Screw.Unit(function() {
  describe("test whether a given sample has swine flu", function() {
   it("clean sample", function() {
     var swineFluIndicator  = new SwineFluIndicator();
     var testSample = {
       value : '123'
     };
      expect(swineFluIndicator.hasSwineFlu(testSample)).to(be_false);
    });
  });
});

Screw.Unit tests are executed in the browser (so debugging with Firebug is easy, and produce a very simple DOM that’s simple to read:

Writing JavaScript unit tests is pretty easy; now it’s time to integrate them. HtmlUnit have released 2 new versions in 2009 so far that offer unprecedented DOM support via Rhino. With HtmlUnit, our test consists of rendering the page and interpreting the simple DOM results.

Set up the clients and load the page:

WebClient firefoxClient = new WebClient(BrowserVersion.FIREFOX_2);
WebClient ieClient = new WebClient(BrowserVersion.INTERNET_EXPLORER_6);

firefoxClient.setThrowExceptionOnScriptError(true);
ieClient.setThrowExceptionOnScriptError(true);
HtmlPage htmlPage = (HtmlPage) client.getPage(testFile.toURL());

and provide a means of interpreting the page results:

protected void interpretTestResults(final HtmlPage htmlPage) {
        String header = "";
        String heading = "";
        String paragraph = "";
        // returns a list of tests
        List testDivs = (List) htmlPage
            .getByXPath("//*[contains(@class,'describe focused')]");

        for (HtmlListItem htmlListItem : testDivs) {
            List heading1List = (List) htmlListItem.getByXPath("./h1");
            header = heading1List.get(0).getTextContent();
            // returns a list of its divisions; if there are nested
            // describes, there will be multiple its
            List test = (List) htmlListItem
                .getByXPath(".//*[contains(@class,'its')]");
            for (HtmlUnorderedList htmlUnorderedList : test) {
                // if there are no child nodes, this is part of a nested
                // describe
                if (htmlUnorderedList.hasChildNodes()) {
                    List failedItemList = (List) htmlUnorderedList
                        .getByXPath(".//*[contains(@class,'it enqueued failed')]");
                    if (failedItemList.size() == 0) {
                        // successful
                    } else {
                        for (HtmlListItem failedItem : failedItemList) {
                            List describedList = (List) failedItem
                                .getByXPath("./h2");
                            Assert.assertTrue(describedList.size() == 1);
                            heading = describedList.get(0).getTextContent();
                            List errorMessageList = (List) failedItem
                                .getByXPath("./*[contains(@class, 'error')]");
                            for (HtmlParagraph htmlParagraph : errorMessageList) {
                                paragraph += htmlParagraph.getTextContent();
                            }
                        }
                        Assert.fail("Header: " + header + " heading: " + heading + " paragraph: "
                            + paragraph);
                    }
                }
            }
        }
    }

This method takes an HtmlUnit HtmlPage and, using xpath expressions, iterates over the test result DIV tags generated by Screw.Unit. It ignores tests that passed, and focuses on the failed tests. For failed tests it gets the provided information about the test (the it and describes strings), so that we’ll know what test failed and why.

Lastly, rather than write a test for every Screw.Unit test page we write, we made use of JUnit4′s Parameterized test. This way we provide a list of Screw.Unit tests and have the Parameterized test execute a test for each.

Annotate the class:

@RunWith (Parameterized.class)
public class ScrewUnitTest {

Provide a static Collection:
@SuppressWarnings ("unchecked")
    @Parameters
    public static Collection data() {
        Collection fileCollection = new ArrayList();
        Collection fileList = FileUtils.listFiles(new File(HTML_TEST_DIR), extensions, true);
        for (File file : fileList) {
            File[] fileArray = { file };
            fileCollection.add(fileArray);
        }
        return fileCollection;
    }

and a constructor:

public ScrewUnitTest(File file) {
        this.file = file;
    }

Then for every file in the Collection, this.file will be available for reference in the tests. And our JavaScript tests can be easily run by a continuous integration system.

I’ve been using a second inbox as a todo-list, filtered on starred items. I can also prioritize tasks based on different stars.

First of all, the main screen escape key is ctrl-a. That’s all well and good, unless you’re an emacs user, then it’s downright offensive (ctrl-a is the emacs command to go to the beginning of a line- one I happen to use a lot). Fortunately it’s easy enough to change. I added a screenrc file that looks like this:

# ctrl-/ is my preferred shortcut key
escape \034\034
# turn off visual bell
vbell off
caption always "%H %= %-w%L>%{= BW}%n*%t%{-}%52<%+w %L="
startup_message off
deflogin on
shell -/bin/bash

It’s easy enough to switch between screens from a single (rxvt) shell now, but as an emacs user I naturally enjoy having my screen split so I can multitask. It took me a while to figure out how to do that effectively with screen.

ctrl-/ S splits the screen.
ctrl-/ n switches to the next screen, but does it within the current region, so it’s not like M-x o in emacs.
ctrl-/ tab switches between the split regions, just like M-x o in emacs.
ctrl-/ X “unsplits” the screen.

References

• A Quick Tutorial
• Some good screenrc tips
• Screen Cheat Sheet pdf