Things happened in my life

I have a chance to use Lucene (3.6.0) to implement a full-text search in one of my recent projects. One of the requirements is to highlight the matched text in the result. The highlighted text should be displayed in the whole paragraph (not just a small text fragment). Here is my snippet to achieve this:

private String getHighlightedField(Query query, Analyzer analyzer, String fieldName, String fieldValue) throws IOException, InvalidTokenOffsetsException {
    Formatter formatter = new SimpleHTMLFormatter("", "");
    QueryScorer queryScorer = new QueryScorer(query);
    Highlighter highlighter = new Highlighter(formatter, queryScorer);
    highlighter.setTextFragmenter(new SimpleSpanFragmenter(queryScorer, Integer.MAX_VALUE));
    highlighter.setMaxDocCharsToAnalyze(Integer.MAX_VALUE);
    return highlighter.getBestFragment(this.analyzer, fieldName, fieldValue);
}

• By creating a SimpleSpanFragmenter with a very big fragment size, we can display the highlighted text in the whole paragraph or document. Lucene also does a nice thing here for free, by merging all the highlighted text fragments into one big chunk (or our original paragraph/document)
• query: is the Lucene query you constructed to do the search
• analyzer: is the Lucene analyzer are used to analyzed the field when you create the index for that field

Happy highlighting!

In my previous post, I successfully managed to put all the output of Maven (and Eclipse) into RAM to reduce the disk write. In today post, I will do the same thing but with Gradle. Here is my build.gradle

apply plugin: "java"
apply plugin: "war"
apply plugin: "eclipse"

sourceCompatibility = 1.6
targetCompatibility = 1.6

group = "me.tinhtruong"
version = "1.0"

repositories {
    mavenCentral()
}

dependencies {
    compile "com.icegreen:greenmail:1.3.1b"
    compile "jstl:jstl:1.2"
    providedCompile "javax.servlet:servlet-api:2.5"
}
// Change the buildDir of the current project to /tmp/ (which is mounted on RAM using tmpfs)
buildDir = new File("/tmp/gradle/" + project.name);

// First, create a linked resource pointing to our Gradle buildDir, then hook into the .classpath file generation of Gradle to change the output of Eclipse to that linked resource.
eclipse {
 project {
  linkedResource name: 'build', type:'2', location: buildDir.absolutePath
 }
 classpath {
  file {
   whenMerged { classpath ->
    classpath.entries.each { entry ->
     if (entry.kind == 'output') {
      entry.path = 'build/eclipse-output';
     }
    }
   }
  }
 }
}

It has been a while since I finished porting the Monokai color theme from TextMate to Eclipse. Thanks to the original author of Monokai (I believe this is the guy) and the authors of the awesome Eclipse color theme plugin which enable everyone to create an Eclipse color theme easily. Here is the Monokai theme in action (click on the screenshot for larger preview)

I've recently bought an Intel 520 SSD, so my top priority for my laptop is to reduce the disk write during daily use. In the Java world, Maven is one of the most common build tool out there. My most used Maven command is:

mvn clean package

This command will do a fresh build of the project, then copy all the compiled classes/resources to the build directory of Maven (which is the folder 'target', next to your source directory). If you have a large Maven project at hand, this command will perform thousands disk write (clean compiled classes and resources, then compile Java classes and assemble the resources into WAR/JAR file). By changing the build directory of Maven to /tmp (which is a tmpfs mountpoint (residing on RAM on my ArchLinux)), I can now rebuild my project as many times as I like without the write amplication concern. Here is now I do it in Maven:

• Define a property name target.directory with the default value is target
• Under the build section in your POM file, add this tag <directory>${target.directory}</directory>
• Modify your settings.xml file to include this snippet in your active profile:

  
      /tmp/maven/${project.groupId}-${project.artifactId}/target
  
  

With the above configuration, maven will do all the build in /tmp, my SSD will thanks me for this :), but we have a small problem! Eclipse does not allow the build directory to be located outside the project directory, but I have a workaround for that. By defining a linked resource, Eclipse will happily with our setup! Here is the complete sample pom.xml file:

 4.0.0
 com.abc
 abc
 war
 1.0
 Sampe Webapp
 http://www.abc.com
 
  target
 
   
  
   junit
   junit
   3.8.1
   test
  
 
 
  abc
  ${target.directory}  
 
 
   
     maven-eclipse-plugin
       2.8
       
         true
         true
         target
         
           
             target
             2
             ${project.build.outputDirectory}
           
         
       
   
 

And the sample settings.xml file:

  
  
    
      development
      
        /tmp/maven/${project.groupId}-${project.artifactId}/target
       
    
    
      public-snapshots      
  
  
    development
  

Happy coding!

This how-to is served as my memo to import a Bitbucket project into Eclipse. First things first, make sure you have an up-and-running Eclipse with EGit (in this how-to I am using Eclipse Indigo 3.7.2 with EGit 1.3.0)

• Create a folder to hold the workspace for your new project (You can skip this step if you want to use an existing workspace), I will use one of my project on Bitbucket in this how-to. It's GreenMail web application. So I create a folder name greenmail-webapp
• Open the Git Repositories view (it's under Windows -> Show View -> Other..., then under the Git category).
• Click 'Clone a Git repository' and paste in the whole Git repo URL to the URI textbox, EGit will automatically fill in other textbox with the right value (so cool!), all you need is to enter the correct password. Then click 'Next'.
• At the Branch Selection screen you are able to choose a branch to clone, my project has only one branch (master). If you clone an empty project from Bitbucket, just click next.
• At the Local Destination, browse to your workspace directory for this project. I usually don't check-in the .project and .classpath files into the VCS, I just generate them locally right after I checkout/clone instead. If your build tool does not generate those files for you or you are the only one in this project, it'd better to check-in those files.
• Now, let's generate the Eclipse project files. I use Gradle as my build system, so it's just a command away.

  gradle eclipse
  

  Before running this, make sure you've already applied the 'eclipse' plugin in your build.gradle. If you use Maven, please include the maven-eclipse-plugin into your pom.xml and run the command

  mvn eclipse:eclipse
  

  The above commands will generate/overwrite the .project and .classpath for you.

• Returning to your Eclipse, you can now Import your new cloned project into your workspace by right clicking on your in the Git Repository view, select Import Projects...

  
• Select Import existing projects
• Select the project you want to import.

Happy coding!

In my recent project, I have a need to monitor a directory for changes such as a new file created, modified or deleted. Surprisingly, JDK (up to JDK 6) does not have APIs to do that! JDK 7 does support it out of the box but I am stuck with the version 6

After looking around for an existing solution, I finally found that jNotify seems to fit the need. It supports all the three major platforms (Windows, Linux, and MacOS).The project has not released any update for nearly two years, so it's a little bit tricky to compile the native code. In this post, I will show you how! (at least on a Ubuntu Server 64bit)

In order to build anything serious on Ubuntu, you should install the package build-essentials

sudo apt-get install build-essential

Then download the source code of jNotify from its homepage. Extract it, open a terminal and issue the command: (assuming that you are at the directory jnotify-native-linux-0.93-src)

cd Release
make

On ArchLinux 64bit, the compilation will succeed and you will get a libjnotify.so in the same folder. But on my Ubuntu Server 10.04 LTS, I've got this:

/usr/include/asm-generic/fcntl.h:96: error: expected specifier-qualifier-list before ‘pid_t’

After Googling around I found this thread. Basically, you have to change the file net_contentobjects_jnotify_linux_JNotify_linux.c by moving up the "unistd.h" up above the "sys/time.h". Now issue the command "make", the compilation will work as expected. Happy coding!

I've been exposing to Gradle for a couple of weeks and really like it. As a Maven user, I found that Gradle is a refreshing methodology on how a build tool should be. But one thing I miss from the Maven land: the ability to generate the initial structure for a project (I mean the 'archetype' plugin of Maven). Luckily, due to the plugin architecture of Gradle, a Gradle user has developed a plugin just for that purpose. It's called the 'tempaltes' plugin. The wiki page of the plugin gives you all the details you need to install, but the global installation section is confusing and did not work. Here is how I did to make it work:

• Create a file called templates.gradle in the ~/.gradle/init.d/ folder (actually you can name it whatever you want as long as it has the extension .gradle)
• Edit that file and paste this little code snippet:

gradle.beforeProject { prj ->
   prj.apply from: 'http://launchpad.net/gradle-templates/trunk/latest/+download/apply.groovy'
}

Now, you can create a project structure event without a build.gradle with the command:

gradle createJavaProject

Happy coding!