Scriptlandia

Extending RubyMine with JRuby script - How to use HAML/SASS converter from inside IDE (JRuby script-plugin)

2011-01-30T08:00:00.000-08:00

This post describe how to build RubyMine plugin in Ruby language. As an example it takes HAML/SASS converters and represents them as extensions to RubyMine editor.

Some links for plugin developers:

Design Patterns in Ruby

2009-02-16T08:52:00.000-08:00

Previously I wrote a post about Design Patterns in Beanshell. Now I have converted them in ruby scripts. Some of DP implementations in Ruby does not make sense because of highly dynamic nature of this language.

Creational Patterns

Abstract Factory
Builder
Factory Method
Prototype
Singleton
Singleton (corrected)
Lazy Initialization

Structural Patterns

Adapter
Bridge
Composite
Decorator
Facade
Flyweight
Proxy

Behavioral Patterns

Chain of Responsibility
Command
Domain Function
Interpreter
Iterator
Mediator
Memento
Observer
Observer with Observer library
State
Strategy
Template Method
Template Method (corrected)
Visitor

Enterprise Patterns

MVC
Data Access Object
Map-Reduce

My main sources:

1. Design Patterns in Beanshell
2. Design Patterns in Ruby : web site and the book

Use Google Translate from command line (Ruby)

2009-02-16T08:36:00.000-08:00

If you have Ruby/Gem installed on your computer, you can start using Google Translate from the command line. Just follow these instructions:

$ gem sources -a http://gems.github.com
$ gem install google-translate

Now you have "translate" command available:

$ translate list

- displays the list of supported languages

$ translate detect "hello world"

- detects language of text

$ translate en:ru "hello world"
$ translate en:ru hello world

- translates from English to Russian

$ translate ru "hello world"
$ translate ru hello world

- translated from auto-detected language to Russian.

New Versions of JLaunchPad and Scriptlandia are available for download

2008-09-22T07:41:00.000-07:00

JLaunchPad 1.0.2
Scriptlandia 2.2.5

Groovy script for building maven dependencies based on information from OSGI bundle

2008-06-17T07:19:00.000-07:00

Sometimes when you work with OSGI container outside of Exlipse, you want to have access to dependencies for a given bundle. This information is hidden within the bundle in "META-INF/MANIFEST.MF" file. By analyzing "Bundle-Version", "Import-Package", "Export-Package" attributes we can understand which dependencies are required.

Unfortunately, this work is tedious and here we'll look for the way how to make it easier. I wrote groovy script that takes OSGI bundle and eclipse home as input parameters and produces maven dependencies (with "system" scope) section. It could be used along with "maven-ant-tasks" library for "ant" scripts or, after small modification with ant directly.

Nice article on Maven: Migrating to Maven 2

2008-04-29T06:29:00.000-07:00

Migrating to Maven 2 (Part 1)
Migrating to Maven 2 (Part 2)

Announcement: New release of Scriptlandia (ver. 2.2.4)

2008-02-27T07:37:00.000-08:00

Scriptlandia is the effort to build scripting command line environment on top of JVM. The user don't have to worry how to install or configure libraries for different scripting languages. It will be done automatically, partially at installation time and partially at execution time.

This release includes:

1. Support for latest versions of languages/tools: Scala, Jython, Pnuts, Groovy, JRuby, Sleep, Scriptella, Fortress, Freemarker, Ivy, Maven.

2. Added support for new languages: Clojure, P~, YOIX, GANT (Groovy Ant);

3. Integration with JLaunchPad 1.0.1 (Added support for proxy with authenication);

4. Removing dependency on JDIC library - replacing it with builtin support from "deploy.jar";

5. Other bug fixes/improvements.

Announcement : New version of JLaunchPad 1.0.1 - universal java launcher

2008-02-26T15:46:00.000-08:00

This program tries to resolve the following challenges:

1. It gets rid of complex starting scripts to run JVM with different parameters (memory optimizers, classpath,
bootclasspath, native library path, system properties etc.). The idea is to have one universal script that fits all possible scenarios. The part that is different from one project to another is moved to configuration file. JLaunchPad provides ready to use scripts both for Windows and Unix environments that can be used by any Java program. If you need to customize the process of starting JVM, you don't modify these scripts. Instead, you make modifications in the configuration file.

For example, if you want to run your program that requires native library (*.dll), your configuration will
look something like this:

# my_prg.jlcfg
# my configuration

<java.library.path>
_path_to_your_dll_library_

<jvm.args>
-Xms256m
-Xmx512m

<launcher.class>
_your_fully_qualified_class_name_

<command.line.args>
_param1_
_param2_

You can use the following sections within your configuration file:

- "java.classpath";
- "java.endorsed.dirs";
- "java.ext.dirs";
- "java.library.path";
- "java.system.props";
- "java.bootclasspath";
- "java.bootclasspath.prepend";
- "java.bootclasspath.append";
- "jvm.args";
- "launcher.class";
- "set.variables";
- "command.line.args".

It seems that for projects with simple start scripts it's not worth using it. But JLaunchPad
offers some other features that could be useful for your project.

This part of the functionality is based (with some modification) on Java App Launcher project.

2. It downloads all dependent libraries (if necessary) from remote server and installs them locally. You don't have to install libraries manually. Once you declare the dependency, it will be downloaded and installed automatically.

It requires to have all used libraries located on remote server. It's true for all
installations that exist in WWW, but we have to organize these installations a little bit more. To eliminate infamous jar hell we want to introduce separation based on group name and version. Closest candidate that could make this organization happen is maven repository.

We have to make these changes in configuration to make it happen:

# my_prg.jlcfg
# my configuration

<launcher.class>
_special_launcher_class_

<command.line.args>
-deps.file.name=_my_deps_file_.xml

Remote maven repositories are used as the storage for libraries and maven project file is used for describing dependencies. As you can see, we try to reuse maven abilities as much as possible.

This part of functionality becomes available thanks to "bootstrap-mini" project that is
the part of maven2 source.
It provides file delivery mechanism, independent from maven2 standard delivery mechanism.

3. It builds CLASSPATH dynamically based on declared dependencies. You can put all the dependencies for your project in dependencies file. Current implementation
uses maven2 pom.xml file for describing dependencies. As an example, if you want to run JRuby engine, you need to have these files:

a). JLaunchPad configuration:

# my_prg.jlcfg
# my configuration

<launcher.class>
_special_launcher_class_

<command.line.args>
-deps.file.name=_jruby_deps_file_.xml
-main.class.name=org.jruby.Main

b). JRuby dependencies file



<project>
<modelVersion>4.0.0</modelVersion>
<groupId>org.sf.scriptlandia</groupId>
<artifactId>jruby-starter</artifactId>
<version>1.0</version>
<packaging>pom</packaging>

<name>JRuby Starter</name>
<description>JRuby Starter</description>

<dependencies>
<dependency>
<groupId>jruby</groupId>
<artifactId>jruby</artifactId>
<version>1.0.2</version>
</dependency>
</dependencies>
</project>

This functionality is possible thanks to classworlds project.

JLaunchPad's main responsibility is to integrate these 3 different approaches into one powerful solution.
Classworlds takes care of classloader management. We read dependencies files and inform classworlds about new libraries that should be added to CLASSPATH. To accomplish it, "_special_launcher_class_" should be substituted with "org.codehaus.classworlds.Launcher" class.
We only need to tell classworlds which class to run: "org.sf.jlaunchpad.JLaunchPadLauncher". This class is main integration point that performs main preparation work: it reads dependencies file, download them if required and add them dynamically to CLASSPATH. Then it tries to execute java class declared with "main.class.name" parameter.

Changes for current release:

- added proxy with authentication;

- storing configuration parameters (proxy, local repository location, remote repositories location)
in settings.xml file;

- added new examples;

- changes in installation program layout;

- other changes and improvements.

New Free Service from Google - WebCall Button

2008-02-24T16:06:00.000-08:00

If you have a blog on Google's www.blogspot.com site, you can benefit from new exciting service - WebCall Button. What does it mean?

Simply by putting this button on your web site (I don't think it's restricted with your blog only), you will get one "virtual" phone number that could redirect calls to your home, cell or work phone numbers. Or to voice mail. And sender shouldn't know your phone number at all.

Or imagine another situation. You don't want to share your home, cell and work phones. Instead, you expose your "virtual" phone number to outside world and this service will redirect all incoming calls to home, cell, work phones (or to voicemail).

You also could publish separate voice mail on your blog/web-site as embedded object.

In order to use this service you have to register your account at Grand Central. Now it's part of Google.

You can try this service by calling my home number right from my blog page at Scriptlandia blog.

Maven Archetypes as standalone program

2008-02-11T14:55:00.000-08:00

Initial Release.

This project helps to generate initial Java project layout with the help of Maven Archetypes.

It is not required to have Maven 2 preinstalled - instead it uses JLaunchPad (as part of the installation). It means that required by Maven and Maven Archetypes Plugin parts will be downloaded and installed into your local repository automatically.

All you need to do is to specify the location of Java and the location of Maven repository. If you are working behind the firewall, you have to specify proxy parameters too.

Tip: How to use Intellij IDEA and Maven 2 together for debugging and context help

2008-02-09T14:28:00.000-08:00

Latest version of Intellij IDEA has excellent integration with Maven 2. I want to explain one tip that could help you to gain productivity.

When you debug with IDEA, it's nice to have sources and javadocs for each used library registered with IDEA. If you have registered additional sources, you can debug deeper, going inside those sources. If you have registered additional javadocs, you can get context help for used classes from that libraries.

Unfortunately, this process is manual and tedious. Usually you have to do the following actions:

1. Find out on Internet sources for given library and unzip them locally.

2. Find out on Internet javadocs for given library and unzip it locally.

3. With the help of Intellij IDEA you have to register unzipped sources and javadocs.

This should be done for each external library in the project. If you have a lot of dependencies,
it'll take a lot of time.

Even if your project is dependent on other your own libraries, you still won't get sources and context helps
for them automatically. To have this support, you will do same things as what you did for external libraries -
IDEA should know where your dependent sources/javadocs are located.

Is it possible to make this process less time consuming, less painful? And the answer is: Yes.

When your project is equipped with maven's pom.xml file, you can do the following trick. Close your current
project and next time, when you try to open this project again, use pom.xml file as the project file (use "Open Project" functionality) instead of regular IDEA project file.

What happens here, IDEA is trying to resolve dependencies, defined inside maven project file and populates them back into IDEA's project (synch up). After such synchronization, IDEA is looking for sources and javadocs inside maven reopsitory. They should be located in same folder as your jar file and should have name built by special scheme. For example, my example library is located here:

${maven.local.repository}/org/google/code/maven-archetypes/1.0.0/maven-archetypes-1.0.0.jar

My sources and javadocs should be layed out in this way

${maven.local.repository}/org/google/code/maven-archetypes/1.0.0/maven-archetypes-1.0.0-sources.jar
${maven.local.repository}/org/google/code/maven-archetypes/1.0.0/maven-archetypes-1.0.0-javadoc.jar

As you can see, maven has "classifier" notion that helps us to differentiate "jar" artifact from "sources" and
"javadocs" artifacts.

Good thing is that most of new artifacts to be deployed recently into maven repositories (or at least everybody who understand it and wants to benefit from it), follow this pattern.

Now, what we have to do for our project components to be "in synch" with this pattern? Follow these steps:

1. Generate sources and javadocs with the help of "maven-source-plugin" and "maven-javadoc-plugin"
plugins:

>mvn source:jar

>mvn javadoc:jar

After the execution of these commands, 2 new files will be created. By default, you will see these files in "target" folder:

maven-archetypes-1.0.0-javadoc.jar
maven-archetypes-1.0.0-sources.jar

2. Install sources into maven repository:

mvn install:install-file ^
  -Dfile=target/yourArtifactId-yourVersion-sources.jar ^
  -DgroupId=yourGroupId ^
  -DartifactId=yourArtifactId ^
  -Dversion=yourVersion ^
  -Dpackaging=jar ^
  -Dclassifier=sources ^
  -DgeneratePom=false

3. Install javadocs into maven repository:

mvn install:install-file ^
  -Dfile=target/yourArtifactId-yourVersion-javadoc.jar ^
  -DgroupId=yourGroupId ^
  -DartifactId=yourArtifactId ^
  -Dversion=yourVersion ^
  -Dpackaging=jar ^
  -Dclassifier=javadoc ^
  -DgeneratePom=false

You can use this batch script to do all commands in one step:

rem install-jar-javadoc-sources.bat

rem 1. generate sources jar file

call mvn source:jar

rem 2. generate javadoc jar file

call mvn javadoc:jar

SET GROUP_ID=org.google.code
SET ARTIFACT_ID=maven-archetypes
SET VERSION=1.0.0

SET SOURCES_CLASSIFIER=sources
SET JAVADOC_CLASSIFIER=javadoc

rem 3. install sources jar file

call mvn install:install-file ^
  "-Dfile=target/%ARTIFACT_ID%-%VERSION%-%SOURCES_CLASSIFIER%.jar" ^
  "-DgroupId=%GROUP_ID%" ^
  "-DartifactId=%ARTIFACT_ID%" ^
  "-Dversion=%VERSION%" ^
  "-Dpackaging=jar" ^
  "-Dclassifier=%SOURCES_CLASSIFIER%" ^
  "-DgeneratePom=false"

rem 4. install javadoc jar file

call mvn install:install-file ^
  "-Dfile=target/%ARTIFACT_ID%-%VERSION%-%JAVADOC_CLASSIFIER%.jar" ^
  "-DgroupId=%GROUP_ID%" ^
  "-DartifactId=%ARTIFACT_ID%" ^
  "-Dversion=%VERSION%" ^
  "-Dpackaging=jar" ^
  "-Dclassifier=%JAVADOC_CLASSIFIER%" ^
  "-DgeneratePom=false"

You also can run these commands as Beanshell script:

// installSourcesJavadocs.bsh

import org.sf.pomreader.PomReader;
import org.apache.maven.bootstrap.model.Model;
import org.sf.scriptlandia.MavenHelper;

MavenHelper.executeMaven(null, new String[] { "source:jar" });
MavenHelper.executeMaven(null, new String[] { "javadoc:jar" });

PomReader pomReader = new PomReader();
pomReader.init();

Model model = pomReader.readModel(new File("pom.xml"));

void installArtifact(Model model, String classifier) {
  System.setProperty("file", "target/" + model.getArtifactId() + "-" + classifier + ".jar");
  System.setProperty("groupId", model.getGroupId());
  System.setProperty("artifactId", model.getArtifactId());
  System.setProperty("version", model.getVersion());
  System.setProperty("packaging", model.getPackaging());
  System.setProperty("classifier", classifier);
  System.setProperty("generatePom", "false");

  MavenHelper.executeMaven(null, new String[] { "install:install-file" });
}

installArtifact(model, "sources");
installArtifact(model, "javadoc");

In order to run this script, you have to install Scriptlandia
launcher on your computer. It will take care of downloading all required dependencies, installing them locally on your computer and then executing Beanshell script.

Design Patterns in Beanshell (ready to use)

2008-01-30T12:41:00.000-08:00

I wrote scripts in Beanshell to demonstrate each out of 23 GoF DP. It helps to see the idea behind particular DP in "compressed" format. And, of course, you can test it right away by executing the script.

Creational Patterns

Abstract Factory
Builder
Factory Method
Prototype
Singleton
Singleton (corrected)
Lazy Initialization

Structural Patterns

Adapter
Bridge
Composite
Decorator
Facade
Flyweight
Proxy

Behavioral Patterns

Chain of Responsibility
Command
Interpreter
Iterator
Mediator
Memento
Observer
State
Strategy
Template Method
Template Method (corrected)
Visitor

Enterprise Patterns

MVC
Data Access Object
Map-Reduce

My main sources:

1. Wikipedia
2. FluffyCat
3. JavaCamp
4. The Design Patterns - Java Companion (book)

New version of CafeBabe Bytecode Editor plugin (ver. 1.0.0) for Intellij IDEA

2007-12-11T11:54:00.000-08:00

This plugin integrates CafeBabe Bytecode Editor with Intellij IDEA.

Update:

1. Added implementation of ClassHound service.
2. Added implementation of Save Class File function.
3. Bug fix: disabling initial openning of plugin toolwindow.

How to use it inside Intellij IDEA:

How to use Class Viewer/Editor

- Select class file in the files tree or click on "Open File" icon within plugin toolwindow;
- Activate context menu for the selected file;
- Select "Open in CafeBabe" item from the context menu;
- Class will be disassembled and represented in CafeBabe toolwindow;
- If you want to disassemble some method, navigate to methods list, select one method
and activate context menu. Follow "Go to method body" link. You will be redirected to
"Bytecode Editor" toolwindow;
- Now you can create/delete/edit bytecode instructions;
- In constant pool you can modify UTF strings;
- If you want to get explanation for a given instruction, click on Help icon.
- If you modified the file and then trying to save it, "Save as" dialog will be initiated, allowing you to save modified class.
- You can click on "Save as" icon any time when you want to save your modifications.

How to use ClassHound

- Click on ClassHound icon - new toolwindow will be open;
- In ClassHound toolwindow select archive, then package, class, fileld or method. You can select only package
or only package class;
- By double clicking on package, class, field or method - selected item will be loaded into Class Viewer/Editor.
If it's field or method, Class File Viewer/Editor will be positioned on selected field/method;
- You can add new archive to the list of available archives - then you can explore it in standard way.

New version of Groovy language and most popular java information portals

2007-12-10T17:31:00.000-08:00

New version of Groovy language - 1.5 - had been released. Great job!

But I want to ask everybody about the efficiency of our "leaders" in information ocean of Java events. Neither "javalobby" nor "theserverside"... For the last 3 days... What's wrong? Where can we get the most up-to-date and complete information about Java events?

My selection is "javablogs.com". What about yours?

New version of maven-archetypes plugin for Intellij IDEA (1.0.2)

2007-12-05T10:34:00.000-08:00

This plugin helps to generate initial java project layout with the help of Maven Archetypes.

Update:

1. Downgrading java version to 1.5 (to be compatible for Mac users);
2. Changing appfuse version to 2.0.1;
3. Separating archetypes.xml file from jar file (make it avalilable for user modifications).

How to use it inside IDEA editor:

1. Select Working Directory;
2. Select archetype group;
3. Select archetype;
4. Enter groupId, artifactId, version for your project;
5. Click on Generate button. New project will be generated in the working directory.

New plugin for Intellij IDEA: CafeBabe Bytecode Editor plugin (ver. 0.8.0) is available for download

2007-11-28T11:20:00.000-08:00

This plugin integrates CafeBabe Bytecode Editor with Intellij IDEA.

Update:

1. Initial implementation.

How to use it inside Intellij IDEA:

- Select class file in the files tree or click on "Open File" icon within plugin toolwindow;
- Activate context menu for the selected file;
- Select "Open in CafeBabe" item from the context menu;
- Class will be disassembled and represented in CafeBabe toolwindow;
- If you want to disassemble some method, navigate to methods list, select one method
and activate context menu. Follow "Go to method body" link. You will be redirected to
"Bytecode Editor" toolwindow;
- Now you can create/delete/edit bytecode instructions;
- If you want to get explanation for a given instruction, click on Help icon.

New maven-archetypes plugin (ver. 1.0.0) is available for Intellij IDEA

2007-11-20T10:22:00.000-08:00

This plugin helps to generate initial java project layout with the help of Maven Archetypes.

Update:

1. Initial implementation.

How to use it inside IDEA editor:

1. Select Working Directory;
2. Select archetype group;
3. Select archetype;
4. Enter groupId, artifactId, version for your project;
5. Click on Generate button. New project will be generated in the working directory.

Tips for Intellij IDEA plugins developers (my bloody experience)

2007-11-17T17:09:00.000-08:00

1. How to get project with new API

Old fashion:

Project project = (Project)dataContext.getData(DataConstants.PROJECT);

New fashion:

Project project = DataKeys.PROJECT.getData(dataContext);

2. How to register tool window with new API

// Get toolwindow manager
ToolWindowManager toolWindowManager = ToolWindowManager.getInstance(project);

// Register your tool window at desired location
ToolWindow toolWindow =
        toolWindowManager.registerToolWindow("your_toolwindow_id", true, ToolWindowAnchor.RIGHT);

// Prepare content panel of your tool window (all your controls)
JPanel yourContentPanel = ...

// Get peer factory
PeerFactory peerFactory = PeerFactory.getInstance();

// Create content
Content content = peerFactory.getContentFactory().createContent(yourContentPanel, "", false);

// Add created content
toolWindow.getContentManager().addContent(content);

3. How to persist plugin properties with new API

If you did it for previous versions of IDEA, you probably have the following code:

public class YourPluginConfiguration
       implements ProjectComponent, Configurable, JDOMExternalizable {
  private final String COMPONENT_NAME = ...;

  publuc String yourProperty; // property to be persisted

  public String getComponentName() {
    return COMPONENT_NAME;
  }

  public void readExternal(Element element) throws InvalidDataException {
    DefaultJDOMExternalizer.readExternal(this, element); // load
  }

  public void writeExternal(Element element) throws WriteExternalException {
    DefaultJDOMExternalizer.writeExternal(this, element); // save
  }

}

With new API you have to do something like this:

@State(
    name = YourPluginConfiguration.COMPONENT_NAME,
    storages = {@Storage(id = "your_id", file = "$PROJECT_FILE$")}
)
public final class YourPluginConfiguration
          implements ProjectComponent, Configurable, PersistentStateComponent<YourPluginConfiguration> {
  public static final String COMPONENT_NAME = ...;

  publuc String yourProperty; // property to be persisted

  public String getComponentName() {
    return COMPONENT_NAME;
  }

  public YourPluginConfiguration getState() {
    return this; // load
  }

  public void loadState(YourPluginConfigurationstate) {
    XmlSerializerUtil.copyBean(state, this); // save
  }

}

In this example we use $PROJECT_FILE$ macro. You have to use appropriates macros according to component level.

There are 3 types of component level. Each of them has unique, only for this level macros:

- application-level components (ApplicationComponent): $APP_CONFIG$, $OPTIONS$;
- project-level components (ProjectComponent): $PROJECT_FILE$, $WORKSPACE_FILE$, $PROJECT_CONFIG_DIR$;
- module-level components (ModuleComponent): $MODULE_FILE$

4. How to register intention action

Usually intention action should be assoсiated with some analytical tool that recognizes important situation and indicates about it the user. We also can assoсiate intention action with changes in the editor.

First, your class should implement IntentionAction. Additionally, if you want to listen to editor changes,it should extend EditorAction:

public class YourIntentionAction extends EditorAction implements IntentionAction {

  public YourIntentionAction() {
    super(new YourEditorActionHandler());
  }

  private static class YourEditorActionHandler extends EditorActionHandler /* or EditorWriteActionHandler */ {

    // This method is executed every time you do modifications in the editor.
    // Wev are trying to look for selections
    public void execute(Editor editor, DataContext dataContext) {
      String searchText = null;

      SelectionModel selection = editor.getSelectionModel();
      if (selection.hasSelection()) {
        searchText = selection.getSelectedText();
      }

      if (searchText != null && searchText.trim().length() > 0) {
        // Displays pop up

        Project project = DataKeys.PROJECT.getData(dataContext);

        showPopup(project, editor, searchText);
      }
    }
  }

/**
   * Returns text to be shown in the list of available actions, if this action
   * is available.
   */
  @NotNull
  public String getText() {
    return "The text to show in the intention popup.";
  }

  /**
   * Returns the identifier of the family of intentions. This id is used to externalize
   * "auto-show" state of intentions. When user clicks on a lightbulb in intention list,
   * all intentions with the same family name get enabled/disabled. The identifier
   * is also used to locate the description and preview text for the intention.
   */
  @NotNull
  public String getFamilyName() {
    return "popup";
  }

  /**
   * Checks whether this intention is available at a caret offset in file.
   * If this method returns true, a light bulb for this intention is shown.
   */
  public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
    return editor.getSelectionModel().hasSelection();
  }

  /**
   * Called when user invokes intention. This method is called inside command.
   * If {@link #startInWriteAction()} returns true, this method is also called
   * inside write action.
   */
  public void invoke(@NotNull Project project, Editor editor, PsiFile file) throws IncorrectOperationException {
    String searchText = null;

    SelectionModel selection = editor.getSelectionModel();

    if (selection.hasSelection()) {
      searchText = selection.getSelectedText();
    }

    showPopup(project, editor, searchText);
  }

  /**
   * Indicate whether this action should be invoked inside write action.
   * Should return false if e.g. modal dialog is shown inside the action.
   * If false is returned the action itself is responsible for starting write action
   * when needed, by calling {@link com.intellij.openapi.application.Application#runWriteAction(Runnable)}.
   */
  public boolean startInWriteAction() {
    return false;
  }

private static void showPopup(Project project, Editor editor, String searchText) {
    JPanel panel = ... // Create your content here

    JBPopup jbPopup = JBPopupFactory.getInstance()
        .createComponentPopupBuilder(panel, panel)
        .setDimensionServiceKey(project, "popup", false)
        .setRequestFocus(true)
        .setResizable(true)
        .setMovable(true)
        .setTitle("Your title")
        .createPopup();

    jbPopup.showInBestPositionFor(editor);
  }

}

You have to register your intention action. If you have project component, you can do it
in projectOpened() method:

  public void projectOpened() {
    IntentionManager.getInstance().addAction(new YourIntentionAction());
  }

Useful links

1. Tutorial

2. Plugin Development FAQ

3. The Basics of Plugin Development for IntelliJ IDEA

4. IntelliJ IDEA 7.x Developers Documentation

5. IntelliJ Developing Custom Language Plugins for IntelliJ IDEA 5.0

New version of google-translate plugin for Intellij IDEA (1.0.5)

2007-11-15T12:40:00.000-08:00

Google-Translate Plug-in version 1.0.5 is available for download
using IDEA's internal Plugin Manager or directly from the IDEA plug-ins
website at http://plugins.intellij.net/plugin/?id=1460.

Update:

1. Added Translation Preview feature. Select the text for preview and then intention icon will appear. Or press
"Alt-Enter" key combination to force the intention. Another way is to click on "Translation Preview" item
in editor pop-up.
2. Removed deprecated code.

How to use it in side IDEA editor:

1. In editor select the part to be translated;
2. Select "Translate" item from the editor popup menu;
3. (hidden) "translate.google.com" web site (service) will perform actual translation;
4. Response from the service will be inserted in place of your selection.

Application template generation with "Archetypes" program (Scriptlandia, Maven2, Beanshell)

2007-09-14T13:08:00.000-07:00

Maven 2 has the notion of archetype. It is a template of a project which is combined with some user input to produce a working Maven project that has been tailored to the user's requirements.

Some other projects are trying to achieve same goal by using similar or slightly different approaches:

- AppFuse 1.x; (light) - uses Ant scripts to generate template;

- AppFuse 2.x; - uses Maven2 scripts to generate template;

- Able Project (https://svn.opensymphony.com/svn/sandbox/able);

- HSE (Hibernate, Spring, Echo2) Project;

- Archy project.

Archetypes program is based on my previous scripts (see my
previous post) and also inspired by Archy project.

All definitions of archetypes and repository locations are decoupled from source code into external xml file (archetypes.xml).

All archetypes are divided by groups. Group is the list or archetypes that has
same groupId, version (e.g. AppFuse, Maven2 or WebTidy groups).

Each archetype has name, description and version (if different from group version). All archetypes from same group are located in same repository. For example AppFuse fragment looks like:

<groups>
  ...

  <group name="Appfuse" groupId="org.appfuse" prefix="appfuse-" version="2.0-m5" >
    <archetypes>
      <archetype name="basic-jsf"
            description="Archetype for creating a web application with Hibernate, Spring and JSF"/>

      <archetype name="basic-spring"
            description="Archetype for creating a web application with Hibernate, Spring and Spring MVC"/>
      ...
    </archetypes>

    <repositories>
      <repository>http://static.appfuse.org/repository</repository>
    </repositories>
  </group>
  ...
</groups>

In order to run the application you have ho have Scriptlandia
project installed on your computer. It will take care of downloading all required dependencies, installing them locally on your computer and then executing Beanshell script. Otherwise, you have to be ready to do this manually.

Program can function in 2 modes: console and gui. For console mode you have to execute the following command:

>create-archetype.bsh -console

Program will ask the user about archetype group name and archetype name. Then, for your application, you have to specify groupId, artifactId and version. For these parameters Archetypes program will generate the resulting template in current directory.

For "gui" mode you have to execute the following command:

>create-archetype.bsh -wait

"wait" parameter is used my Scriptlandia framework to indicate that our script should wait for completion of gui/swing thread execution. Otherwise, frame will appear for very short time and just after that script execution will be terminated.

In "gui" mode you will see same input parameters, just layed out in more convenient for typical Windows user. After selecting appropriate archetype and clicking on "Create archetype" button, new project will be created in the current directory.

This program uses behind the scene
Scriptlandia API to execute maven2 tool:

ScriptlandiaHelper.executeMaven(args);

The source for this script is located here or within examples for Scriptlandia.

Hope tis program will save you time for your family and friends!

Article about JLaunchPad in German Java Magazine

2007-09-14T04:52:00.000-07:00

Sony PRS (Portable Reader System) and how to read russian books

2007-09-08T05:33:00.000-07:00

I got new gadget for my wife - Sony book reader. Unfortunately, it does not support Russian language (and any other languages except English). What to do?

The solution would be to use pdf file with embedded fonts. In order to generate pdf file I use Java pdf library that is available for everybody: iText.

In this example I will use Scriptlandia feature to download and install required dependencies automatically. I use beanshell for writing the program:

// txt2pdf.bsh

import org.sf.scriptlandia.ScriptlandiaHelper;

ScriptlandiaHelper.resolveDependencies("itext", "itext", "2.0.4");

import java.io.FileOutputStream;
import java.io.IOException;

import com.lowagie.text.*;
import com.lowagie.text.pdf.*;

if(bsh.args.length == 0) {
  print("Please specify input file.");

  return;
}

String inFileName = bsh.args[0];

int index = inFileName.indexOf(".");

String title = inFileName.substring(0, index);

String outFileName = title + ".pdf";

Document document = new Document();

// Creates a writer that listens to the document and directs a PDF-stream to a file.
PdfWriter.getInstance(document, new FileOutputStream(outFileName));

document.addTitle(title);

document.open();

BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(inFileName), "Cp1251"));

boolean done = false;

Paragraph paragraph = null;

while(!done) {
  String line = reader.readLine();

  if(line == null) {
    done = true;
  }
  else {
    BaseFont baseFont = BaseFont.createFont("c:\\windows\\fonts\\arial.ttf", "CP1251", BaseFont.EMBEDDED);
    Font font = new Font(baseFont, 28);

    if(line.startsWith(" ")) {
      paragraph = new Paragraph();
      paragraph.setLeading(28);
      document.add(paragraph);
    }

    document.add(new Chunk(" ", font));
    document.add(new Chunk(line, font));

  }
}

document.close();

This program produces simple pdf that is executed very fast on the reader comparing to standard process (text-to-word-to-pdf).

New version of Scriptlandia: 2.2.3 has been released!

2007-09-04T11:11:00.000-07:00

Problem with maven-javadoc-plugin

2007-08-31T14:50:00.000-07:00

I tried to run Maven 2.07 and maven-javadoc-plugin 2.3. Suddenly on "mvn site" I got the following error:

Failed to configure plugin parameters for: org.apache.maven.plugins:maven-javadoc-plugin:2.3

Not a number: ''

After analyzing parameters of this plugin I found only one parameter that is a number:

<parameter>
  <name>proxyPort</name>
  <type>int</type>
  ...
</parameter>

It seems that when you are not behind firewall (and, as result, have proxy port represented as empty string: ""), plugin has a bug.

Simple problem fix could be done in this way:

<reporting>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-javadoc-plugin</artifactId>

      <configuration>
        <proxyPort>0</proxyPort>
      </configuration>
    </plugin>
  </plugins>
</reporting>

ANNOUNCEMENT: JLaunchPad - next generation of java launcher

2007-08-29T15:11:00.000-07:00

I'm pleased to announce the release of new project: JLaunchPad, version 1.0.0.

This program (Java launcher) is the set of Java classes and shell scripts (Windows and Unix) for simplifying installation/launching of Java applications. Once the launcher is installed, it can be reused for starting different Java applications.

For your application you have to specify required dependencies on other Java libraries (in maven-like fashion). When application is getting executed first time, all dependencies will be downloaded and installed automatically into your local repository. For all consequent executions of the application download process is not required and the only one responsibility of the launcher is to build correct "classpath" and launch the application.

How it works? It could be explained in the following steps:

1. On the dedicated server we have Central Repository (sponsored, non-profit, for everybody in the community/ IT industry) of Java components represented in binary format. It could be a separate Java library, some convenient tool or even GUI program.

2. Each component is provided with the group name, artifact name and the version. Classifier also could be used for specifying Java version of the component (e.g. jdk15, jdk16 etc.).

3. Each component has binary artifact and could also contain (optional) sources, javadocs or other artifacts.

4. Each component describes dependencies to other components in the form of Dependencies File. As the result, we have Dependencies Tree (or Transitive Dependencies).

5. Launcher program connects to the remote Central Repositories and downloads required components to the client's computer. Then the launcher builds correct CLASSPATH and then starts up the programs.

6. All downloaded components are stored in the Local Repository - it is the mirror of
Central Repositories and it contains only required components with their dependencies.

7. If somebody wants to introduce new program, s(he) describes it in the form of dependencies,then s(he) writes the code. As the result, it is required to distribute new code only - all dependencies will be downloaded later and only "on-demand" - when it is really required.

8. "Smart" start-up program reads Dependencies File, installs all the required dependencies and then starts the original program.

This is real separation of new code from related dependencies. If your application
is, say, dependent on "jdom" library, your distribution does not have to include this file. Instead, you provide dependencies for the project and they will be downloaded automatically.

For the implementation the following projects were reused:

- classworlds project (http://dist.codehaus.org/classworlds)
- bootstrap-mini project (http://svn.apache.org/repos/asf/maven/components/tags/maven-2.0.7/bootstrap)
- Java App Launcher (https://java-app-launcher.dev.java.net)

The project has plenty of examples that explain how to use this launcher for existing applications. The benefit is that all application deliveries will be built by same
unified scenario and do not contain dependencies - they will be downloaded/reused automatically. Among examples you can see such programs as Ant, Maven 2, Tomcat, JRuby, Groovy, Intellij IDEA, Glean and some other.

Initially this idea was implemented in another project. During last few moths I was able to separate the code and represent it as standalone project.

New version of google-translate plugin for Intellij IDEA

2007-08-09T10:38:00.001-07:00

Update: it works now with the latest version of Intellij IDEA 7 (Selena; build 7118).

How to use it in side IDEA editor:

1. In editor select the part to be translated;
2. Select "Translate" item from the editor popup menu;
3. (hidden) "translate.google.com" web site (service) will perform actual translation;
4. Response from the service will be inserted in place of your selection.

New version of Scriptlandia: 2.2.1 has been released!

2007-05-05T15:26:00.000-07:00

This release includes new features and new supported languages. The full list of
supported languages include:

- Javascript (1.6R4);
- Groovy (1.1-beta1);
- Beanshell (2.0b5);
- Jelly (1.0);
- JRuby (0.9.9);
- Jython (2.2b1);
- Pnuts (1.1);
- Jaskell (1.0);
- JScheme (7.2);
- TCL (1.4.0);
- AWK (0.14);
- f3 (?.?);
- Fortress (build 156);
- Scala (2.4.0);
- Sleep (2.1-beta15);
- Janino (2.5.5);
- Scriptella (0.7);
- Velocity (1.4);
- Freemarker (2.3.9);
- Ant (1.7.0);
- Maven (2.0.6).

Scriptlandia: what is it? It's the effort to build scripting command line environment on top of JVM. The user don't have to worry how to install or configure libraries for different scripting languages. It will be done automatically at installation and/or at execution time.

This project is useful for doing fast prototyping in your favorite language without spending time at all on installation/configuration (AKA CoC - convention over Configuration). It's also good for building simple command-line tools.

How is it different, say, from scripting-for-java project?

1. It's not tied to Java 6 platform. You can use Java 5; it's possible to have this code ready for java 1.4.

2. You can specify dependencies for the language in the form of dependencies file (currently it is based on maven 2 pom.xml format). As the result, these dependencies will be downloaded automatically from the server to your local repository when it's required.

3. It's easy to build environment in which scripts are aware of each other. It can be done by adding new dependencies, not through ancient CLASSPATH approach, but rather through dependencies file.

4. Language gear is available through the file extension. Thanks to jdic project, corresponding gear will be executed, based on file extension.

5. Based on extension, different convenient programs-launchers can be assigned to existing extensions like jar, war etc. As an example, if jar represents micro-edition application, suitable launcher will be started. In another example we can associate jar file with ant script and extend available commands for jar file, but everything whatever could be expressed as ant target.

6. New extensions are introduced: .sl (scriptlandia) and .cw (classworld). They can be used for starting arbitrary programs with correct dependencies specified. See examples: "cafebabe", "jclasslib", "udoc", "jlgui" for details.

7. Ant and Maven scripts are first-class citizens: you can interpret them as yet another scripting languages.

8. Scriptlandia is integrated with Nailgun server. It means that for simple scripts you can keep JVM in-memory, drastically reducing start-up time for running scripts.

9. It is not nescessary to install all dependencies at installation time. Installer program will download and install only minimally required libraries. The rest will be downloaded when you invoke fitst time the script.

New plugin for Intellij IDEA: translate text from one language to another (translate.google.com)

2007-04-06T14:43:00.000-07:00

This plugin performs translations in Intellij IDEA Editor Window from one language to another (e.g. from Russian to Spain). It uses "http://translate.google.com" service behind the scene.

Plugin is especially convenient when you are trying to translate long i18n property files in your project for different languages.

Plugin adds "Translate" item into popup menu for the editor (also, in "Code" menu and "Generate" group). It also have separate configuration screen for selecting "from" and "to" languages.

How to use

1. Select the part to be translated;
2. Select "Translate" item from popup menu;
3. "translate.google.com" web site will perform actual translation;
4. Response from the service will be inserted in place of selection.

The project is located here.

How to build java presistence example with maven2

2007-04-04T12:52:00.000-07:00

Here I will show how to build a very simple example that uses java persistence API. In order to simplify the build process I use maven 2. As the result, example archive is very short in size and all required libraries will be downloaded automatically only when it's really required.

1. Create new Java class, where you map java class/properties to database table/fields. Java persistence annotations will do this job for us:

import javax.persistence.*;

@Entity
@Table(name = "MESSAGES")
public class Message {

  @Id @GeneratedValue @Column(name = "MESSAGE_ID")
  private Long id;

  @Column(name = "MESSAGE_TEXT")
  private String text;

  @ManyToOne(cascade = CascadeType.ALL) @JoinColumn(name = "NEXT_MESSAGE_ID")
  private Message nextMessage;

  public Message() {}

  public Message(String text) {
    this.text = text;
  }

  // getter and setter methods for java properties
  ...
}

As you can see, "Message" class is mapped to "MESSAGES" table, "id", "text" and "nextMessage" properties - to "MESSAGE_ID", "MESSAGE_TEXT" and "NEXT_MESSAGE_ID" fields.

2. Now we can create simple program that uses persistent "Message" object:

import java.util.*;
import javax.persistence.*;

public class HelloWorld {

  public static void main(String[] args) {

    // Start EntityManagerFactory
    EntityManagerFactory emf = Persistence.createEntityManagerFactory("helloworld");

    // First unit of work
    EntityManager em = emf.createEntityManager();
    EntityTransaction tx = em.getTransaction();
    tx.begin();

    Message message = new Message("Hello World with JPA");
    em.persist(message);

    tx.commit();
    em.close();

    // Second unit of work
    EntityManager newEm = emf.createEntityManager();
    EntityTransaction newTx = newEm.getTransaction();
    newTx.begin();

    List messages =
        newEm.createQuery("select m from Message m order by m.text asc").getResultList();

    System.out.println( messages.size() + " message(s) found:" );

    for (Object m : messages) {
      Message loadedMsg = (Message) m;
      System.out.println(loadedMsg.getText());
    }

    newTx.commit();
    newEm.close();

    // Shutting down the application
    emf.close();
  }

}

This example does not refer to any persistent framework directly. Instead, it uses symvolic names to get access to the framework in indirect way. In the abovementioned example we have "helloworld" name to refer to.

So, who is doing the persistence work here? We can use various frameworks here, but they should comply with java persistence API. For example, Hibernate or Toplink.

3. In this example we use Hibernate (http://hibernate.org) as persistence framework and hsqldb (http://hsqldb.org) as database. Let's take a look ad the hibernate configuration file (persistence.xml) where we describe "helloworld" factory:

<persistence xmlns="http://java.sun.com/xml/ns/persistence"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
   http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"
   version="1.0">

  

  <persistence-unit name="helloworld">

    
    <provider>org.hibernate.ejb.HibernatePersistence</provider>

    <properties>
      
      <property name="hibernate.archive.autodetection" value="class, hbm"/>

      
      <property name="hibernate.show_sql" value="true"/>
      <property name="hibernate.format_sql" value="true"/>
      <property name="use_sql_comments" value="true"/>

      <property name="hibernate.dialect" value="org.hibernate.dialect.HSQLDialect"/>

      <property name="hibernate.connection.driver_class" value="org.hsqldb.jdbcDriver"/>
      <property name="hibernate.connection.url" value="jdbc:hsqldb:file:persistence-db/test"/>
      <property name="hibernate.connection.username" value="sa"/>
      <property name="hibernate.hbm2ddl.auto" value="create"/>

      <property name="hibernate.c3p0.min_size" value="5"/>
      <property name="hibernate.c3p0.max_size" value="20"/>
      <property name="hibernate.c3p0.timeout" value="300"/>
      <property name="hibernate.c3p0.max_statements" value="50"/>
      <property name="hibernate.c3p0.idle_test_period" value="3000"/>
    </properties>
  </persistence-unit>

</persistence>

This file should be located on your CLASSPATH within META-INF directory. "hibernate.hbm2ddl.auto" property will take care of creating database table automatically.

4. Maven 2 file is responsible of downloading all dependent libraries, building correct CLASSPATH for the project and running the example (we use "exec:java" plugin for it):

<?xml version="1.0" encoding="UTF-8"?>

<project>
  <modelVersion>4.0.0</modelVersion>

  <groupId>persistence-deps</groupId>
  <artifactId>persistence-deps</artifactId>
  <version>1.0</version>

  <dependencies>
    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.0.4</version>
    </dependency>

    <dependency>
      <groupId>hsqldb</groupId>
      <artifactId>hsqldb</artifactId>
      <version>1.8.0.7</version>
    </dependency>

    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate</artifactId>
      <version>3.2.2.ga</version>
    </dependency>

    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-annotations</artifactId>
      <version>3.2.1.ga</version>
    </dependency>

    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-entitymanager</artifactId>
      <version>3.2.1.ga</version>
    </dependency>

    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-tools</artifactId>
      <version>3.2.0.beta9a</version>
    </dependency>

    <dependency>
      <groupId>c3p0</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.1</version>
    </dependency>
  </dependencies>

  <build>
    <defaultGoal>compile</defaultGoal>

    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>1.5</source>
          <target>1.5</target>
        </configuration>
      </plugin>

      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>exec-maven-plugin</artifactId>
        <executions>
          <execution>
            <goals>
              <goal>java</goal>
            </goals>
          </execution>
        </executions>

        <configuration>
          <mainClass>hello.HelloWorld</mainClass>
        </configuration>
      </plugin>
    </plugins>
  </build>

  <repositories>
    <repository>
      <id>scriptlandia-repo</id>
      <name>Scriptlandia Maven2 repository</name>
      <url>http://scriptlandia-repository.googlecode.com/svn/trunk/tools</url>
    </repository>
  </repositories>
</project>

5. Now, you can run compete example in one line:

>mvn compile exec:java

Complete example is located here.

How to compile and run Scala program with Ant and Maven 2

2007-04-03T07:15:00.001-07:00

We have small scala program:

// HelloWorld.scala

object HelloWorld {

  def main(args: Array[String]) = {
    Console.println("Hello, world!")
  }

}

and want to compile/run it. In order to do it, we have to perform some additional steps.

    Compile/run with Ant

a). Scala is preinstalled

You need to have "scala-library" and "scala compiler" libraries in order to compile Scala programs.
You can download them from Scala web site (http://scala-lang.org).

Your ant script will start with the following lines:



<property name="src.dir" value="src/main/scala"/>
<property name="build.dir" value="target/classes"/>

<property name="repository.home" value="c:/maven-repository"/>
<property name="scala-compiler.jar" value="${repository.home}/scala/scala-compiler/2.4.0/scala-compiler-2.4.0.jar"/>
<property name="scala-library.jar" value="${repository.home}/scala/scala-library/2.4.0/scala-library-2.4.0.jar"/>



<path id="scala.classpath">
  <pathelement location="${scala-compiler.jar}"/>
  <pathelement location="${scala-library.jar}"/>
</path>



<path id="project.classpath">
  <path refid="scala.classpath"/>

  <pathelement location="${build.dir}"/>
</path>



<taskdef resource="scala/tools/ant/antlib.xml">
  <classpath refid="scala.classpath"/>
</taskdef>

Now you can compile sources by using "scalac" command:



<target name="compile">
  <mkdir dir="${build.dir}"/>

  <scalac srcdir="${src.dir}" destdir="${build.dir}" classpathref="project.classpath" force="changed">
    <include name="**/*.scala"/>
  </scalac>
</target>

Once compiled, you can run scala program:



<target name="run" depends="compile">
  <java classname="scala.tools.nsc.MainGenericRunner" fork="true">
    <classpath>
      <path refid="project.classpath"/>
    </classpath>

    <arg line="HelloWorld"/>
  </java>
</target>

Run this command:

>ant run

It will compile and then run scala example.

b). scala is being installed by maven 2

If you don't want to install scala libraries manually, you can use maven tasks for ant
(see http://maven.apache.org/ant-tasks.html for further details):

<project name="scala-compile-test2" default="compile" basedir="."
         xmlns:artifact="antlib:org.apache.maven.artifact.ant">

  

  <property name="src.dir" value="src/main/scala"/>
  <property name="build.dir" value="target/classes"/>

  

  

  <artifact:localRepository id="local.repository" location="${repository.home}" layout="default"/>

  <artifact:pom file="scala-compile-test2.maven" id="maven.project" />

  <artifact:dependencies pathId="scala.classpath" filesetId="compile.fileset" useScope="compile">
    <pom refid="maven.project"/>
  </artifact:dependencies>

Steps 3-6 are the same as in previous example.

    Compile/run with Maven2

There are 2 maven plugings to work with scala sources. First plugin is implemented as
standard extension to the plexus compiler
(http://svn.codehaus.org/plexus/plexus-components/trunk/plexus-compiler/plexus-compilers).

The extension is located in the following repository:
http://scriptlandia-repository.googlecode.com/svn/trunk/languages

Another plugin for scala is implemented as regular maven plugin
(see details here: http://millstone.iodp.tamu.edu/~blambi/maven-scala-plugin).

a). plexus-compiler-scalac

First, you have to specify the location of scala sources. We'll do it with the help of
"build-helper-maven-plugin":

  <plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>build-helper-maven-plugin</artifactId>
    <executions>
      <execution>
        <id>add-source</id>
        <phase>generate-sources</phase>
        <goals>
          <goal>add-source</goal>
        </goals>
        <configuration>
          <sources>
            <source>src/main/scala</source>
          </sources>
        </configuration>
      </execution>
    </executions>
  </plugin>

Then you configure "maven-compiler-plugin" plugin:

  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <configuration>
      <compilerId>scalac</compilerId>

      <includes>
        <include>**</include>
      </includes>
    </configuration>

    <dependencies>
      <dependency>
        <groupId>org.codehaus.plexus</groupId>
        <artifactId>plexus-compiler-scalac</artifactId>
        <version>1.5.3</version>

        <scope>runtime</scope>
      </dependency>
    </dependencies>
  </plugin>

And don't forget about right repository:

  <repositories>
    <repository>
      <id>scriptlandia-repo</id>
      <name>Scriptlandia Maven2 repository</name>
      <url>http://scriptlandia-repository.googlecode.com/svn/trunk/languages</url>
    </repository>
  </repositories>

Now, compilation is easy:

>mvn compile

In order to run compiled code we'll use "exec" maven plugin:

  <plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>exec-maven-plugin</artifactId>
    <executions>
      <execution>
        <goals>
          <goal>java</goal>
        </goals>
      </execution>
    </executions>

    <configuration>
      <mainClass>HelloWorld</mainClass>
    </configuration>
  </plugin>

And run it:

>mvn exec:java

b). maven-scala-plugin

This plugin contains 2 parts: compiler and runner. It requires small configuration:

  <plugin>
    <groupId>iodp.usio</groupId>
    <artifactId>maven-scala-plugin</artifactId>

    <configuration>
      <mainClass>HelloWorld</mainClass>
    </configuration>
    <executions>
      <execution>
        <phase>compile</phase>
        <goals>
          <goal>compile</goal>
        </goals>
      </execution>
    </executions>
  </plugin>

You also have to specify the location of this plugin:

  <pluginRepositories>
    <pluginRepository>
      <id>maven2.iodp.usio</id>
      <name>IODP Maven2 Repository</name>
      <url>http://millstone.iodp.tamu.edu/maven2</url>
    </pluginRepository>
  </pluginRepositories>

Now you will be able to compile and run scala code now:

>mvn scala:compile

>mvn scala:run -DmainClass=HelloWorld

How to build completely dynamic example with Spring 2, Scriptlandia, Beanshell, Groovy and JRuby (revisited)

2007-03-28T07:38:00.000-07:00

I made small modifications to previously explained example in order to use the custom dynamic language tags from Spring 2 to define dynamic-language-backed beans. Finally, the spring configuration file looks like

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:lang="http://www.springframework.org/schema/lang"
       xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-2.0.xsd">

  
  <lang:groovy id="cat" script-source="classpath:Cat.groovy">
    <lang:property name="name" value="cat-name"/>
  </lang:groovy>

  
  <lang:jruby id="dog" script-interfaces="Animal" script-source="classpath:Dog.ruby"
              refresh-check-delay="5000"> 

    <lang:property name="name" value="dog-name"/>
  </lang:jruby>

  
  <lang:bsh id="cow" script-interfaces="Animal" script-source="classpath:Cow.bsh">
    <lang:property name="name" value="cow-name"/>
  </lang:bsh>

  
  <lang:groovy id="ant">
    <lang:inline-script>
      class Ant implements Animal {
        String name

        void makeSound() {
          println name + ": Shhh..."
        }
      }
    </lang:inline-script>
    <lang:property name="name" value="ant-name" />
  </lang:groovy>

  
  <bean id="farm" class="AnimalFarm">
    <property name="animals">
      <list>
        <ref bean="cat"/>
        <ref bean="dog"/>
        <ref bean="cow"/>
        <ref bean="ant"/>
      </list>
    </property>
  </bean>

</beans>

The final version of example is located here.

How to build completely dynamic example with Spring 2, Scriptlandia, Beanshell, Groovy and JRuby

2007-03-19T14:49:00.001-07:00

Recently, I found this project: GroovyWorks;.
It tries to use together such things as Java, Groovy, Spring 2 and Struts 2. Because Struts actions are written as Groovy scripts, it is not required to restart web application for each and every change. It is possible because of dynamic nature of Groovy language.

But still, it's not completely dynamic. Small portion of the system is written in Java and for each change in Java you have to recompile and redeploy your web application. Is it possible to make it completely dynamic?

In the following lines I will explain how to build such completely dynamic code. It is standalone application, so Struts 2 is not required. But we still want to have IoC container. Spring 2 fits for our needs, especially with new struts-scripting library, that supports 3 popular languages: Groovy, JRuby and Beanshell.

1. In order to work with scripts inside Spring 2 we have to create Java classes first. Let's create animal farm that consists of animals:

// Animal.java

public interface Animal {

public void makeSound();

}

// AnimalFarm.java

import java.util.List;

public class AnimalFarm {
private List animals;

public AnimalFarm() {
System.out.println("New Animal farm has been created.");
}

public void setAnimals(List animals) {
this.animals = animals;
}

public void wakeUp() {
for(int i=0; i < animals.size(); i++) {
Animal animal = (Animal)animals.get(i);

animal.makeSound();
}
}

}

2. Now, we can implements different animals in different languages:

// Cat.groovy

class Cat implements Animal {

void makeSound() {
println "Meow!"
}

}

# Dog.rb

require "java"

include_class("Animal")

class Dog < Animal
def makeSound
puts "Bark!!!"
end
end

Dog.new

// Cow.bsh

void makeSound() {
System.out.println("Moo...");
}

3. We'll keep all required libraries in the form of maven2 dependencies file.
Because current version of spring (2.0.3) is not compatible with jruby version 0.9.8
(see bug SPR-3255),
we have to keep reference to temporary repository:
http://scriptlandia-repository.googlecode.com/svn/trunk/patches.

4. All required beans are defined inside spring file:

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">



<beans>

<bean class="org.springframework.scripting.support.ScriptFactoryPostProcessor"/>


<bean id="cat" class="org.springframework.scripting.groovy.GroovyScriptFactory">
<constructor-arg value="file:Cat.groovy" />
</bean>


<bean id="dog" class="org.springframework.scripting.jruby.JRubyScriptFactory">
<constructor-arg value="file:Dog.ruby" />
<constructor-arg value="Animal" />
</bean>


<bean id="cow" class="org.springframework.scripting.bsh.BshScriptFactory">
<constructor-arg value="file:Cow.bsh" />
<constructor-arg value="Animal" />
</bean>


<bean id="farm" class="AnimalFarm">
<property name="animals">
<list>
<ref bean="cat"/>
<ref bean="dog"/>
<ref bean="cow"/>
</list>
</property>
</bean>
</beans>

5. The trickiest part here is how to avoid compilation of java code, making code
completely dynamic. To achieve it, we use janino library (http://www.janino.net/)
with JavaSourceClassLoader. We load class from source file, retrieve it as array of bytes
and then add this array as a class to our class loader.

To load required classes/libraries to CLASSPATH we use Scriptlandia API (http://scriptlandia.sf.net).
The complete example is represented below:

// dynamo-test.bsh

org.sf.scriptlandia.ScriptlandiaHelper.addMavenDependencies("pom.xml");

import org.sf.scriptlandia.launcher.ScriptlandiaLauncher;
import org.codehaus.janino.*;

import org.sf.scriptlandia.util.*;
import org.codehaus.classworlds.ClassRealm;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class Dynamo {
private ClassRealm classRealm;
private ApplicationContext factory;

public Dynamo(String basedir, String[] classNames, String beansFile) {
ScriptlandiaLauncher launcher = ScriptlandiaLauncher.getInstance();

classRealm = launcher.getMainRealm();

register(basedir, classNames);

factory = new FileSystemXmlApplicationContext(new String[] { basedir + "/" + beansFile });
}

private void register(String basedir, String[] classNames) {
ScriptlandiaLauncher launcher = ScriptlandiaLauncher.getInstance();

ClassLoader sourceClassloader = new JavaSourceClassLoader(
launcher.getClass().getClassLoader(), // parentClassLoader
new File[] { new File(basedir) }, // optionalSourcePath
(String) null, // optionalCharacterEncoding
DebuggingInformation.NONE // debuggingInformation
);

for(int i=0; i < classNames.length; i++) {
loadClass(classNames[i], sourceClassloader);
}
}

/**
* Loads class specified by the name.
*/
private void loadClass(String name, ClassLoader classLoader) {
String[] args = new String[] { name };

Map bytecodes = ReflectionUtil.invokePrivateMethod(
classLoader,
new Object[] { name },
JavaSourceClassLoader.class,
"generateBytecodes",
new Class[] { String.class });

classRealm.addConstituent(name, bytecodes.get(name));
}

public Object getBean(String beanName) {
return factory.getBean(beanName);
}

public static void main(String[] args) throws Exception {
// Java classes that needs to be registered.
String[] classNames = new String[] {"Animal", "AnimalFarm" };
String basedir = System.getProperty("user.dir");

Dynamo dynamo = new Dynamo(basedir, classNames, "dynamo-test.xml");

AnimalFarm animalFarm = dynamo.getBean("farm");

animalFarm.wakeUp();
}

}

Building GUI frontend for Maven2 archetype plugin (Beanshell, Swing, Scriptlandia)

2007-03-08T07:21:00.000-08:00

There are multiple archetypes available for developers:

standard Maven 2 distribution contains 5 archetypes: "archetype", "j2ee-simple", "mojo", "quickstart", "site", "webapp";
AppFuse 2.0 project (http://appfuse.org) now is rewritten in form of different archetypes (8): "basic-jsf", "basic-spring", "basic-struts", "basic-tapestry", "modular-jsf", "modular-spring", "modular-struts", "modular-tapestry";
WebTide site (http://www.webtide.com/resources.jsp) published archetypes for web development (10): "ActiveMQ", "DOJO", "DWR", "JSF", "SiteMesh", "Spring", "SpringJpa", "Struts", "Tapestry", "WebWork";
JPA 101 (http://jroller.com/page/cmaki?entry=jpa_maven_2_archetype) archetype ("hibernate-archetype").

How to handle this amount of different types?

I wrote simple front-end with the help of Swing and Beanshell that displays all input parameters for the project (group ID, artifact ID, version and arche-type). After selecting appropriate archetype and clicking on "Create archetype" button, new project will be created in the current directory.

The source for this script is located here: create-archetype.bsh.

This program uses behind the scene Scriptlandia API to execute maven2 tool:

ScriptlandiaHelper.executeMaven(args);

After this work is done, it's easy to create simple starters for different archetype implementations.

For starting standard maven 2 archetypes:

// maven-archetype.bsh

sourceRelative("create-archetype.bsh");

String[] archetypes = {
"archetype", "j2ee-simple", "mojo", "quickstart", "site", "webapp"
};

CreateArchetype frame = new CreateArchetype("WebTide");

frame.setArchetypes(archetypes);
frame.setArchetypeGroupId("org.apache.maven.archetypes");
frame.setArchetypeArtifactIdPrefix("maven-archetype-");
frame.setArchetypeVersion("1.0");

frame.setVisible(true);

For starting AppFuse archetypes:

// appfuse-archetype.bsh

sourceRelative("create-archetype.bsh");

String[] archetypes = {
"basic-jsf", "basic-spring", "basic-struts", "basic-tapestry",
"modular-jsf", "modular-spring", "modular-struts", "modular-tapestry"
};

CreateArchetype frame = new CreateArchetype("Appfuse");

frame.setArchetypes(archetypes);
frame.setArchetypeGroupId("org.appfuse");
frame.setArchetypeArtifactIdPrefix("appfuse-");
frame.setArchetypeVersion("1.0-m3");
frame.setRemoteRepositories("http://static.appfuse.org/repository");

frame.setVisible(true);

For starting WebTide archetypes:

// webtide-archetype.bsh
// Resource: http://www.webtide.com/resources.jsp

sourceRelative("create-archetype.bsh");

String[] archetypes = {
"ActiveMQ", "DOJO", "DWR", "JSF", "SiteMesh", "Spring", "SpringJpa", "Struts", "Tapestry", "WebWork"
};

CreateArchetype frame = new CreateArchetype("WebTide");

frame.setArchetypes(archetypes);
frame.setArchetypeGroupId("com.webtide");
frame.setArchetypeArtifactIdPrefix("maven-archetype-");
frame.setArchetypeVersion("1.0");
frame.setRemoteRepositories("http://scriptlandia-repository.googlecode.com/svn/trunk/tools");

frame.setVisible(true);

For starting Jpa 101 archetype:

// jpa-archetype.bsh

// Resource: http://jroller.com/page/cmaki?entry=jpa_maven_2_archetype

sourceRelative("create-archetype.bsh");

String[] archetypes = {
"hibernate-archetype"
};

CreateArchetype frame = new CreateArchetype("JPA");

frame.setArchetypes(archetypes);
frame.setArchetypeGroupId("com.sourcebeat");
frame.setArchetypeArtifactIdPrefix("jpa-");
frame.setArchetypeVersion("1.0-SNAPSHOT");
frame.setRemoteRepositories("http://scriptlandia-repository.googlecode.com/svn/trunk/tools");

frame.setVisible(true);

New version of Scriptlandia: 2.2.0 has been released!

2007-03-07T04:03:00.000-08:00

This release includes new features and new supported languages. The full list of
supported languages include:

- Javascript (1.6R4);
- Groovy (1.0);
- Beanshell (2.0b5);
- Jelly (1.0);
- JRuby (0.9.8);
- Jython (2.2b1);
- Pnuts (1.1);
- Jaskell (1.0);
- JScheme (7.2);
- TCL (1.4.0);
- AWK (0.14);
- f3 (?.?);
- Fortress (?.?);
- Scala (2.3.3);
- Janino (2.5.5);
- Scriptella (0.7);
- Velocity (1.4);
- Freemarker (2.3.9);
- Ant (1.7.0);
- Maven (2.0.5).

What is it: Scriptlandia? It's the effort to build environment on top of JVM. The user don't have
to worry how to install or configure libraries for different scripting languages. It will be done
automatically at installation and/or at execution time.

This project is useful for doing fast prototyping in your favorite language without spending time
on installation/configuration (aka CoC). It's also good for building simple command-line tools.

How is it different from, say scripting-for-java project?

1. It's not tied to Java 6 platform. You can use Java 5; it's possible to have this code ready for java 1.4.

2. You can specify dependencies for the language in the form of maven 2 project file. As the result, these dependencies will be downloaded automatically from the server to your local repository.

3. It's easy to build environment in which scripts are aware of each other. It can be done by adding new dependencies (not through ancient CLASSPATH approach).

4. Language gear is available through the file extension. Thanks to jdic project, corresponding
gear will be executed, based on extension.

5. Based on extension, different convenient programs-launchers can be assigned to existing extensions like jar, war etc. As an example, if jar represents micro-edition application, suitable launcher will be started. In another example we can associate jar file with ant script and extend available commands for jar file (now execute command only, see jdk documentation), but everything whatever could be expressed as ant target.

6. New extensions are introduced: .sl (scriptlandia) and .cw (classworld). They are used for starting arbitrary programs with correct dependencies specified.

7. Ant and Maven scripts are first-class citizens: you can interpret them as another scripting languages.

8. Scriptlandia is integrated with Nailgun server. It means that for simple scripts you can keep
JVM in-memory, drastically reducing start-up time for running scripts.

Excellent introduction into Maven2 for beginners

2007-03-01T09:45:00.000-08:00

Nice critical analysis of maven 2 pros and cons

2006-12-14T11:34:00.000-08:00

The pain of migrating from Ant to Maven

New JiniExamples (2.1.001) Project

2006-12-13T14:42:00.000-08:00

This new project is dedicated to Jini Technology. It is reincarnation of my very old project for Jini ver. 1.0. Now it's adapted to Jini ver. 2.1.

The project includes 22 examples, starting from simplest toward more practical examples. The advantages of this project over another similar projects are:
- up to date examples;
- ready to use Ant scripts (zero configuration);
- Maven 2 project file for automatic downloads of required dependent files.

As the result, even beginner could start examples before looking at actual sources for examples. And they are as simple as possible - I try to focus on one aspect only at the same time.

Hope it accelerates development speed as well as attracts more interest to this underestimated technology.

Structurally, all examples are divided into 3 groups:

Simple Tests

# Common tests
# Developing simple service
# Simple Remote Service over JERI
# Simple Remote Service over JERI started from configuration file
# Client as servlet/JSP
# Simple service as service UI

Advanced Tests

# Client listening for events
# Building event generator
# Administrable service
# Activatable Jeri service
# Administrable and Activatable service
# EventMailbox (mercury) example
# Norm example
# Fiddler example
# JavaSpace example
# JavaSpace (Blitz) examples
# Federate example
# Failover example

Practical Examples

# Jini and NetLib library
# Jini and Database
# Speaker service (Speech API)
# Jini Services for home (music, speech, time)

Very good introduction into Scala Language

2006-11-29T08:59:00.000-08:00

Scala is the new language that follows object-oriented and functional paradigms at the same time. There are some very useful links that could be introduction int the language:

Scala: Everything is an Object!

Scale up with Scala

Scala: Compose Classes with Mixins

Generics in Scala - Part 1

Scala Hosts a Friendly Visitor

XML Integration in Java and Scala

Closures in Java and The Other Side of Backwards Compatibility

Threadless Concurrency on the JVM - aka Scala Actors

Java Kernel (Browser Edition)

2006-09-20T10:45:00.000-07:00

It looks like Sun is trying to make right steps:

Ethan Nicholas's Blog

Feedback from Artima site

It's not only about the size, it's more about well designed system.

Another useful article about Maven 2 from Eric Redmond

2006-09-14T07:34:00.000-07:00

Grails links

2006-08-23T07:29:00.000-07:00

It seems that Grails project gains the momentum now. Some links:
Grails Home
Article about Grails: Grails + EJB Domain Models Step-by-Step

How to run Rails on JRuby

2006-08-18T14:45:00.000-07:00

Im order to do it, you have to perform the following steps.

1. Install ruby interpreter into ${ruby.home} (e.g. c:\ruby-1.8.4-20).
You can download latest version for Windows from here:

http://rubyforge.org/frs/download.php/11926/ruby184-20.exe

Test it (check ruby version):

>ruby.exe -v

Ruby installation has packaging tool called gem. Test it's version:

>gem.bat -v

2. Install rails. You can do it in one command:

>gem.bat --no-rdoc --no-ri --include-dependencies install rails

If you are behind the proxy, download gems separately and then install them individually:

>gem.bat install --no-rdoc --no-ri activesupport-1.3.1.gem
>gem.bat install --no-rdoc --no-ri activerecord-1.14.4.gem
>gem.bat install --no-rdoc --no-ri actionpack-1.12.5.gem
>gem.bat install --no-rdoc --no-ri actionmailer-1.2.5.gem
>gem.bat install --no-rdoc --no-ri actionwebservice-1.1.6.gem
>gem.bat install --no-rdoc --no-ri RbYAML-0.1.0.gem
>gem.bat install --no-rdoc --no-ri rails-1.1.6.gem

All of these gem files could be downloaded from http://rubyforge.org site.

You can also update gem tool to the latest version:

>gem.bat install --no-rdoc --no-ri rubygems-update-0.9.0.gem

Test rails version:

>rails.bat -v

3. Install jruby library into ${jruby.home} folder (e.g. c:\jruby-0.9.1).
Prepare jruby.bat script file:

SET RUBY_HOME=c:\ruby-1.8.4-20
SET JRUBY_HOME=c:\jruby-0.9.1

SET CLASSPATH=%JRUBY_HOME%\lib\jruby.jar;%JRUBY_HOME%\lib\jvyaml.jar;%JRUBY_HOME%\lib\plaincharset.jar;%JRUBY_HOME%\lib\asm.jar

java -Djruby.home=%RUBY_HOME% -Djruby.shell="cmd.exe" -Djruby.script=jruby.bat -classpath %CLASSPATH% org.jruby.Main

The trick here is that we use native ruby libraries from ruby installation (not from jruby installation).

Now you can execute all commands, required for building/running Rails application.

4. Create new project (testrails). Keep in mind that the project will be created in the current directory:

>jruby.bat c:\ruby-1.8.4-20\bin\rails testrails

Newly generated project has already some commands inside, so we need to change the current directory:

>cd testrails

5. Modify testrails\config\database.yml to point to your database. By default, it's MySQL database.

6. Start the database. Create database for devepoment: testrails_development

7. Generate the model

>jruby.bat .\script\generate controller MyTest

8. Generate the controller

>jruby.bat .\script\generate controller MyTest

9. Start the WEBrick server

>start jruby.bat .\script\server

10. Test if server is started properly in the browser:

>http://localhost:3000/my_test

Now you should see your view.

Rails on JRuby is very slow. Let's wait for improvements from JRuby team.

How to pre-compile JSP pages for Weblogic8 with Ant

2006-06-19T13:00:00.000-07:00

It can be done in similar way as for Tomcat Application Server (see this link). The only difference is: we have another JSP compiler which takes different input parameters and expects JSP pages in well specified locations. It does not "like" JSP pages within WEB-INF folder, so you need to follow this rule. Otherwise you have to copy files with "wrong" locations into "right" locations.

1. Specify "project.classpath" for your project. It will include all jars required to compile or run your project:

<path id="project.classpath">
  ...
</path>

2. Specify "weblogic.jsp.classpath". You need to have Weblogic Web Server installed ar ${weblogic.home}. You also need to specify, where you have your implementation of logging system ("${repository.home}/log4j").

  <path id="weblogic.jsp.classpath">

    

    <path refid="project.classpath"/>

    

    <fileset dir="${weblogic.home}/server/lib">
      <include name="weblogic.jar"/>
    </fileset>

    

    <fileset dir="${repository.home}/saxpath">
      <include name="saxpath-1.0-FCS.jar"/>
    </fileset>

    

    <fileset dir="${java.home}/lib">
      <include name="tools.jar"/>
    </fileset>

    <fileset dir="${java.home}/../lib">
      <include name="tools.jar"/>
    </fileset>

    

     <fileset dir="${global.repository.home}/log4j">
       <include name="log4j-1.2.8.jar"/>
     </fileset>
  </path>

3. Now we can generate Java sources for JSP files.

  <property name="jsp.src.dir" value="<the root for your JSP files>"/>
  <property name="jsp.package.name" value="<the package name for your JSPs, like com.mycompany.jsp>"/>

  <property name="build.dir" value="target/build"/>
  <property name="jsp.generated.src.dir" value="${build.dir}/jsp_sources"/>
  <property name="jsp.classes.dir" value="${build.dir}/jsp_classes"/>

  <target name="tomcat.jsp.generate">
    <mkdir dir="${jsp.generated.src.dir}"/>
    <mkdir dir="${jsp.classes.dir}"/>

    <java classname="org.apache.jasper.JspC" fork="yes">
      <classpath refid="tomcat.jsp.classpath" />

      <arg line="-uriroot ${jsp.src.dir} -d ${jsp.generated.src.dir} -p ${jsp.package.name} -webapp ${jsp.src.dir}" />
    </java>
  </target>

  <target name ="weblogic.jsp.generate">
    <mkdir dir="${jsp.generated.src.dir}"/>
    <mkdir dir="${jsp.classes.dir}"/>

    <java classname="weblogic.jspc" fork="yes">
      <classpath refid="weblogic.jsp.classpath" />

      <sysproperty key="weblogic.jsp.windows.caseSensitive" value="false"/>

      <arg line="-forceGeneration -keepgenerated -compileAll -webapp ${jsp.src.dir} -d ${jsp.generated.src.dir}"/>
    </java>
  </target>

It is very important to set "weblogic.jsp.windows.caseSensitive" to "false". At the same step Weblogic will compile Java sources into Java classes (-forceGeneration and -keepgenerated). Compiled JSP java classes will be located in same folders as JSP compiled classes. We will separate them on next step.

You don't have to specify package name for JSP pages. JSP compiler will assign default "jsp_servlet" package name for all JSP pages. Each folder will be converted with the "_" prefix plus original name, each jsp page into "__" prefix plus original name.

4. Now, it's better to separate generated Java sources from compiled files.

  <target name ="weblogic.jsp.compile" depends="weblogic.jsp.generate"
          description="Separates sources from classes">
    <move todir="${jsp.classes.dir}/jsp_servlet">
      <fileset dir="${jsp.generated.src.dir}/jsp_servlet">
        <include name="**/*.class"/>
      </fileset>
    </move>
  </target>

If, on this step you don't have compiler errors, your source code (JSP part) is not broken.

When you assemble war file, you should include everything from ${jsp.src.dir} folder except JSP files and their includes.

How to handle JSP Error Page

2006-06-02T07:38:00.000-07:00

At first glance it looks like a very straightforward task.

1. Each JSP page should use "errorPage" attribute. For example:

<%-- /example.jsp --%>

<%@ page errorPage="/WEB-INF/templates/errorPage.jsp"%>

<%-- some JSP content --%>

If you don't want to repeat this for each JSP page, use Tiles template or specify error page in "web.xml" file:

<web-app>
  ...

  <error-page>
    <exception-type>java.lang.Throwable</exception-type>
    <location>/WEB-INF/templates/errorPage.jsp</location>
  </error-page>

  ...

</web-app>

This description registers "errorPage.jsp" JSP page as error page for all JSP pages within web application.

2. You need to create error page, which displays runtime exceptions:

<%-- /WEB-INF/templates/errorPage.jsp --%>

<%@ page isErrorPage="true" %>

<%
  out.println("Exception: " + exception);
%>

By using "isErrorPage" attribute you declare this JSP page as error page. As a result, you have access to "exception" JSP variable (in addition to regular "application", "session",
"request", etc.).

This is basic. The problem happened, when your JSP page generates big output (bigger than page buffer) before the exception. In this case your error page will be appended to the current content instead of displaying in the new page.

To overcome the problem you can:

3.A. Play with "buffer" attribute. Say, you know, that the size of your page will never be more than 1MB. In this case add these attributes to the page:

<%-- /example2.jsp --%>

<%@ page errorPage="/WEB-INF/templates/errorPage.jsp"%>

<%@ page buffer="1024kb"%>
<%@ page autoFlush="false"%>

<%-- some JSP content --%>

This approach is not perfect, because you cannot guarantee the maximum page size. Another drawback is that page will be refreshed only after completing the operation. This could hurt user's perception.

3.B.1. Use custom javascript code to clear flushed already output. By using "document.getElementById()" function we canget reference to the body and rewrite it:

<%-- /WEB-INF/templates/errorPage.jsp, ver.1 --%>

<%@ page isErrorPage="true" %>

<html>
  <head>
    <script type="text/javascript">
      function newPage() {
        var exception = '<%= exception %>';

        var body = document.getElementById("body");

        body.innerHTML =
            "<html>" +
            " <body>" +
            " Exception: " + exception +
            " </body>" +
            "</html>";
        }
      }
    </script>
  </head>

  <body/>

</html>

This solution fits for simple error pages only. If you want to display full-featured error page, you have to look for another solution (see 3.B.2).

3.B.2. Redirect to another page.

This scenario is based on 3.B.1 solution. Now, instead of preparing the content to display, we'll submit the form, redirecting the flow to the requested page. In order to get the reference to javascript's "document" obect and clear it, we'll use document.open()" function:

<%-- /WEB-INF/templates/errorPage.jsp, ver.2 --%>

<%@ page isErrorPage="true" %>

<%
  // We want to have exception available on the redirected page.
  session.setAttribute("javax.servlet.error.exception",
                        request.getAttribute("javax.servlet.error.exception"));
%>

<html>
  <head>
    <script type="text/javascript">
      function newPage(action) {
        var newDoc = document.open("text/html", true);

        if(newDoc) {
          var errorFormName = 'errorForm';
          var txt =
            "<html>" +
            " <body>" +
            " <form id='" + errorFormName + "' method='get'/>" +
            " </body>" +
            "</html>";

          newDoc.write(txt);
          newDoc.close();

          var form = newDoc.getElementById(errorFormName);
          form.action = action;
          form.submit();

          return true;
        }

        return false;
      }

      newPage("someURL"); // direct execution of javascript custom function
    </script>
  </head>

  <body/>

</html>

This solution does not work properly yet. The problem is, that at the time of javascript execution the html page is not completely generated yet. As the result, "document.open()" call will return "null" object and the conten for the redirection will not be generated. See 3.B.3 for the solution.

3.B.3. Using timer object.

This scenario is based on 3.B.2 solution. It is exactly the same, the only difference is how we call "newPage()" function. Instead of direct call we'll do it indirectly from the timer:

<%-- /WEB-INF/templates/errorPage.jsp, ver.3 --%>

<%@ page isErrorPage="true" %>

<%
  // We want to have exception available on the redirected page.
  session.setAttribute("javax.servlet.error.exception",
                        request.getAttribute("javax.servlet.error.exception"));
%>

<html>
  <head>
    <script type="text/javascript">
      function newPage(action) { ... }

      var timer = new Timer("timer");
      timer.setScript("newPage('someURL')");

      timer.start();
    </script>
  </head>

  <body/>

</html>

Timer is the special custom javascript class that performs call to a given script periodically until the script returns "true" value. After this, the timer will stop execution.

You can download inplementation for the timer from here:

http://home.comcast.net/~shvets/blog/timer.js

Now JSP error page work properly.

Search Engine for Maven 2 (and other Java artifacts) from SourceLabs.

2006-05-24T14:49:00.000-07:00

CJAR is the combination of Maven2 structured repository of Java artifacts with powerful Lucene based search engine and related tools.

CafeBabe bytecode editor v.1.4 - welcome back!

2006-05-23T08:49:00.000-07:00

This is my very old project - I started it probably in 1997-1998.

By using CafeBabe you can view/edit the content of Java bytecodes. Also it understands the format of serialized files. Initially the project had some oprimization/obfuscation tools. I removed them in favor of simplicity.

Project contains libraries that can be used separately:

* classfile - parsing of Java class file;
* serfile - parsing of Java *.ser file;
* MDI - represents Multi Document Interface implementation;
* Net Lib - library for working with sockets (similar to servlet API, but not attached to any container).

Project is well modularized and uses Maven 2 as the build (...) tool.

Scriptlandia 2.1.0 has been released.

2006-05-23T08:42:00.000-07:00

Latest update of the Scriptlandia scripting environment, version 2.1.0.

It includes support for such extensions as *.jad, *cwd (classworld file), *.class, *.apt-jelly, *.apt-fmt.

The library of examples has new examples to show what this environment can do.

How to use Ant, Maven2 and Scripting Languages together

2006-05-19T12:24:00.000-07:00

I have used Ant tool to organize build process for a long period of time. It's pretty convenient and helps you to organize a lot of useful actions around compilation, packaging, deployment etc.

After some period of time I found that it is very convenient to use "script" task to extend basic functionality of Ant tool or dynamically customize it. For example, Javascript or Beanshell scripting languages are perfect selection for doing this.

The only one thing that Ant doesn't take care of is the project dependency resolution for libraries used within your project. Maven tool is especially designed to solve this problem.

As the result, the following architecture could cover all or the most of possible scenarios for describing build process: Ant + Maven + Some Scripting Language (Beanshell, Javascript, Groovy etc.)

Let me introduce basic steps that help you to solve the problem.

1. Ant tool should be aware of Maven. In order to achieve this, download "Maven Tasks for Ant library" (e.g. maven-artifact-ant-2.x.x-dep.jar) and install it into ${ant.home}/lib directory.

2. Once Maven Tasks for Ant are installed, we can start using them (in project.xml). First of all, describe the namespace for maven tasks:

<project name="myProject" default="run" basedir="."
         xmlns:artifact="antlib:org.apache.maven.artifact.ant">

3. Specify the location of your local Maven repository ("${repository.home}"). Usually it is ${user.home}/.m2, but you can choose any other location. Maven will download dependent libraries and save them inside this repository:

  <property name="repository.home" value="c:/local-maven-repository"/>

  <artifact:localRepository id="local.repository" location="${repository.home}" layout="default"/>

4. Load the Maven project file and assign some id for the project:

  <artifact:pom file="pom.xml" id="maven.project" />

5. Export various classpath variables from the Maven. In the following example we have access to compile-time, run-time and test-time classpath variables:

  <target name="resolve.dependencies">
    <artifact:dependencies pathId="compile.classpath" filesetId="compile.fileset" useScope="compile">
      <pom refid="maven.project"/>
    </artifact:dependencies>

    <artifact:dependencies pathId="runtime.classpath" filesetId="runtime.fileset" useScope="runtime">
      <pom refid="maven.project"/>
    </artifact:dependencies>

    <artifact:dependencies pathId="test.classpath" filesetId="test.fileset" useScope="test">
      <pom refid="maven.project"/>
    </artifact:dependencies>

  </target>

6. Now you can use Ant tasks/targets the same way as before. You don't need to build classpath manually, it will be built dynamically based on the information from "pom.xml" maven file.

You also should be aware of some commonly used properties inside Maven. For example:

${maven.project.build.sourceDirectory} -> src/main/java
${maven.project.build.directory} -> target
${maven.project.build.outputDirectory} -> target/classes
${maven.project.name} - the project name

You can find out other properties here: http://maven.apache.org/maven-model/maven.html.

Let's create basic Ant targets, like clean-compile-jar-run:

  <property name="jar.file" value="${maven.project.build.directory}/${maven.project.name}.jar"/>

  <target name="clean" description="Removes all compiled classes">
    <delete dir="${maven.project.build.directory}"/>
  </target>

   <target name="compile" depends="resolve.dependencies" description="Compiles java sources">
    <mkdir dir="${maven.project.build.outputDirectory}"/>

    <javac destdir="${maven.project.build.outputDirectory}"
           includeAntRuntime="false"
           debug="${debug}"
           optimize="${optimize}"
           deprecation ="${deprecation}">
        <classpath refid="compile.classpath"/>
        <src path="${maven.project.build.sourceDirectory}"/>
    </javac>
  </target>

  <target name="jar" depends="compile" description="Prepare packaging for the project">
    <jar destfile="${jar.file}">
      <fileset dir="${maven.project.build.outputDirectory}"/>
    </jar>
  </target>

  <target name="run" depends="jar">
    <java jar="${jar.file}" fork="true" failonerror="true" maxmemory="128m">
      <classpath>
        <path refid="runtime.classpath"/>
        <pathelement location="${jar.file}""/>
      </classpath>
     </java>
  </target>

  <target name="run.script">
    <script language="beanshell">
      print("Hello, World!");
    </script>
  </target>

7. Your dependencies for the project are expressed in the form of "pom.xml" maven file:

<project>
  <modelVersion>4.0.0</modelVersion>

  <groupId>your.group.id</groupId>
  <artifactId>your.artifact.id</artifactId>
  <version>your.version</version>

  <name>YourName</name>

  
  <dependencies>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.12</version>
    </dependency>

    ...
  </dependencies>

  </repositories>

</project>

By using this approach we can build scripts of any level of complexity without introducing Java compilation at all. Such programs will contain light-weight code, related to implementation only. All heavy-weight parts of the program will be conveniently located in the repository.

How to make JavaEE project with Maven2

2006-05-13T07:28:00.000-07:00

You want to support multiple modules in your project. Suppose you plan to have these modules:

- Java Module (one or more);
- EJB Module (dependent on Java Module);
- WEB Application Module (dependent on Java and EJB Modules);
- Enterprise Application Module (dependent on Java, EJB and Web Application Module).

First of all, you have to create multi-module project. It is special type of maven project - it does not produce any artifact. Its main purpose is to host modules - single maven projects - and to perform group operations for all modules.

Each single maven project should be aware of parent project. The same is true for parent maven project - it has to be aware about all the children.

The following steps describe whole process of creating such a project.

1. Create multi-project with the following directory structure:

myMultiProject
    myJavaModule1
    myJavaModule2
    ...

    myEJBModule1
    myEJBModule2
    ...

    myWebApplicationModule1
    myWebApplicationModule2
    ...

    myEnterpriseApplicationModule

2. Create maven project "pom.xml" files inside parent directory and inside each child project. Each "pom.xml" file contains specific to given project information.

myMultiProject
    myJavaModule1
        pom.xml
    myJavaModule2
        pom.xml
    ...

    myEJBModule1
        pom.xml
    myEJBModule2
        pom.xml
    ...

    myWebApplicationModule1
        pom.xml
    myWebApplicationModule2
        pom.xml
    ...

    myEnterpriseApplicationModule
        pom.xml

    pom.xml

You can auto-generate "pom.xml" files by using special "archetype:create" command. Only these archetypes are supported now: "quickstart", "webapp", "site", "mojo" and "marmalade-mojo". For our process we can use only 2 first archetypes.

Run these commands:

- for parent multi-project (in the directory where you plan to hst whole project):

>mvn archetype:create -DarchetypeGroupId=org.apache.maven.archetypes -DarchetypeArtifactId=maven-archetype-quickstart -DgroupId=myMultiProjectGroupId -DartifactId=myMultiProjectArtifactId -DpackageName= -Dversion=1.0

This command creates the directory with the name specified as artifactId: "myMultiProjectArtifactId". You have to change "packaging" value from "jar" to "pom" inside "pom.xml".

You have to change current directory to "myMultiProjectArtifactId" before running all following commands.

- for Java Module:

>mvn archetype:create -DarchetypeGroupId=org.apache.maven.archetypes -DarchetypeArtifactId=maven-archetype-quickstart -DgroupId=myMultiProjectGroupId.myMultiProjectArtifactId -DartifactId=myJavaModule1 -DpackageName=my.new.package -Dversion=1.0

This command creates "myJavaModule1" with minimal set of directories/files for "quickstart" archetype.

- for EJB Module:

>mvn archetype:create -DarchetypeGroupId=org.apache.maven.archetypes -DarchetypeArtifactId=maven-archetype-quickstart -DgroupId=myMultiProjectGroupId.myMultiProjectArtifactId -DartifactId=myEJBModule1 -DpackageName=my.new.package -Dversion=1.0

This command creates "myJavaModule" with minimal set of directories/files for "quickstart" archetype.

- for Web Application Module:

>mvn archetype:create -DarchetypeGroupId=org.apache.maven.archetypes -DarchetypeArtifactId=maven-archetype-webapp -DgroupId=myMultiProjectGroupId.myMultiProjectArtifactId -DartifactId=myWebApplicationModule1 -DpackageName=my.new.package -Dversion=1.0

This command creates "myWebApplicationModule1" with minimal set of directories/files for "webapp" archetype.

- for Enterprise Application Module:

>mvn archetype:create -DarchetypeGroupId=org.apache.maven.archetypes -DarchetypeArtifactId=maven-archetype-quickstart -DgroupId=myMultiProjectGroupId.myMultiProjectArtifactId -DartifactId=myEnterpriseApplicationModule -DpackageName=my.new.package -Dversion=1.0

This command creates "myEnterpriseApplicationModule" with minimal set of directories/files for "quickstart" archetype.

As you can see, for Java, EJB, Enterprise Application Modules and Multi-Project we use "quickstart" archetype and for Web Application - "webapp" archetype.

The cyclic dependency between parent and children projects should be expressed in the following way: for parent project we have to use "modules" tag, for children projects - "parent" tag.

Parent project's structure looks like this:

<project>
  <modelVersion>4.0.0</modelVersion>

  
  <groupId>myMultiProjectGroupId</groupId>
  <artifactId>myMultiProjectArtifactId</artifactId>
  <version>myMultiProjectVersion</version>

  
  <packaging>pom</packaging>

  
  <modules>
    <module>myJavaModule1</module>
    <module>myJavaModule2</module>
    ...
    <module>myEJBModule1</module>
    <module>myEJBModule2</module>
    ...
    <module>myWebApplicationModule1</module>
    <module>myWebApplicationModule2</module>
    ...
    <module>myEnterpriseApplicationModule</module>
  </modules>

</project>

Child project's structure looks like this:

<project>
  <modelVersion>4.0.0</modelVersion>

  
  <groupId>myMultiProjectGroupId.myMultiProjectArtifactId</groupId>
  <artifactId>myJavaArtifactId</artifactId>
  <version>myJavaModuleVersion</version>

  

  <packaging>jar</packaging>

  
  <parent>
    <groupId>myMultiProjectGroupId</groupId>
    <artifactId>myMultiProjectArtifactId</artifactId>
    <version>myMultiProjectVersion</version>
    <relativePath>../pom.xml</relativePath>
  </parent>
</project>

3. Java Module

Below is typical "pom.xml" content for Java Module:

<project>
  <modelVersion>4.0.0</modelVersion>

  
   ...
  <packaging>jar</packaging>

  
   ...

  
  <dependencies>
    ...
  </dependencies>

  
  <build>

    
    <finalName>myJavaModule1FinalName</finalName>

    <defaultGoal>package</defaultGoal>

    
    
    <sourceDirectory>../src/java</sourceDirectory>

    
    <filters>
      <filter>target/filter.properties</filter>
    </filters>

    
    
    <resources>
      <resource>
        <directory>../src/resources</directory>
        <filtering>true</filtering>
        <excludes>
          <exclude>*web*.xml</exclude>
        </excludes>
      </resource>
    </resources>

    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>

          
          <source>1.5</source>
          <target>1.5</target>

          
          <includes>
            <include>**/com/**</include>
          </includes>

          
          <excludes>
            <exclude>com/sun/**/*.java</exclude>
          </excludes>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>

4. EJB Module

EJB Nodule is dependent on Java Module:

<project>
  <modelVersion>4.0.0</modelVersion>

  
   ...
  <packaging>ejb</packaging>

  
   ...

  
  <dependencies>
    
    ...

    
    <dependency>
      <groupId>javax.ejb</groupId>
      <artifactId>ejb</artifactId>
      <version>2.1</version>

      
      <scope>provided</scope>
    </dependency>

    
    <dependency>
      <groupId>myMultiProjectGroupId.myMultiProjectArtifactId</groupId>
      <artifactId>myJavaModule1ArtifactId</artifactId>
      <artifactId>myJavaModuleVersion</artifactId>

      
      <scope>runtime</scope>
    </dependency>
  </dependencies>

  
  <build>

    
    <finalName>myEJBModule1FinalName</finalName>

    <defaultGoal>package</defaultGoal>

    
    
    <sourceDirectory>../../src/java</sourceDirectory>

    

    
    
    <resources>
      <resource>
        <directory>../src/java/META-INF</directory>
        <targetPath>META-INF</targetPath>
        <filtering>false</filtering>
        <excludes>
          <exclude>*application*.xml</exclude>
        </excludes>
      </resource>
    </resources>

    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          
          <source>1.5</source>
          <target>1.5</target>

          
          <includes>
            <include>**/ejb/**</include>
          </includes>

          
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>

5. WEB Application Module

Web Application Module is dependent on Java and EJB Modules.

<project>
  <modelVersion>4.0.0</modelVersion>

  
   ...
  <packaging>war</packaging>

  
   ...

  
  <dependencies>
    
    ...

    
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.4</version>

      
      <scope>provided</scope>
    </dependency>

    
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.0</version>

      
      <scope>provided</scope>
    </dependency>

    
    ...

    
    <dependency>
      <groupId>oracle</groupId>
      <artifactId>oracle-driver</artifactId>
      <version>9.2.0.5.0</version>
    </dependency>

    
    <dependency>
      <groupId>javax.ejb</groupId>
      <artifactId>ejb</artifactId>
      <version>2.1</version>

      
      <scope>provided</scope>
    </dependency>

    
    <dependency>
      <groupId>myMultiProjectGroupId.myMultiProjectArtifactId</groupId>
      <artifactId>myJavaModule1ArtifactId</artifactId>
      <artifactId>myJavaModule1Version</artifactId>

      
      <scope>runtime</scope>
    </dependency>

    <dependency>
      <groupId>myMultiProjectGroupId.myMultiProjectArtifactId</groupId>
      <artifactId>myEJBModule1ArtifactId</artifactId>
      <artifactId>myEJBModule1Version</artifactId>

      
      <scope>runtime</scope>
    </dependency>

  </dependencies>

  
  <build>

    
    <finalName>myWebApplicationModule1FinalName</finalName>

    <defaultGoal>package</defaultGoal>

    
    
    <sourceDirectory>../src/java</sourceDirectory>

    

    
    
    <resources>
      <resource>
        <directory>../src/config</directory>
        <filtering>false</filtering>
        <includes>
          <include>*.properties</include>
        </includes>
      </resource>

      <resource>
        <directory>../src/resources</directory>
        <filtering>false</filtering>
      </resource>
    </resources>

    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          
          <source>1.5</source>
          <target>1.5</target>

          
          <includes>
            ...
          </includes>

          
          <excludes>
            ...
          </excludes>
        </configuration>
      </plugin>

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-war-plugin</artifactId>
        <configuration>
          
          
          <warSourceDirectory>../src/web</warSourceDirectory>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>

6. Enterprise Application Module

This module performs main assembly work plus adds some application-level resources, like "application.xml" file. You have to list all the modules to be included into "ear" file in "dependencies" section. Each module should be marked with the corresponding type: "jar", "war", "ejb", "ejb3", "ejb-client", "rar", "par", "sar".

<project>
  <modelVersion>4.0.0</modelVersion>

  
   ...
  <packaging>ear</packaging>

  
   ...

  
  <dependencies>
    <dependency>
      
      ...
      <type>jar</type>

      
      <includeInApplicationXml>true</includeInApplicationXml>
    </dependency>

    <dependency>
      
      ...
      <type>ejb</type>
    </dependency>

    <dependency>
      
      <type>war</type>
    </dependency>
  </dependencies>

  
  <build>

    
    <finalName>myEnterpriseApplicationModuleFinalName</finalName>

    <defaultGoal>package</defaultGoal>

    

    
    
    
    <resources>
      <resource>
        <directory>../src/java/META-INF</directory>
        <targetPath>META-INF</targetPath>
        <filtering>false</filtering>
        <includes>
          <include>weblogic-application.xml</include>
        </includes>
      </resource>
    </resources>

    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>

        
        <configuration>
          <source>1.5</source>
          <target>1.5</target>
        </configuration>
      </plugin>

      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-ear-plugin</artifactId>
        <configuration>

          
          <modules>

            
            <javaModule>
              <groupId>myMultiProjectGroupId.myMultiProjectArtifactId</groupId>
              <artifactId>myJavaModule1ArtifactId</artifactId>
              <artifactId>myJavaModule1Version</artifactId>

              
              <bundleFileName>myBundleJavaModule1FileName</bundleFileName>
            </javaModule>

            
            <ejbModule>
              <groupId>myMultiProjectGroupId.myMultiProjectArtifactId</groupId>
              <artifactId>myEJBModule1ArtifactId</artifactId>
              <artifactId>myEJBModule1Version</artifactId>

              
              <bundleFileName>myBundleEJBModule1FileName</bundleFileName>
            </ejbModule>

            
            <webModule>
              <groupId>myMultiProjectGroupId.myMultiProjectArtifactId</groupId>
              <artifactId>myWebApplicationModule1ArtifactId</artifactId>
              <artifactId>myWebApplicationModule1Version</artifactId>

              
              <bundleFileName>myBundleWebApplicationModule1FileName</bundleFileName>

              
              
              <contextRoot>iris</contextRoot>
            </webModule>

            
            <javaModule>
              <groupId>antlr</groupId>
              <artifactId>antlr</artifactId>
              <bundleDir>APP-INF/lib</bundleDir>
            </javaModule>
            ...

          </modules>
        </configuration>
      </plugin>

    </plugins>
  </build>

</project>

7. Parent multi-project

Parent project can be used as convenient way to execute group commands, When you run particular command on the project, it executes this command for all children projects. Maven is able to discover the correct execution order and to detect circular dependencies.

<project>
  <modelVersion>4.0.0</modelVersion>

  
   ...
  <packaging>pom</packaging>

  
  <modules>
    ...
  </modules>

  <build>
    <defaultGoal>package</defaultGoal>

    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          
          <source>1.5</source>
          <target>1.5</target>
        </configuration>
      </plugin>

    </plugins>
  </build>

</project>

8. Usage

Now you can execute group commands, for example:

>mvn compile
>mvn install
>mvn site

These commands perform operations for each module sequentially.

How to make JavaME project with Ant

2006-05-01T12:45:00.000-07:00

I prepared Ant script that can be used for the most of Java ME projects. It encapsulates all low-level detail dealing with tools/callses from Java ME platform.

1. Specify project name and default target:

<project name="MyFirstMidlet" default="compile" basedir=".">

2. Define useful properties that will be used throughout the project:

  <property name="java.mobile.home" value="c:/Java/j2me-2.3"/>

  <property name="midlet.class.name" value="${ant.project.name}"/>
  <property name="src.dir" value="src"/>
  <property name="target.dir" value="target"/>

  <property name="midlet.command.line" value=""/>

3. Specify the classpath that includes core mobile API and required extension APIs, e.g.:

  <path id="mobile.classpath">
    <pathelement location="${java.mobile.home}/lib/cldcapi11.jar"/>
    <pathelement location="${java.mobile.home}/lib/midpapi20.jar"/>

    <pathelement location="${java.mobile.home}/lib/wma20.jar"/>
    <pathelement location="${java.mobile.home}/lib/mmapi.jar"/>
    <pathelement location="${java.mobile.home}/lib/j2me-ws.jar"/>
    <pathelement location="${java.mobile.home}/lib/jsr75.jar"/>
    <pathelement location="${java.mobile.home}/lib/jsr082.jar"/>
    <pathelement location="${java.mobile.home}/lib/jsr184.jar"/>
    <pathelement location="${java.mobile.home}/lib/jsr179.jar"/>
    <pathelement location="${java.mobile.home}/lib/jsr177.jar"/>
    <pathelement location="${java.mobile.home}/lib/jsr211.jar"/>
  </path>

4. We need to create string version of our classpath. It will be used for executables, like "preverified.exe" and "emulator.exe":

    <property name="mobile.classpath" refid="mobile.classpath"/>

5. Prepare "compile" target. Keep in mind that target attribute should be on "1.1" level:

  <target name="compile">
    <mkdir dir="${target.dir}/classes"/>

    <javac srcdir="${src.dir}" destdir="${target.dir}/classes"
           bootclasspathref="mobile.classpath"
           source="1.1" target="1.1"/>

  </target>

6. Compiled classes should be "preverified". It means that each class file in "classes" directory will have corresponding "preverified" class file in "preverified" directory.

  <target name="preverify" depends="compile">
    <mkdir dir="${target.dir}/preverified"/>

    <exec executable="${java.mobile.home}/bin/preverify">
      <arg line="-classpath ${mobile.classpath}"/>
      <arg line="-d ${target.dir}/preverified"/>
      <arg line="${target.dir}/classes"/>
    </exec>
  </target>

7. Resulting jar file will contain "preverified" classes and resources from "res"
directory:

  <target name="jar" depends="preverify">
    <mkdir dir="${target.dir}/bin"/>

    <jar basedir="${target.dir}/preverified"
         jarfile="${target.dir}/bin/${ant.project.name}.jar"
         manifest="bin/MANIFEST.MF">
      <fileset dir="res"/>
    </jar>

    <copy file="bin/${ant.project.name}.jad"
          tofile="${target.dir}/bin/${ant.project.name}.jad"/>

  </target>

8. In order to run generated artifact you have to launch the emulator. You can run
emulator as executable file or as java class.

- as executable:

  <target name="run2" depends="jar">
    <exec executable="${java.mobile.home}/bin/emulator">
      
      <arg line="-Xdevice:DefaultColorPhone"/>
      <arg line="-Xdescriptor:${basedir}/${target.dir}/bin/${ant.project.name}.jad"/>

      <arg line="-classpath ${mobile.classpath};${basedir}/${target.dir}/bin/${ant.project.name}.jar"/>
    </exec>
  </target>

- as java class:

  <target name="run" depends="jar">
    <java fork="yes" classname="com.sun.kvem.environment.EmulatorWrapper">
      <sysproperty key="kvem.home" value="${java.mobile.home}"/>
      <sysproperty key="java.library.path" value="${java.mobile.home}/bin"/>
      <sysproperty key="sun.java2d.ddlock" value="true"/>
      <sysproperty key="sun.java2d.gdiblit" value="false"/>

      <arg line="-Xdevice:DefaultGrayPhone"/>
      <arg line="-Xdescriptor:${basedir}/${target.dir}/bin/${ant.project.name}.jad"/>

      <arg line="-classpath ${mobile.classpath};${target.dir}/bin/${ant.project.name}.jar"/>
      <arg line="${midlet.class.name}"/>
      <arg line="${midlet.command.line}"/>
      <arg line="0"/>
    </java>
  </target>

How to generate checksum files for Maven 2 repository

2006-04-26T11:50:00.000-07:00

Sometimes you want to add libraries to your Maven 2 repository manually.
This tool will help you to generate checksum files recursively, starting from current directory.

Tool is located here.

You can use Scriptlangia in order to simplify launching of this tool.

Beanshell plugin for maven2

2006-04-25T14:00:00.000-07:00

Plugin for running beanshell scripts in the same way as maven-antrun-plugin does. Based on the source from maven-antrun-plugin plugin.

Source code is located here: maven-beanshell-plugin.

in order to use the plugin you have to add new repository to the list of your repositories:

<repositories>
  ...
  <repository>
    <id>scriptlandia-maven2</id>
    <name>scriptlandia-maven2</name>
    <url>http://scriptlandia.sourceforge.net/maven2</url>
  </repository>
</repositories>

Then, configure the plugin:

<build>
  ...
  <plugins>
    <plugin>
      <groupId>org.apache.maven</groupId>
        <artifactId>maven-beanshell-plugin</artifactId>

      <executions>
        <execution>
          <id>validate</id>
          <phase>validate</phase>
          <configuration>
            <source>test.bsh</source>
            
          </configuration>
          <goals>
            <goal>run</goal>
          </goals>
          </execution>
      </executions>
    </plugin>
  </plugins>
</build>

New maven2 book (free, pre-release): Better Builds with Maven

2006-04-25T13:58:00.000-07:00

Scriptlandia Project Home Page

2006-04-22T15:43:00.000-07:00

Welcome to the Scriptlandia World!

I started this project two years ago (Antlets). The idea was to simplify running various scripts written in scripting languages (Beanshell, Groovy, Jelly etc.) for JVM under Windows and Unix environment.

We have a plenty of scripting engines, each has the launcher/starter program. In order to run the script, you have to remember the name of the launcher program. In case if you need to add new libraries to your script, it's not so easy. If you want to have scripts in different languages to be aware of each other, it's even more difficult.

Scriptlandia is built in top of ClassWorlds framework, a convenient way of solving classloader problems in one unified way. Your batch/shell scripts will become as simple as possible and addition of new libraries will happen outside of them.

By the size this project is very small (~70K). It uses Maven2 as the delivery mechanizm to download all required parts. It has to deliver libraries for running Beanshell, Groovy etc. from Maven2 repositories.

After installing the Scriptlandia you will be able to launch beanshell, groovy, jelly, velocity scripts in one click. You can do the same for jar files. If jar file is written for Java Micro Edition, the system will recognize it and the file will be started in mobile phone emulator. See examples archive for more details. This file: README.txt contains complete description of the project.

Princeton JUG site

2006-04-22T07:01:00.000-07:00

Maven2 dedicated sites

2006-04-18T07:18:00.000-07:00

Maven Blogs site.

Maven Book site.

Jetty6 and Maven2.

Project Versioning with Maven.

Maven News from Sourcelabs.

Using Maven2 from Hollow World

2006-04-13T08:11:00.000-07:00

Part 1.

Part 2.

Part 3.

Part 4.

Part 5.

Part 6.

Useful articles about Maven 2

2006-04-11T07:58:00.000-07:00

An introduction to Maven 2.

Get the most out of Maven 2 site generation.

PP presentation about Maven 2 from Jason van Zyl.

Play with Maven from Ant.

Step by step maven 2 simple plugin creation.

Maven 2 student course.

Compiling JSF/spring/hibernate project in Maven.

How to pre-compile JSP pages for Tomcat with Ant

2006-04-04T12:50:00.000-07:00

JSP pre-compilation is very important part of the build process. Even if you don't want to use pre-compiled pages in your production environment (it's for specific application server (AS) only), it can guarantee the integrity of your source.

With regular approach you make changes to JSP pages, then copy/deploy them to AS and only at this time possible error will be discovered. In contrast, JSP pre-compilation will give you this knowledge at compile time.

How to do the pre-compilation? I will explain it with the help of Ant build tool.

1. Specify "project.classpath" for your project. It will include all jars required to compile or run your project:

<path id="project.classpath">
...
</path>

2. Specify "tomcat.jsp.classpath". You need to have Tomcat Web Server installed somewhere. For this example I use tomcat, embedded into JBoss Application Server ("${jboss.home}").

You also need to specify where you have your implementation of logging system
("${repository.home}/log4j").

<path id="tomcat.jsp.classpath">



<path refid="project.classpath"/>



<fileset dir="${jboss.home}/server/default/deploy/jbossweb-tomcat55.sar">
<include name ="jasper-compiler.jar"/>
<include name ="jasper-compiler-jdt.jar"/>
<include name ="jasper-runtime.jar"/>
<include name ="commons-logging.jar"/>
<include name ="commons-el.jar"/>
<include name ="jsp-api.jar"/>
</fileset>



<fileset dir="${ant.home}/lib">
<include name ="ant.jar"/>
</fileset>



<fileset dir="${jboss.home}/server/default/lib">
<include name ="jboss-j2ee.jar"/>
<include name ="javax.servlet.jar"/>
<include name ="javax.servlet.jsp.jar"/>
</fileset>



<fileset dir="${repository.home}/log4j">
<include name ="log4j-1.2.8.jar"/>
</fileset>

</path>

3. Now we can generate Java sources for JSP files:

<property name="jsp.src.dir" value="<the root for your JSP files>"/>
<property name="jsp.package.name" value="<the package name for your JSPs, like com.mycompany.jsp>"/>

<property name="build.dir" value="target/build"/>
<property name="jsp.generated.src.dir" value="${build.dir}/jsp_sources"/>
<property name="jsp.classes.dir" value="${build.dir}/jsp_classes"/>

<target name="tomcat.jsp.generate">
<mkdir dir="${jsp.generated.src.dir}"/>
<mkdir dir="${jsp.classes.dir}"/>

<java classname="org.apache.jasper.JspC" fork="yes">
<classpath refid="tomcat.jsp.classpath" />

<arg line="-uriroot ${jsp.src.dir} -d ${jsp.generated.src.dir} -p ${jsp.package.name} -webapp ${jsp.src.dir}" />
</java>
</target>

4. After the generation of Java classes from JSPs, we need to compile them. The "depend" task is responsible for "smart" recompilation of JSP-Java files.

<target name="tomcat.jsp.compile" depends="tomcat.jsp.generate"
description="Generates java classes from jsp files, then compiles them">
<depend srcdir="${jsp.src.dir}"
destdir="${jsp.classes.dir}"
cache="${build.dir}"
closure="true">
<classpath refid="tomcat.jsp.classpath"/>
</depend>

<javac destdir="${jsp.classes.dir}" debug="off" optimize="false">
<classpath refid="tomcat.jsp.classpath"/>

<src path="${jsp.generated.src.dir}"/>
<include name ="com/**/*.java"/>
</javac>
</target>

If on this step you don't have compiler errors, your source code (JSP part) is not broken.

Blog's birthday,

2006-03-31T06:51:00.000-08:00

At the beginning it was a word. Then the blog was born...