Enum.valueOf(YourClassName.class, "String Value")

• http://docs.oracle.com/javase/6/docs/api/java/lang/Enum.html

• You cannot deal with all Grails Mail settings in the configuration file
• You cannot use the log4j DSL to extract the logging configuration outside your application
• etc..

In our hunt for a good way to load configuration files we asked question on the mailinglist and also found this blogpost which was the start for our implementation of loading the external configuration files. We modified some small things and added a way of loading a configuration file that is resident in the root of a Grails project. So when developing with IntelliJ for example the config file is at your fingertips in the root of the application project structure. We must also note that we are very happy with the fact that the Grails community was more then helpfull in helping us out here!

// -------------------------------------------------------------------------------- //
// - START: CONFIGURATION FILE LOADING -------------------------------------------- //
// -------------------------------------------------------------------------------- //
// locations to search for config files that get merged into the main config
// config files can either be Java properties files or ConfigSlurper scripts
def ENV_NAME = "${appName}.config.location"
if(!grails.config.locations || !(grails.config.locations instanceof List)) {
    grails.config.locations = []
}
println "--------------------------------------------------------------------------------"
println "- Loading configuration file                                                   -"
println "--------------------------------------------------------------------------------"
// 1: check for environment variable that has been set! This variable must point to the
// configuration file that must be used. Can be a .groovy or .properties file!
if(System.getenv(ENV_NAME) && new File(System.getenv(ENV_NAME)).exists()) {
    println("Including System Environment configuration file: " + System.getenv(ENV_NAME))
    grails.config.locations << "file:" + System.getenv(ENV_NAME)

// 2: check for commandline properties!
// Use it like (examples):
//      grails -D[name of app].config.location=/tmp/[name of config file].groovy run-app
// or
//      grails -D[name of app].config.location=/tmp/[name of config file].properties run-app
//
} else if(System.getProperty(ENV_NAME) && new File(System.getProperty(ENV_NAME)).exists()) {
    println "Including configuration file specified on command line: " + System.getProperty(ENV_NAME)
    grails.config.locations << "file:" + System.getProperty(ENV_NAME)

// 3: check on local project config file in the project root directory
} else if (new File("./${appName}-config.groovy").exists()) {
    println "*** User defined config: file:./${appName}-config.groovy ***"
    grails.config.locations = ["file:./${appName}-config.groovy"]
} else if (new File("./${appName}-config.properties").exists()) {
    println "*** User defined config: file:./${appName}-config.properties ***"
    grails.config.locations = ["file:./${appName}-config.groovy"]

// 4: check on local project config file in ${userHome}/.grails/...
} else if (new File("${userHome}/.grails/${appName}-config.groovy").exists()) {
    println "*** User defined config: file:${userHome}/.grails/${appName}-config.groovy ***"
    grails.config.locations = ["file:${userHome}/.grails/${appName}-config.groovy"]
} else if (new File("${userHome}/.grails/${appName}-config.properties").exists()) {
    println "*** User defined config: file:${userHome}/.grails/${appName}-config.properties ***"
    grails.config.locations = ["file:${userHome}/.grails/${appName}-config.properties"]

// 5: we have problem!!
} else {
    println "********************************************************************************"
    println "* No external configuration file defined                                       *"
    println "********************************************************************************"
}
println "(*) grails.config.locations = ${grails.config.locations}"
println "--------------------------------------------------------------------------------"
// -------------------------------------------------------------------------------- //
// - END: CONFIGURATION FILE LOADING ---------------------------------------------- //
// -------------------------------------------------------------------------------- //

A simple mechanism to load these property files is to place a short snippet of code in the ‘Config.groovy’ that will load a specific configuration file from the filesystem, depending on the availability.

grails.config.locations = ["classpath:application-config.properties",
"file:./application-config.properties"]

This snippet will first try to load the property file from the classpath and if that fails you have a backup on the filesystem. This opens opportunities to load a different property file during development! When you deploy the application you can place the ‘application-config.properties’ file inside a folder which is available in the classpath. For Apache Tomcat this would be the ‘lib’ folder! This gives the opportunity to configure the application outside the ‘Config.groovy’ file so any changes made the the property file will be reflected in your environment.

• Open a terminal
• Issue the command ‘xrandr’ this gives a list with displays that are attached to your system
• Issue the command ‘ xrandr –output <displayname> –primary’ where you replace the <displayname> with the actual name of the display that is going to be used as primary display!

Example:

• ‘xrandr –output HDMI1 –primary’

Good Luck and Happy Minting

Steps:

• Install ImageMagick according to the installation instructions.
• It contains a utility called convert which we will need later on! This utility takes care of the conversion of images to thumbnails, watermarks etc. So remember where this utility is installed on your system!
• Make sure that ImageMagick is installed correctly be converting an image to a thumbnail by using the following command in a terminal.

  /opt/local/bin/convert <filename> -thumbnail 70x70 <thumbnail-filename>

  example:

  /opt/local/bin/convert /tmp/image-001.jpg -thumbnail 70x70 /tmp/thumbnail-image-001.jpg

• Create some code that calls the ImageMagick convert utility with the correct parameters to enable you to achieve what you want. Something like below:

  def createThumbnail(File file) {
     def command = "/opt/local/bin/convert ${file.canonicalPath} " +
                   "-thumbnail 70x70 " +
                   "/images/thumbs" + File.separator + "${file.name}"
     def proc = Runtime.getRuntime().exec(command)
     int exitStatus;
     while (true) {
         try {
             exitStatus = proc.waitFor();
             break;
         } catch (java.lang.InterruptedException e) {
             log.debug("Creating thumbnail - Interrupted: Ignoring and waiting")
         }
     }
      if (exitStatus != 0) {
          log.error("Error executing command: exitStatus=[${exitStatus}]")
      }
      log.debug("Succesfully created thumbnail")
      return (exitStatus == 0);
  }

The above should give you some idea on how you could integrate Grails and ImageMagick into your own application.

Reference links:

• ImageMagick
• Grails

##Pathogen
When you instal a plugin one may copy the files to the plugin directory. In a later stage you also want to delete a plugin and then the hunt for files starts. You need to track down which files belong to the specific plugin you want to delete. Pathogen to the rescue Pathogen enables you to create sub-folders inside a bundle-folder which will acts a place holder for all your plugins nicely separated in a ‘folder per plugin’ structure. So if you need to delete a plugin then you just delete the correct plugin-folder and everything is gone.

Normal installation of a Vim script is standard, you create a sub-folder below the bundle-folder, copy the Vim script and all is ok. BUT when you want to use a vimball then you need to do some additional steps.

* Create a folder in which you want to later on extract the vimball. Preferably below the ‘bundle’ folder.

mkdir ~/.vim/bundle/align

* Open the vimball with command ‘:e ‘location of your vimball’/‘name of your vimball’

:e ~/Downloads/Align.vba

* Tell Vim to use the vimball by issuing command ‘:UseVimball ‘location to extract’’

:UseVimball ~/.vim/bundle/align

* Restart your Vim and your plugin should be available.

##Links
* [Vim Homepage][vim]
* [Installing Vim Scripts][installing_vim_scripts]
* [Pathogen Vim Script][pathogen_vim_script]
* [The modern Vim Config with Pathogen][the_modern_vim_config]

[vim]: http://www.vim.org/ “Vim Homepage”
[installing_vim_scripts]: http://www.installationwiki.org/Installing_Vim_Scripts
[the_modern_vim_config]: http://tammersaleh.com/posts/the-modern-vim-config-with-pathogen
[pathogen_vim_script]: http://www.vim.org/scripts/script.php?script_id=2332

Using Textmate everything is easy, but when you want to use Markdown inside VIM it is somewhat different. But anything is different when using VIM

##Steps
* download Markdown from [The home of Markdown][home_of_markdown], It’s usual place as this is a Perl script you need to put it somewhere so OSX is able to execute it.
* start your terminal and create a directory inside ‘usr/local/bin’
* extract the downloaded file and put the ‘Markdown.pl’ file inside the ‘user/local/bin’ directory
* inside the terminal chmod the ‘Markdown.pl’ to 777
* using the [Installing Markdown as OSX Service][osx_markdown_service] OSX Automator create a service to use Markdown
* You are done…

##Links
* [The home of Markdown][home_of_markdown]
* [TextMate][textmate]
* [Vim][vim]
* [Installing Markdown as OSX Service][osx_markdown_service]

[home_of_markdown]: http://daringfireball.net/projects/markdown/
[textmate]: http://macromates.com/
[vim]: http://www.vim.org/
[osx_markdown_service]: http://gothick.org.uk/2010/08/04/installing-markdown-as-a-os-x-service-using-automator-in-snow-leopard/

##Links:
* [Groovy][groov]
* [Grails][grails]
* [Presentation Introduction to Groovy and Grails][presentation]
* [Devnology][devnology]

[groov]: http://groovy.codehaus.org/
[devnology]: http://www.devnology.nl
[presentation]: http://slidesha.re/cfL3eH
[grails]: http://www.grails.org/

Naast Windows Areo Snap betrap ik mezelf er ook nog wel eens op dat ik van het ‘groene’ balletje in de schermen van Mac OSX verwacht dat het zorgt voor volledige vergroten van het huidige scherm. Helaas…. soms gaat het zoals verwacht maar soms ook niet. Hiervoor is ook een oplossing in de vorm van [Rightzoom][rightzoom] wat eveneens gratis is. Dit keer zonder NagWare

##Links
* [Windows Aerosnap][aerosnap]
* [Cinch][cinch]
* [Rightzoom][rightzoom]

[aerosnap]: http://windows.microsoft.com/en-US/windows7/products/features/snap
[cinch]: http://irradiatedsoftware.com/cinch/
[rightzoom]: http://www.blazingtools.com/downloads.html#RightZoom

* Download the MySQL JDBC driver [called a connector] from the [MySQL website][1]
* Extract the zip or tar archive
* Copy the driver (at this time of writing called `mysql-connector-java-5.1.13-bin.jar` into the `grails-app/lib` directory

* Configure your application datasource in file ‘grails-app/conf/DataSource.groovy’

development {
 		dataSource {
 		dbCreate = "create-drop" // one of 'create', 'create-drop','update'
 		url = "jdbc:mysql://localhost/"
 		driverClassName = "com.mysql.jdbc.Driver"
 		port =  // default 3306
 		username = ""
 		password = " "
 	}
}

Use your own database settings!

* Start your Grails application

[1]: http://dev.mysql.com/downloads/connector/j/