public class Invoker {

        public static void main(String[] args) {
                System.out.println("Invoked from: " + invoker());
                System.out.println("A bit more indirect: " + test());
        }

        private static String test() {
                return invoker();
        }

        public static String invoker() {
                try {
                        throw new RuntimeException();
                } catch(RuntimeException e) {
                        return e.getStackTrace()[1].toString();
                }
        }
}

The output format matches the Exception#printStackTrace format, so that you can click on the result in the Eclipse console and it opens the file at the correct line:

Invoked from: Invoker.main(Invoker.java:4)
A bit more indirect: Invoker.test(Invoker.java:9) 

Based on the comment attached to the code where I found this, there is an easier way to obtain the stack in Java 1.5. And with a bit of searching, I found the getStackTrace method, added to Thread in 1.5. With that, the code becomes even simpler:

public class Invoker {

        public static void main(String[] args) {
                System.out.println("Invoked from: " + invoker());
                System.out.println("A bit more indirect: " + test());
        }

        private static String test() {
                return invoker();
        }

        public static String invoker() {
                return Thread.currentThread().getStackTrace()[2].toString();
        }

} 

Note that the call to Thread#getStackTrace ends up on the stack, too, so the interesting StackTraceElement is at index 2, not 1 as before.

A final warning: While this is immensly helpful for log-based debugging, the performance hit should be kept in mind. The log4j documentation warns about that as well, though I suspect that the Java 1.5 methods will have less impact than the try-catch approach. And some very primitive benchmarking proved me wrong…

import java.util.ArrayList;
import java.util.List;

public class CommandStack {

	/**
	 * Implement for each individual change that can occur in an editor.
	 *


	 * Both {@link #execute()} and {@link #undo()} should fire property change
	 * events for notifying the editor of an update.
	 */
	public static abstract class Command {

		private String name;

		public Command(String name) {
			this.name = name;
		}

		@Override
		public String toString() {
			return name;
		}

		/**
		 * Implements the actual change.
		 *


		 * Any state-saving for {@link #undo()}
		 * has to occur elsewhere, eg. in the constructor.
		 */
		public abstract void execute();

		/**
		 * Reverts any changes applied by {@link #execute()}.
		 */
		public abstract void undo();

	}

	private final List commands = new ArrayList();
	private int currentLocation = -1;
	private int saveLocation = currentLocation;

	public void add(Command command) {
		clearInFrontOfCurrent();
		command.execute();
		commands.add(command);
		currentLocation++;
	}

	public void undo() {
		commands.get(currentLocation).undo();
		currentLocation--;
	}

	public boolean undoEnabled() {
		return currentLocation >= 0;
	}

	public void redo() {
		currentLocation++;
		commands.get(currentLocation).execute();
	}

	public boolean redoEnabled() {
		return currentLocation < commands.size() - 1;
	}

	public boolean dirty() {
		return currentLocation != saveLocation;
	}

	private void clearInFrontOfCurrent() {
		while (currentLocation < commands.size() - 1) {
			commands.remove(currentLocation + 1);
		}
	}

	public void markSaveLocation() {
		saveLocation = currentLocation;
	}

	@Override
	public String toString() {
		return commands.toString();
	}

}

And to illustrate the usage, the JUnit test:

import junit.framework.TestCase;

public class CommandStackTest extends TestCase {

	CommandStack stack = new CommandStack();

	private String name;
	private int age;

	class EditName extends Command {

		private String oldName = name;
		private String newName;

		public EditName(String newName) {
			super("Update name to " + newName);
			this.newName = newName;
		}

		public void execute() {
			name = newName;
		}

		public void undo() {
			name = oldName;
		}
	};

	class EditAge extends Command {

		private int oldAge = age;
		private int newAge;

		public EditAge(int newAge) {
			super("Update age to " + newAge);
			this.newAge = newAge;
		}

		public void execute() {
			age = newAge;
		}

		public void undo() {
			age = oldAge;
		}
	};

	public void test_basics() {
		assertNull(name);
		assertEquals(0, age);
		assertFalse(stack.dirty());
		assertFalse(stack.undoEnabled());
		assertFalse(stack.redoEnabled());

		stack.add(new EditName("Peter"));

		assertTrue(stack.dirty());
		assertEquals("Peter", name);
		assertTrue(stack.undoEnabled());
		assertFalse(stack.redoEnabled());

		stack.undo();

		assertNull(name);
		assertFalse(stack.undoEnabled());
		assertTrue(stack.redoEnabled());
		assertFalse(stack.dirty());

		stack.redo();

		assertTrue(stack.dirty());
		assertEquals("Peter", name);
		assertTrue(stack.undoEnabled());
		assertFalse(stack.redoEnabled());

		stack.markSaveLocation();

		assertFalse(stack.dirty());
		assertEquals("Peter", name);
		assertTrue(stack.undoEnabled());
		assertFalse(stack.redoEnabled());

		stack.add(new EditAge(10));

		assertTrue(stack.dirty());
		assertEquals(10, age);
		assertTrue(stack.undoEnabled());
		assertFalse(stack.redoEnabled());

		stack.undo();

		assertFalse(stack.dirty());
		assertEquals(0, age);
		assertTrue(stack.undoEnabled());
		assertTrue(stack.redoEnabled());

		stack.add(new EditName("Pan"));

		assertTrue(stack.dirty());
		assertEquals("Pan", name);
		assertEquals(0, age);
		assertTrue(stack.undoEnabled());
		assertFalse(stack.redoEnabled());

		stack.undo();
		stack.undo();

		assertTrue(stack.dirty());
		assertNull(name);
		assertEquals(0, age);
		assertFalse(stack.undoEnabled());
		assertTrue(stack.redoEnabled());

		stack.redo();
		stack.redo();

		assertTrue(stack.dirty());
		assertEquals("Pan", name);
		assertEquals(0, age);
		assertTrue(stack.undoEnabled());
		assertFalse(stack.redoEnabled());
	}

}

To start, your Eclipse plugin needs to add org.eclipse.search as a dependency, and, if you don’t have it already, org.eclipse.jface.text, too. With that, the Require-Bundle part of your MANIFEST.MF should look something like this:

Require-Bundle: org.eclipse.ui,
org.eclipse.core.runtime,
org.eclipse.ui.views,
org.eclipse.core.resources,
org.eclipse.ui.ide,
org.eclipse.ui.workbench.texteditor,
org.eclipse.text,
org.eclipse.ui.editors,
org.eclipse.search,
org.eclipse.jface.text

Next, we’ll specify the extension for our custom search page, using the plugin.xml editor or just pasting and modifying this snippet:

<extension point="org.eclipse.search.searchPages">
  <page
    class="com.acm.your.product.CustomSearchPage"
    id="yourplugin.page1"
    label="Your Custom Search, rename this">
  </page>
</extension>

And the actual implementation, providing a textfield as input, initialized with whatever text selection is currently active (thats where the org.eclipse.jface.text dependency comes from), and doing a text search across the full workspace:

package com.acm.your.product;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.jface.dialogs.DialogPage;
import org.eclipse.jface.text.TextSelection;
import org.eclipse.search.ui.ISearchPage;
import org.eclipse.search.ui.ISearchPageContainer;
import org.eclipse.search.ui.NewSearchUI;
import org.eclipse.search.ui.text.TextSearchQueryProvider;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;

public class CustomSearchPage extends DialogPage implements ISearchPage {

	private String selected;
	private Text idText;

	public IdSearchPage() {
		super();
	}

	public IdSearchPage(String title) {
		super(title);
	}

	public boolean performAction() {
		if (idText.getText().length() == 0)
			return false;
		try {
			NewSearchUI.runQueryInBackground(TextSearchQueryProvider.getPreferred().createQuery(idText.getText()));
		} catch (IllegalArgumentException e) {
			throw new RuntimeException(e);
		} catch (CoreException e) {
			throw new RuntimeException(e);
		}
        return true;
	}

	public void setContainer(ISearchPageContainer container) {
		if (container.getSelection() instanceof TextSelection) {
			selected = ((TextSelection) container.getSelection()).getText();
		}
	}

	public void createControl(Composite parent) {
		GridLayout layout = new GridLayout(1, false);
		layout.horizontalSpacing = 5;
		layout.verticalSpacing = 5;
		parent.setLayout(layout);
		new Label(parent, 0).setText("Containing text:");
		idText = new Text(parent, SWT.BORDER);
		idText.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		if (selected != null) {
			idText.setText(selected);
			idText.setSelection(0, selected.length());
		}
		setControl(parent);
	}

	@Override
	public void setVisible(boolean visible) {
		super.setVisible(visible);
		idText.setFocus();
	}

}

You can also restrict the files to search by creating a list first, and pass that to the search provider:

package com.acm.your.product;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceProxy;
import org.eclipse.core.resources.IResourceProxyVisitor;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.jface.dialogs.DialogPage;
import org.eclipse.jface.text.TextSelection;
import org.eclipse.search.ui.ISearchPage;
import org.eclipse.search.ui.ISearchPageContainer;
import org.eclipse.search.ui.NewSearchUI;
import org.eclipse.search.ui.text.TextSearchQueryProvider;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;

public class CustomSearchPage2 extends DialogPage implements ISearchPage {

	private String selected;
	private Text idText;

	public IdSearchPage() {
		super();
	}

	public IdSearchPage(String title) {
		super(title);
	}

	public boolean performAction() {
		if (idText.getText().length() == 0)
			return false;
		try {
			final List files = new ArrayList();
			ResourcesPlugin.getWorkspace().getRoot().accept(new IResourceProxyVisitor() {
				public boolean visit(IResourceProxy proxy) throws CoreException {
					if (proxy.getType() == IResource.FILE) {
						IFile file = (IFile) proxy.requestResource();
			            if (file.getLocation().getFileExtension() != null && file.getLocation().getFileExtension().matches("xml|html|js|css")) {
			            	files.add(file);
			            }
			         }
			         return true;
				}
			}, IResource.DEPTH_INFINITE);
			NewSearchUI.runQueryInBackground(TextSearchQueryProvider.getPreferred().createQuery(idText.getText(), files.toArray(new IResource[0])));
		} catch (IllegalArgumentException e) {
			throw new RuntimeException(e);
		} catch (CoreException e) {
			throw new RuntimeException(e);
		}
        return true;
	}

	public void setContainer(ISearchPageContainer container) {
		if (container.getSelection() instanceof TextSelection) {
			selected = ((TextSelection) container.getSelection()).getText();
		}
	}

	public void createControl(Composite parent) {
		GridLayout layout = new GridLayout(1, false);
		layout.horizontalSpacing = 5;
		layout.verticalSpacing = 5;
		parent.setLayout(layout);
		new Label(parent, 0).setText("Containing text:");
		idText = new Text(parent, SWT.BORDER);
		idText.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
		if (selected != null) {
			idText.setText(selected);
			idText.setSelection(0, selected.length());
		}
		setControl(parent);
	}

	@Override
	public void setVisible(boolean visible) {
		super.setVisible(visible);
		idText.setFocus();
	}

}

This in itself doesn’t yet provide a lot of value, but if you actually need to build a custom search, its a good start.

Roughly based on this sort-of tutorial on the Eclipse wiki.

By creating your own keystore, you exclude the default list of trusted certificates. This is a problem when using trying to send mail to a SMTP server with a signed certificate, as that now isn’t trusted anymore. Specifically, the following exception is thrown when trying to connect to the smtp server:

javax.net.ssl.SSLHandshakeException:
sun.security.validator.ValidatorException: PKIX path building failed:
sun.security.provider.certpath.SunCertPathBuilderException:
unable to find valid certification path to requested target

To fix this, you have to import the certificate of the server you’re trying to connect to into your custom keystore. The InstallCert program is the right tool for that.

In my case, I copied the keystore file into my project root, named “jssecacerts”, and ran “java InstallCert smpt.gmail.com:465 password” (“password” is the passphrase as defined when creating the keystore). InstallCert then updates the “jssecacerts” file – now is includes my own self-signed certificate, as well as the Google one. I copied that back to where Jetty could find it, replacing the old keystore file.

Btw., to configure Spring’s JavaMailSenderImpl to use GMail as the SMTP Server:

public @Bean JavaMailSender mailSender() {
	JavaMailSenderImpl sender = new JavaMailSenderImpl();
	sender.setPort(465);
	sender.setProtocol("smtps");
	sender.setHost("smtp.gmail.com");
	sender.setUsername("your-account@gmail.com");
	sender.setPassword("your-password");
	return sender;
}

I hope this helps someone else to solve this problem in less time then I spend on it.

The bug was already fixed in Wicket’s trunk, though not yet released. The scheduled version for the release is 1.4RC2, which doesn’t help either, as I’m still working with Wicket 1.3.5 (the current stable release).

I had to somehow fix this, and I’d like to present how I got it working until we can update to 1.4: The ticket also included a patch to MockHttpServletRequest, and I needed exactly that patch. The getInputStream method isn’t final, but I couldn’t just subclass, as the code instantiating MockHttpServletRequest is quite involved. So instead, I copied the class into my project, applying the patch there. The Java classloader loads my modified version instead of the one provided by Wicket’s jar file, and the issue is resolved.

This blog is powered by PHP and I write little PHP scripts once in a while to mock a server for testing my jQuery plugins. On the other hand, I’m designing, architecting and writing a web application in Java. In the case of testing jQuery plugins and the application, the tool is the right one for the job. I’m not so sure about this blog, WordPress and PHP. Jeff’s post links to more than enough arguments why PHP isn’t the right tool…

But the quality of the programming language is a too small part of the picture. I consider the barrier to entry an important part. Its a hell of a lot easier to get started writing a PHP application. Just create a new file. Finding a hoster for that application is easy, too, and can be as cheap as a few bucks per year, literally. Setting up a shared-hosting enviroment is rather easy, too, as each PHP request runs in its own shared-nothing process.

Installing WordPress is frickin’ easy, too. Download the current release, upload it via FTP, enter DB info into a plain text file (“plain text” in contrast to verbose xml configuration buried within JNDI datesource defintions), and done!

The barrier to entry for writing and deploying Java web applications is a bit higher. Java hosting is rare and expensive. Writing a Java web application requires at least two files and one folder, one file being an XML configuration file placed inside that folder. Deploying applications heavily depends on the hosting enviroment. Usually it involves uploading a war-file via FTP or webinterface, I don’t even know how it works in shared-hosting enviroments.

A few hosters support JSPs: Just upload a .jsp file and point the URL. Pretty close to the PHP model, arguably much worse. JSPs invite you to mix HTML and Java, which is much worse then mixing HTML and PHP. A JSP has extra tags to import classes, and of course tags for SQL queries, if you are really desperate. You loose the benefits of static styping while still bearing the cost, unit-testing is somewhere between extremely hard and impossible, certainly not worth it anymore. In other words: JSPs provide no reasonable benefits over PHP.

That leaves us with a lot of work ahead to lower the barrier to entry for Java web applications. The most potential is creating applications. The create-a-file-to-create-an-application mode is as easy as it gets, so we’d need some abstraction that allow you to create a servlet application with just one file, and no xml configuration, please.

Once creation is a matter of creating a file, deploying should boil down to uploading that file. Once that is possible, hosting will improve – its than a matter of supply and demand.

I hava few ideas for the necessary abstractions and will post about them. Thoughts and ideas are very welcome – maybe I’m looking in the wrong direction here.

public List<Item> bought(User user) {
	List<Item> result = new ArrayList();
	for (Item item : currentItems) {
		if (user.bought(item)) {
			result.add(item);
		}
	}
	return result;
}

def bought(user: User): List[Item] = {
	items.filter(user bought _)
}

If you are familiar with Java, which is more likely then you being familiar with Scala, you may tend to the Java-version. Scala has a different syntax for declaring types and generics, and supports closures, including anonymous parameters (the underscore).

When Closures are introduced in one of the next Java releases, JDK 7 or 8, the example could be rewritten like this:

public List<Item> bought(User user) {
	return ListUtils.filter(Item item : items) {
	   user.bought(item);
	}
}

Or with extension methods:

public List<Item> bought(User user) {
	return items.filter(Item item : ) { // <-- note the smily! thats what its all about!
	   user.bought(item);
	}
}

The interesting differences between Java with closures and Scala is the static typing: Scala inferences that items are all of type Item, so there is no need to specify that information again.

So, while the current Java Closures specification is a great step in the right direction, lead by Neil Gafter who is quite the right man for the job, it may not be worth to wait for it, if you have the choice. Its not even sure yet that we'll see that spec implemented in JDK7, and even that is at best one and a half year away.

PS: Pasting Scala code with generic types into a blog is much easier then generic Java, where you need to escape < and >

Whether the motivation behind making their labors freely available is a matter of seeking recognition, resume building, free advertising for other services, bragging rights, or just plain old-fashioned altruism, we can gratefully take advantage of these tools. jQuery is one such tool.

I think altruism is very far away from the true motivation in most cases. Most free and open source software I can think of is done because someone needed it anyway. And instead of just writing that little tool you needed that one day, why not release it to the great public under some appropiate license? If the tool is worth its code its quite likely that someone else has use for it, too. And because they don’t have to pay anything and can read and modify the source code, its very easy for them to contribute back whatever they can. And using that feedback is again helping the initial author.

You can find good hints at the eat-your-own-dogfoot principle and where it was applied and where not in a lot of open source products. Consider the update manager in Eclipse. To start with, its hidden under the Help menu. You have to manually copy&paste links from update sites into it. And you always have to choose “search for new features to install” even if you want to look for updates, because looking for updates most likely never finishes and yields no result after bugging you 20 times for a mirror to choose from a list. That is the stuff the developers (of Eclipse) mostlikely themselves don’t use, and therefore don’t care about.

On the other hand, Eclipse’ Java Development Tools is state-of-the-art: I’m using it now for almost three years and yet I find new helpful features everyday. Its refactoring support alone is worth some gold. Ever wanted to introduce a new parameter in an interface method and its four implementations? Its something very ugly when doing by hand, with Eclipse its simple as hell: Refactor -> “Change method signature”, and you’re nearly done. Learned how to use that just today.

Eclipse is backed by a big corporation (IBM) and a daily growing list of both small and big eclipse foundation members. This isn’t the case on projects like jQuery. When asking John Resig about his motivation for releasing jQuery he answered:

I’d have to say Altruism + Recognition – resume building was a nice side effect, but I didn’t think about that

And he added:

I mean, I guess if you’re wondering why open source vs. “closed source” (license-restricted). I guess, technically one could get recognition from either, but I don’t like restrictive software. I’ve grown up using open source, and benefited so much from it. It just doesn’t make sense to me to release closed software. I don’t see how it could possibly benefit me, or help others.

So for me, restricted software just doesn’t feel right – whereas open source feels very good. Helping people and feeding back into the community is really what does it for me. Seeing it do well is a nice side effect – I mean, on my web site alone I’ve released over 70 pieces of open source software. A couple have done really well – only one really took off.

So I definitely wasn’t expecting recognition, but it was nice that it happened.

As always he has some good points to argument with. I spent and keep spending a lot of time working on my jQuery plugins because I know (at least now) that I will be most likely developing web applications in the next years (though so far they are all 100% corporate intranet applications, but still running in browsers). And its great to use features of your own plugins in your own project that someone else contributed. Even questions for support help a lot, because you know where you have to improve APIs and examples.

Releasing JavaScript code as opensource is somehow natural anyway. Reading JavaScript code in the source of other’s website has been done for years now, and giving the code a property license to motivate “readers” to give feedback and contribute has helped a ton to improve the overall quality of written JavaScript by several magnitudes.

Currently I’m investigating ways to leverage those plugins on the server-side too, which is especially interesting when considering the validation plugin. John’s work on implementing a browser environment in Rhino is amazing. It already is able to run the full jQuery test suite, and the possibilities for building web application frameworks based on jQuery are daunting.

I hope I can also opensource some of the framework code I’m developing at work some time in the feature. There is already some really nice JSF and Spring related code in our repository…

Since I’m most familiar with Java, I started to mock up some classes. I’m relying on some of Java 5′s features to be able to write some nice code. Wouldn’t want to try that with 1.4.

Let’s get started with some code that actually uses jQuery

import static com.jquery.jQuery.jQuery;

import com.jquery.Element;
import com.jquery.Event;
import com.jquery.EventListener;
import com.jquery.ReadyListener;
import com.jquery.jQuery;

public class Application {

  public void main() {
    jQuery(new ReadyListener() {
      public void handle(Element document) {
        jQuery("input:checked").val("newvalue").val();

        // need to split declaration and call to click, otherwise
        // we'd get "The local variable anchors may not have been initialized"
        final jQuery anchors = jQuery("a");
        anchors.click(new EventListener() {
          public void handle(Event e) {
            e.preventDefault();
            jQuery(e.target).val("foo");
            anchors.val("bar");
          }
        });
      }
    });
  }

}

Here we have the first use of one Java 5 feature: Static imports. We’re importing the static jQuery method from the jQuery class:
import static com.jquery.jQuery.jQuery;

public interface ReadyListener {
	public void handle(Element document);
}
public interface Function {
	public void apply(Element element);
}
public interface Element {
	public String getAttribute(String name);
	public void setAttribute(String name, String value);
}
public interface EventListener {
	public void handle(Event e);
}

public abstract class Event {

	public final Element target;
	public final Element source;

	protected Event(Element source, Element target) {
		this.source = source;
		this.target = target;
	}

	public abstract void preventDefault();
	public abstract void stopPropagation();

}

public void main() {
  jQuery(new ReadyListener() {
    public void handle(Element document) {
      jQuery("input:checked").val("newvalue").val();

      // need to split declaration and call to click, otherwise
      // we'd get "The local variable anchors may not have been initialized"
      final jQuery anchors = jQuery("a");
      anchors.click(new EventListener() {
        public void handle(Event e) {
          e.preventDefault();
          jQuery(e.target).val("foo");
          anchors.val("bar");
        }
      });
    }
  });
}

final jQuery anchors = jQuery("a");
anchors.click(new EventListener() {
	public void handle(Event e) {
		e.preventDefault();
		jQuery(e.target).val("foo");
		anchors.val("bar");
	}
});

package com.jquery;

import static com.jquery.Window.document;

public class jQuery {

  // use an array instead of a list to guarantee non-destructive behaviour
  private final Element[] elements;

  // private constructors
  private jQuery(Element element) { elements = new Element[] { element }; }
  private jQuery(Element[] elements) { this.elements = elements; }

  // factories
  public static jQuery jQuery(String expression) {
    return new jQuery(document).find(expression);
  }
  public static jQuery jQuery(Element element) {
    return new jQuery(element);
  }
  public static jQuery jQuery(Element[] elements) {
    return new jQuery(elements);
  }
  public static jQuery jQuery(String expression, Element context) {
    return new jQuery(context).find(expression);
  }
  public static void jQuery(ReadyListener listener) {
    new jQuery(document).ready(listener);
  }

  // DOM ready event, manages ready list
  public void ready(ReadyListener listener) {}

  // provide access to all or a single element
  public Element[] get() { return elements; }
  public Element get(int index) { return elements[index]; }

  // find elements and return new jQuery object
  public jQuery find(String expression) { return jQuery(new Element[] {}); }

  // iterate through elements and apply a function
  public jQuery each(Function handler) {
    for (Element current : elements) {
      handler.apply(current);
    }
    return this;
  }

  // get value of first element
  public String val() { return elements[0].getAttribute("value"); }

  // set value of all elements
  public jQuery val(final String value) {
    // use each to iterate
    // actually a for loop would be more efficient here, less code
    return this.each(new Function() {
      public void apply(Element element) {
        element.setAttribute("value", value);
      }
    });
  }

  // manages click event handlers
  public jQuery click(EventListener listener) { return this; }

}