Andrea Campolonghi

Fake xhr request from rspec

2013-02-28T16:36:00-08:00

I discovered today that I had no idea of how to fake an xhr request in an Rspec controller test. I need this cause some of my layout strategy behaves on the request.xhr? method.

As expected Rspec solved the issue in a cool and elegant way.

 get :show, id: 1  # normal request
 
    xhr :get, :show, id: 1 
    # exactly the same request, This time fake to be an xhr 
    # call. request.xhr? will be true

ruby alias vs alias_method

2012-11-29T00:00:00-08:00

While alias and alias_method looks very similar at first they hide a substantial different behaviour. Look at the following code.

### Basic alias behaviour

class Boss
  def name
     p "Andrea"
  end
  alias :full_name :name
end

Boss.new.name # => Andrea
Boss.new.full_name # => Andrea

This is the the basic behaviour we could expect from the alias method. #full_name is perfectly aliased to #name. But what happens if we subclass Boss?

### Alias in subclass

class Employee < Boss

    def name
       p "Bob"
    end

end

Employee.new.name # => Bob
Employee.new.full_name  # => Andrea

Looks like Employee#full_name points to the superclass #name method and not at Employee#name! And this is the truth.

alias is a ruby keyword and is executed when source code gets parsed. When Boss class is parsed Boss#full_name is aliased to Boss#name and this will be truth for any Boss instance as per any Class instance that subclass Boss.

alias_method is instead, as the word says, a method and is executed in the current self scope.

### Using alias_method

class Boss
  def name
     p "Andrea"
  end
  def self.apply_alias
      alias_method :full_name, :name
  end
  apply_alias
end

class Employee < Boss
    def name
       p "Bob"
    end
    apply_alias
end

Boss.new.name # => Andrea
Boss.new.full_name # => Andrea
Employee.new.name # => Bob
Employee.new.full_name # => Bob

alias_method is executed the first time in the self scope of Boss and then the self scope of Employee and apply the method aliasing in the way we expected. While this looks like a tiny difference using alias_method grant more flexibility and may avoid unpredictable code behaviour.

Railo 4 beta released

2012-07-03T09:40:00-07:00

Railo 4 beta has been released. See more info in Railo blog. Many improvements and new features:

closures
rest support
loop and cfloop enhancements
better Application.cfc management
function caching
compiler enhancemnets

Really looks a great release !!!!! Good job.

Redis cache extension for Railo

2012-05-18T09:24:00-07:00

I have recently had occasion to work with Redis and I got really impressed by how is fast and reliable. Redis is a nosql key/value store quite commonly used in the Ruby world where I am digging these days.

Many well known projects like Resque, Sidekiq and others make a wide use of Redis for storing any kind of data. What makes Redis really shining, over being so fast, is the ability to manage typed data like hashes, sets and lists. This feature makes the engine suitable to be used in many more situations than a plain key value store.

Looking around into the cfml community I discovered that Redis almost completely unknown in the coldfusion world. What a shame???

What a better occasion to make another cache extension for Railo. I have found in Jedis a very well designed and fully featured Java client and well… here we are.

The result is an extension that you can easily install on your Railo server. Once you got it running creating a new cache and use is very easy. You can find some more info on github.

I made some fast test comparing with the Railo MongoDb cache extension that I have developed as well.

<cfloop from="1" to="10" index="j">
    <cfset start = gettickcount()>
    <cfloop from="1" to="5000" index="i">
        <cfcache action="put" id="a#i#" value="#i#">
        <cfcache action="get" id="a#i#" name="v">
    </cfloop>
    <cfset end = gettickcount()>
    <cfset time = end -start>
    <cfset total = total + time >
    <cfoutput>#time/1000# s<br/></cfoutput>
    <cfflush>
    <cfset cacheClear()>
</cfloop>
<cfoutput>Average sec: #(total/10)/1000#</cfoutput>

This simple snippets runs 10 iterations with 5000 write/read operations each. ONn my machine MongoDb executes this in 3 secs average per iteration. Redis will do the same job in 1 sec average so basically 66% faster. I have reporetd the same performance even launching the scripts from 4 concurrents threads.

Resources

Rspec rails views tips

2012-04-22T00:00:00-07:00

In the last days I faced some new challenge in testing rails views with rspec. Here is what I learned.

I am useing the veru handy rails controller prepend_view_path helper to be able to choose dynamically what views to use to render the actual request. A sample code is the following:

#controller
before_filter :prepend_view_path_if_required

private
def prepend_view_path_if_required
    prepend_view_path "views/custom_view_path" if my_condition
end

When my_condition returns true, the passed path will placed on top of the views_path rails controller stack. Rails will then look into this location as first choice when looking for a view to render. This technique allows me to choose what view to render in different conditions without the need to hacks into my routes. Is a nice tool. You just say to rails: “if this condition is true looks for views here as a first choice. If nothing is found go on and check into the rest of the views locations stack”

What was a bit challenging was the view testing when prepend_view_path plays a role into the rendering process. Testing a single view placed for example in “views/custom_view_path/view_to_test” is not a big deal.

  # rspec view test
  it ....
    render "custom_view_path/view_to_test"
    rendered.should match/"text to match"/
  ....

But what if the view you are testing has code that render a partial?

#custom_view_path/view_to_test
render :partial => "users/login"

When you run it rspec creates a fake controller for you that will not know nothing about the ‘views path prepending’ that your application is expecting to use. The users/login partial will be looked for in “app/views/users” folder but not in “app/views/custom_view_path/users” where you may expect it is looked for. While a was trying to stub/mock things I then dicovereed that I could simply call the prepend_view_path method on the controller that rspec creates in views specs. My spec is looking like this:

# rspec view test
before do
    prepend_view_path "views/custom_view_path"
end

it ....
    render "custom_view_path/view_to_test"
    rendered.should match/"text to match"/
....

When I run my test the correct views path is added to the controller and my spec runs as expected. Simply and clean.

I then faced a new task. The application I am building uses an helper method called is_mobile_request? that check if the call comes from a mobile. A view I was testing is rendering a partial that isa actually using this same helper method. While this is a smell of a not perfect design I needed a way to stub the result of this helper method call so that my view was able to render as expected. My solution was to declare the spec of type helper and to stub the method on the helper scope.

# rspec view test
describe "custom_view_path/view_to_test.html.erb", type: :helper do

before do
    .....
    stub(helper).is_mobile_request?{false}
    ....
end

end

What happens here is that declaring the spec as type helper I can use/stub the helper scope in my spec.

Conclusion

While I use rspec every day I often find ways to learn new things about it. My advise is to look into rspec code/docs/groups before trying to create hacks to test things. Most of the times a clean and elegant solution is already baked into rspec just to solve your issue.

Ruby tip. Double association in a ternary operator

2012-02-09T00:00:00-08:00

I found myself today in the opportunity to use a double association in a ternary operator. Basically I wanted to assign 2 variables based on a certain condition. Normal ruby double assignment works easy like this:

#simple double assignment
a,b = 1,2
a  # 1
b  # 2

Up to here no surprise. But what if I want to evaluate a condition and assigns both the variables??

#double assignment . Wrong ways
a,b = true ? (1,2) : (3,4)
a,b = true ? 1,2  : 3,4

Both this attempts ends in a syntax error. The right way:

a,b = false ? [1,2] : [3,4]
a  # 3
b  # 4

Easy and clean. Values comes in an array and are correctly assigned. Of course this works for any number of variables you need to assign

# triple assignment in ternary operator
a,b,c = false ? [1,2,3] : [4,5,6]
a   # 4
b   # 5
c   # 6

Rails migration redo

2012-01-29T00:00:00-08:00

A very good practice, when writing a rails migration, is to be sure that the down methods works as expected. Once the migration is ready you should make it run and, if anything is fine, you should rollback it and run it again. In this way you are sure that both the up and down migration works as you planned.

To make it faster you can use the following command

rake db:migrate:redo

This will run a rollback of the lates migration and will run it again.

You can even say how many steps you want to rollback and the re apply using the steps attributes as you do in a normal roll back command:

rake db:migrate:redo step=2

Monitor resque workers via upstart

2012-01-11T00:00:00-08:00

Resque is a Redis-backed Ruby library for creating background jobs, placing them on multiple queues, and processing them later. Resque works firing up a set number of workers than will coninuously look for job to be processed and will execute them following the rules defined when the workers are launched. You can have a single worker process any queue or having a single worker processing a single queue or even fire up more workers that will look forward to a single queue. Read more about resque.

A very important topic is to be sure that the workers are always available and that any time your application is deployed also the workers are restarted. This is crucial cause the worker load an instance of your application and will then process the jobs against this application instance. If you deploy a new version of your application but you do not restart your workers the jobs will be run on an outdated code version and this is clearly something you do not want!

I have solved both the issues using upstart to monitor the workers deamon and a rake task that kill all the workers any time the application is deployed. Basically the idea is that any time a worker is killed upstart will restart it with the most up to date application version.

Here is a sample of the upstart script I use to monitor the workers for my application:

If you are not familiar with upstart you can read more here.

What this script does is launching the workers in a defined rails environment using a passed namespace ( I use namespace to ensure that I can safely use the same Redis engine for different applications/environments ). You can also note that the script execute the command from the application directory using an unpriviledged user. This trick was due to the fact that I run the application and the workers using a specific user ( 'my_user' in the example) and not as root as upstart attempt to do. The rest of the script load in the shell rvm with ruby 1.9.2 before executing the script.

Once this conf script has started upstart will monitor the processes and will restart it something gets killed or does not respond.

Great! I know need a task to be runned via capistrano when a new deployment gets completed. Killing the worker will invoke upstart to restart them with the lastest deployed codebase.

Invoking the task will kill any workers that is registered with the Resque instance running in your application. Be sure to run the task just before to restart your application. In this way you are sure that the task will attempt to kill the correct pids.

Et voila! Any feed bask is welcome.

Git rebase --onto to the rescue ( part 1 )

2011-11-03T00:00:00-07:00

I am now using git since more than a year as my primary scm. I tend to use it also against svn repo, I can so focusing on git becoming always more comfortable using it.

To be honest up to now my git use has always been quite basic, while projects I was working on never needed more that a master/develop/topic branches workflow. Recently I faced a more complex issue related to the necessary support for proper support branch that was going to diverge for a long time from the develop branch.

We have a develop branch where is done the job for new version 2.0 while we still have a stable branch where we support version 1.0. The issue comes from the fact that version 1.0 is not going to receive only simple hotfixes but will also be improved with new feature that need to be ported to version 2.0..

For the first month or so we still were able to merge the 2 branches but not they have diverged too much. Merge is not an option and so we had to find a new strategy.

Our goal was to carry all the changes made on a topic branch borned by the 2.0 branch into the same 2.0 and also to the 1.0 without merging 2.0 into 1.0. This can be solved cherry-picking any single commit from the topic branch to the 2.0 and then merge topic into 1.0. While this works fine we faced situations where the topic branch were actually getting too long and cherry picking many commits can be buggy and tricky.

We finally solved our issue using a git feature called rebas —onto.

An example (you can clone example code here https://github.com/andreacfm/git-test):

Our repo has a develop branch checked out from a master branch. Both master and develop have commits made after they diverged. A topic branch is also borned by develop and some job was made on it.

Rebase onto helps us cause it allows us to say to git to rebase the topic branch on master VIA develop. Basically git makes a diff between master and topic excluding all the job that was made on develop after that devlelop diverged from master. This diff gets applied to master.

Our goal is to bring the 2 commits made on topic branch to master and to develop branch without having to merge develop into master. Topic needs to be rebased —onto master and merged into develop. To make this we need a temporary copy of topic.

$ git checkout topic
$ git checkout -b temp

The temp branch allows us to perform the 2 different actions (merge on develop and rebase onto master) leaving git calculate the diff for us. More on this in the next post.

$ git rebase --onto master develop topic
$ git co master
$ git merge topic
$ git checkout develop
$ git merge temp
$ git branch -D topic
$ git branch -d temp

Before we rebase —onto topic to master via develop. We need then to go to master and to fast-forward master to topic by merging. We can now merge the temp branch into develop and delete both topic and branch. Here is what we obtain:

As you see both develop and master branch has received just the commits made on the topic branch but still develop has not been merged into master. Rebase —onto saved our day cause avoid us to make very long cherry picking session on many different branches (forgot to say our project is much more complex that this example). Respect to the cherry picking technique rebase —onto is also less error prone cause let git calculate the commits you need to apply. Sometimes reading the git tree commits is very hard on big projects and this increase the possibility to loose some commits around.

Make your ruby classes Comparable and Enumerable

2011-07-27T00:00:00-07:00

Something very cool in ruby are mixins. As the word says mixin is a technique to mixed a module into a class using the statement “include”. While including a module is a very large topic I focused on the opportunity to include module defined in the Ruby standard library into your class to take advantages of the methods and abilities that these modules provide. The Comparable module in ruby define methods like < <= == > >= between? . What if I want to achieve is making my class instances comparable so that I can ask to ruby if class_a > class_b. Here an example:

The Person class include the module Comparable and implements one single method (<=>). This methods is used by the Comparable module to perform the logic of any of the operator that the module provide.In the example I say to the Person class to compare instances through the @name attribute. But we even gain more functionalities. Once that our classes are able to be compared they are also able to be sorted if placed inside an array. Amazing!!!

But what if I want to find Persons by name?? Wen can use for this purpose the Enumerable module. What we can do is to create a custom PersonEnumerator class like this:

Including the Enumerable module and implementing the each method we gain most of the many methods that the module expose. In our example I find a person object passing a block that filters each Person by name.

The mixin technique applied to the ruby standard library is very powerfull. Your code code gets more elegant and more Ruby Way for you to maintain and for your collaborator to read and understand

Ruby amazes me any day more!

Ruby instance_eval

2011-07-02T00:00:00-07:00

Working on one of my first ruby gem I have started to learn more about ruby meta programming and ruby core language. My gem needs a sort of singleton class that needs to be configured when the application starts. I have choosed to use a Module as singleton cause a ruby module cannot be initialized and so it just fits my needs. I will then include the configured module into the model that will need it.

What I wanted to achieve was something like:

I created my module and added 2 class methods one called configure that is planned to take care of the block and a method called set that is going to apply the requested configurations. Something like this:

If you run this code you get an exception saying to you that: undefined method ‘set’ for main:Object This was a bit confusing at first. The error is thrown cause the block is created outside of the module scope and is executed in the scope where it was created. In this special case the scope is the general Object scope. What I need is that the block passed to the configure method is executed in the scope of My_module. This can be achieved using the instance_eval method. Passing the block as argument to instance_eval this is executed in the current self scope. Exactly what I need.

In conclusion instance_eval is one of the important topic in ruby meta programming allowing blocks to be sent around and executed in the calling instance scope.

Learning Ruby: gets and chomp

2011-06-11T00:00:00-07:00

Playing with the ruby console I am wondering how I can read some input from the console.

Ruby ships with the method gets that makes easy to read console input. Just try the following code:

When the console asks for your name just type it. The ruby program will read the console input and will welcome you. You will note that a new line is added after that the variable name is printed out. This is the default behaviour of the gets function. Gets add a new line after any variable that memorize. If this is not desired you can call the method chomp on the gets result and the newline is suppressed.

Change your code as follows and the new line will not be printed anymore:

Something about bundler and gems dependencies

2011-06-05T00:00:00-07:00

Since some months I have started to programm in Ruby and especially using the Rails framework. I have to say I find Rails so great that I realized, that after some months, that I can be quite productive knowing very little about Ruby itself. This tells you how powerfull can be a dsl written in Ruby and talks about the nice job Rails developers did but is not going to make me shine as a Ruby developer.

I have decided to step back and I am finally going to open a Programming Ruby book seriously. I will go throught my Ruby discovering writing here my tests and anything I will discover in my learning Ruby travel. This will help me to fix some concept in my mind and hopefully someone else will learn from my mistakes.

For the moment I discovered something about bundler I really didn’t know before and I ’d like to share. I have just ended reading a post of Yehuda Katz about Bundler and Gems dependencies that really opened my eyes.

Something from Yehuda post:

Basic Versioning Rules for Apps

After bundling, always check your Gemfile.lock into version control. If you do this, you do not need to specify exact versions of gems in your Gemfile. Bundler will take care of ensuring that all systems use the same versions.
After updating your Gemfile, always run bundle install first. This will conservatively update your Gemfile.lock. This means that except for the gem that you changed in your Gemfile, no other gem will change.
If a conservative update is impossible, bundler will prompt you to run bundle update [somegem]. This will update the gem and any necessary dependencies. It will not update unrelated gems.
If you want to fully re-resolve all of your dependencies, run bundle update. This will re-resolve all dependencies from scratch.
When running an executable, ALWAYS use bundle exec [command]. Quoting from the bundler documentation: In some cases, running executables without bundle exec may work, if the executable happens to be installed in your system and does not pull in any gems that conflict with your bundle. However, this is unreliable and is the source of considerable pain. Even if it looks like it works, it may not work in the future or on another machine. See below, “Executables” for more information and advanced usage.
Remember that you can always go back to your old Gemfile.lock by using git checkout Gemfile.lock or the equivalent command in your version control.

Executables

When you install a gem to the system, Rubygems creates wrappers for every executable that the gem makes available. When you run an executable from the command line without bundle exec, this wrapper invokes Rubygems, which then uses the normal Rubygems activation mechanism to invoke the gem’s executable. This has changed in the past several months, but Rubygems will invoke the latest version of the gem installed in your system, even if your Gemfile.lock specifies a different version. In addition, it will activate the latest (compatible) installed version of dependencies of that gem, even if a different version is specified in your Gemfile.lock.

This means that invoking executables as normal system executables bypasses bundler’s locked dependencies. In many cases, this will not pose a problem, because developers of your app tend to have the right version of the system-installed executable. For a long time, the Rake gem was a good example of this phenomenon, as most Gemfile.locks declared Rake 0.8.7, and virtually all Ruby developers had Rake 0.8.7 installed in their system.

As a result, users fell into the unfortunate belief that running system executables was compatible with bundler’s locked dependencies. To work around some of the remaining cases, people often advocate the use of rvm gemsets. Combined with manually setting up application-specific gemsets, this can make sure that the “system executables” as provided via the gemset remain compatible with the Gemfile.lock.

Unfortunately, this kludge (and others) sufficiently reduced the pain that most people ignored the advice of the bundler documentation to always use bundle exec when running executables tied to gems in the application’s Gemfile.lock.

It’s worth noting that typing in rake foo (or anyexecutable foo) in the presence of a Gemfile.lock, and expecting it to execute in the bundler sandbox doesn’t make any sense, since you’re not invoking Bundler. Bundler’s sandbox relies on its ability to be present at the very beginning of the Ruby process, and to therefore have the ability to ensure that the versions of all loaded libraries will reflect the ones listed in the Gemfile.lock. By running a system executable, you are executing Ruby code before Bundler can modify the load path and replace the normal Rubygems loading mechanism, allowing arbitrary unmanaged gems to get loaded into memory. Once that happens, all bets are off.

I have to say I learn new things about Ruby every day and I really have to thank devs like Yehuda that keep posting so interesting topics.

Railo cfmap addEvent() support

2011-03-02T00:00:00-08:00

A couple of weeks ago I was reading a post from Raymond Camden that remembered me I completely forgot to add support to addevent() in Railo cfmap implementation. The blog post was quite interesting and showed a way to add streetview to a google map, generated by cfmap, using the Coldfusion.Map.addEvent function. Read the post here.

Of course code was not running in Railo due to the lack of the method in the Railo js library.

I made a patch and support was added in Railo 3.2.1.005/3.3.0.005.

So following the Ray example (all credits to Ray for the following code) you can run the following code in Railo and adding a streeview to your cfmap using the addEvent() function.

Please note that in Railo js library are available both the Railo and Coldfusion namespaces so Railo.Map.addEvent() is equivalent as running Coldfusion.Map.addEvent().

Have fun!

MongoDb Cache Extension for Railo - New Update

2011-02-13T00:00:00-08:00

A new update the the MongoDB Cache extension for Railo is on the extension provider.

Some bug was fixed and performance improved by a better tuning of the query that respects the cache expiration timeout. In my tests I could reach 400 interactions ( put and get of 400 items ) in in average time of 1200ms. Pretty awesome!!!!

Railo WebSockets Gateway Extension

2011-01-24T00:00:00-08:00

I have just uploaded the Railo WebSockets Gateway Extension to the Railo preview extension provider.

This extension enables you to launch a server that is capable to manage messaging from HTML WebSockets.

The server runs on a dedicated port. Railo will receive notifications when a connection is opened, closed and any time a message is sent invoking a cfc listener class. The gateway can also being invoked via SendGatewayMessage so to allow your app to push message to all the connected clients.

While only few browsers natively support WebSockets up to now exists many libraries that mange the failover to flash sockets or other technologies like ajax long polling etc... WebSockets are a great way to implement messaging and data pushing using well known technologies like javascript. The gateway just makes it a breeze pushing data from your Railo application to any connected client.

You can find docs about the extension in the Railo wiki and some sample code cloning the following github repo https://github.com/andreacfm/websockets_example_apps.

Please post any feedback in the Railo Google Group and any bug in the Railo Jira bugtraker.

Railo MongoDB cache extension updated

2010-11-13T00:00:00-08:00

I have uploaded yesterday a main update of the MongoDB Cache extension for Railo. See installation details here

I have improved the management of timespan and timeidle expiring using some incredible feature that MongoDB offers.

1) Any time you ask for a key the plugin attempts to delete it running a MongoDB query ( optimized using index on any relevant field ) and then fetch it. If key is still there means that is a still valid entry.

2) Any 20 seconds a clean process is runned so to keep the db more updated as possible and making the the flush operation on cacheGet() more efficient.

In my test this has improved speed of about 30% delegating more operation to the db itself.

The following code makes 2000 read/write operation in an average of 1500/1600 ms.

Amazing !!!!!

Railo Membase Cache Extension available for beta testing.

2010-10-09T00:00:00-07:00

NorthScale Membase Server is an elastic key-value database that stores web application data far more efficiently and cost effectively than it can be stored in a relational database. With NorthScale Membase Server, organizations can deploy a highly available, cloud-friendly data layer that expands dynamically as application needs change, delivering performance exceeding that of any other NoSQL solution. API compatible with memcached, the de facto standard web caching software, Membase is easy to use and supported by virtually every programming language and application framework.

Membase gives you an easy way to access and use memcached as a key-value database. Membase is a very powerfull solution if you need a reliable, fast and distribuited cache engine.

The Extension allows you to use Membase as a key/value cache for your Objects (components), Templates, Queries and Resources (such as files etc).

More info can be found in the Railo wiki : http://wiki.getrailo.org/wiki/extensions:membase

Railo MongoDB Cache Extension on Beta Test

2010-09-30T00:00:00-07:00

In these days I am really interested in nosql tools and especially in the MongoDB document databse.

What amazes me about mongo is that is much more than a key value pair storage while it expose a quite complete query api, a full indexes support and an atomic Fast-In-Place data update.

Over this MongoDB supports asynchronous replication of data between servers for failover and redundancy. This makes really easy to share and replicate data between a cluster.

The result is that Mongodb is an incredibly fast and flexible document database.

Following what Mark Drew was doing for CouchDb I thought was a good idea to implement a Railo Cache plugin that bring into Railo world the power of MongoDB used as cache engine.

The extension implements the Railo Cache interface at 100%. This means that you can switch from any other cache that Railo support to MongoDb cache with safety. The driver serialize any object ( or queries or templates etc... ) you want to cache and will reinflate them up when you need to read them. An index is created over the key of your cache objects so that reading them will be a breeze. The plugin also support the mongodb replica Sets ( cluster ) and makes your application wait if a failover is in place.

Many thanks to Mark Drew that made the installation docs over the Railo wiki. You can find more info, installation step by step and details here:

http://wiki.getrailo.com/wiki/extensions:mongodb

RailoAjax is going to close

2010-08-21T00:00:00-07:00

While this can looks like a bad new .... well it is not.

Latest Railo BER ( 3.1.2.019 ) has included also the missing part of RailoAjax project into the Railo core distribution. From this point the development and maintenanace of the tags will be made directly from the Railo project itself.

As per today Railo included the following tags:

cfajaxproxy
cfajaximport
cfdiv
cfmap
cfmapitem
cfwindow
cflayout and cflayoutarea ( just for tabs )
ajaxonload function
the js library that support the previous tags

I am quite happy about this step. RailoAjax just started like a fun coding of the ajaxproxy and ended into the Railo core..... I really have to thanks all the Railo Team for the support received.

So please note the following:

If you have a RailoAjax extension installed into your server or we context please remove it before update to 3.1.2.019. Or if you have already updated just remove the extension and restart the Railo.
The RailoAjax website and the trac will be shutted down when Railo 3.2 will be delivered.
The RailoAjax extension provider http://railoajax.org/extensionProvider.cfc will be still available up to the 31 december 2010.

If you have any issues please contact me or raise a JIRA tickect.

If you want to help coding new functionalities the source code is available on github.

Mango Github Gists plugin

2010-08-16T00:00:00-07:00

Something very cool about github services are gists.

Gists are a sort of snippets than you can create, share and embedd using a simple js script tag. I have started to use them very often and I think I will that more and more in the future. JUst think about that gists are also plain git repo and as any git repo can be cloned and shared between your team.

I have created a very simple Mango plugin ( mango in very easy when you want to create plugins !!! ) so that you can embed your gists in your mango posts.

Syntax is incredibly easy .... just have a look here.

The mango auto install url is : http://github.com/downloads/andreacfm/mango.gists/com.andreacfm.mango.gists_1.0.zip

You can also download the zip or clone the source form the same GitHub repo.

Have fun !

[gist:525626]

CfEclipse and script based cfcs

2010-08-11T00:00:00-07:00

While the cfeclipse team is working on giving support to the new scripting syntax added recently in cfml I falled into something that can help someone to have a better feeeling in the meantime.

I was not aware, until yesterday, that this syntax is supported in a script based cfc:

So while it does not really looks “amazing” this will give you code colouring and syntax highlighting. But, most important, the syntax is fully supported from ACF and Railo too ( did not test on OpenBD ).

Some of you will be asking why to do that ? Just use cfbuilder …. and I agree. Cfbuilder is a great tool also if , in my opinion , lack of linux support. But I am one of those who are convinced that cfml deserves an open and strong ide to attract more developers so … if you think like me consider to donate something to cfeclipse project.

BlazeDS 3.2 integration in Railo

2010-07-27T00:00:00-07:00

In the Railo mailing lists are often required informations about the settings needed to implement calls via the AMF protocol. If you use the Railo Installers ( thanks again Jordan for this !! ) anything should already being setted up and ready to use but in case of any needs there was a lack of public informations about this topic.

We have now a nice wiki section where you can find a very exhaustive explanations of many aspect of this topic ( credits to Roland Ringgenberg ) .

Have a nice Railo/Blaze Ds integration !!

Railo tip: cffile action touch

2010-06-30T00:00:00-07:00

For linux/unix user is quite common to use the command touch (from the shell) to update the last modified date of a file (to the current time) or to create a new file.

You can do that as well from Railo :

<cffile action="touch" file="whatever.cfm">

StructNew takes arguments

2010-06-02T00:00:00-07:00

During last Sotr I was talking with Mark Drew and Micheal Offner-Streit ( the Railo cto ) and we discovered one of the many gems hidden into Railo engine.

Any cf developer has always fight with the missing support for a linked hash map in cfml. This lack has made a task keeping a struct in a defined order. In railo you can simple do this:

<cfset str = structNew('linked') />

What you have now is a struct 100% similar to a normal struct that has the whole capabilities of a linked hash map. For example the map keep the elements into an ordered stack.

You can read more in the railo wiki docs.

Railo Amazon S3 extension included into core

2010-05-28T00:00:00-07:00

As you can read from the official Railo Blog the Amazon S3 extension will now be free to download and will be soon moved into the Railo core package.
This is an amazing news from Railo and just one of the extra feature Railo will add in the next future.

So let's stay tuned!!!

Railo starts ajax support

2010-04-12T00:00:00-07:00

I am a bit late blogging about this but I had a quite 'intense' maech.

Since version 3.1.2.009 Railo starts the ajax tags support . You can read more here.

Ok so what's teh big news? What make me proud is that I developed those tags and after a long debugging they are finally part of the Railo core engine. The tags comes from the RailoAjax project that will go on focusing on the remaining ajax tags to fill the gap with ACF ( that's the plan .... but it's a long road to do ....).

This is an example of how a community effort can really contribute to the main project. I am sure more efforts will come in the future ... so if you an idea .... some spare time ..... and you wish to contribute do not hesitate to contact me .... Railo needs you.

Railo Installers IIS update

2010-03-25T00:00:00-07:00

Jordan Micheals has posted a great update to the Railo Installers project.

Take the Railo 4k Challenge and win a ticket to cf.Objective()!

2010-03-12T00:00:00-08:00

If you are interested in Railo and you are thinking to take part of cf.Objective() you cannot loose this. Write 4k of amazing Railo code and win a ticket.

Model Glue Caching - patch update

2010-01-08T00:00:00-08:00

Two days ago I have posted some code that solve ( in part ) an annoying bug regarding caching in Model Glue framework.

As per MG docs the caching declaration can be used on any event-handler and include tag but, in practice. caching is only working if applied to the initial event-handler ( the first invoked by the url ).

Since we want to use MG on our project, and we absolutely need a granular caching system, we are implementing what we think can be a good solution and we would like to share for feedback and testings ( of course the MG team is the first in receiving our code for review and possible inclusion in future releases ).

We have made a new review to the first patch and now MG can support the following instructions:

<event-handler name="page.index">
    <broadcasts />
        <results>
            <result do="views.one"/>
            <result do="views.two"/>
            <result do="template.main" />
        </results>
        <views>
            <include name="three" template="pages/three.cfm" cache="true" />
            <include name="four" template="pages/four.cfm"/>
        </views>
</event-handler>

<event-handler name="views.one" cache="true">
    <broadcasts />
    ....... 
    <views>
        <include name="one" template="pages/one.cfm" />
    </views>
</event-handler>

<event-handler name="views.two">
    <broadcasts />
        ......
    <views>
        <include name="two" template="pages/two.cfm" />
    </views>
</event-handler></p>

As you can see from this code MG can cache a single views but , and this is the best feature I guess , is also able to cache a full event.handler even if that is not the initial event handler.

This solution can really speed up yout MG app reducing dramatically the effort you ask to your server to what your page exactly needs. Any time you are able to cache an "inner request" event MG will just include a bunch of html skipping any broadcasting and this can really save a lot of unnecessary server stress.

Over that imagine you can easily cache a full page excluding just the single lines that ( for example ) are reserved to logged user info/panel ( and of course skipping any unnecessary message broadcasting ).

You can find the patch here ( replace file /ModelGlue/gesture/eventrequest/EventContext.cfc)

Let me have your feedbacks and suggestions.

REMEMBER : THIS IS CODE SHARED FOR TESTING AND NOT FOR PRODUCTION USE.

jQuery 1.4

2010-01-08T00:00:00-08:00

I am quite interested in what is happening in jQuery for the next 2 weeks.

With the release of version 1.4 the jQ team has announced 14 days of news, code relaeases etc.

The website created for the event is nice and as pre release day news we got a brand new api browser site that looks most efficient and organized.

So let's wait and see what news will come in teh next weeks.

Model Glue Caching patch

2010-01-06T00:00:00-08:00

I started last week a very big project where we decided to use the MG framework as rendering engine.

The site will have a huge traffic and will need to display many 'heavy portlets' different by user or context etc...

We started to make some test and investigations on how we could implement pur rendering architecture using the MG view caching system. In short time we discovered that the cache declaration based on the include tag was not processed and considered by the framework.

The final result of our research job was that the only caching support "really" working was the once on the initial event object ( basically the first event called in a new request ).

This was a killer, not for the MG caching system per se ( we use an adapter to ehCache ) but because we completely needed to remove MG from the project. We then decided to make some more test and in a short time we could create a patch that allow MG to cache views based on the declarations made in any single include xml tag.

So with this patch code like this :

<include name="myview" template="pages/web/css_js.cfm" cache="true" cacheKeyValues="id" cacheTimeout="3600"/>

will create a cache copy for 3600 seconds of the view based on the value of the id argument.

Please note that any keys looks for value into the event object so, if you want to use sessionid as a cache key, you should push that into the event object on request start. Following a Sean Corfield suggestion the generate key now also consider the host where the view is processed, so If you run the same application from differents domains any domain generate a different cache.

We send code to Dan Wilson that is the MG maintainer for review and testing.

If you want to use and test ( do not use that in production cause is really not tested code ) downlaod the patch and replace the file /ModelGlue/gesture/eventrequest/EventContext.cfc.

Send your feedback ( or share on MG mailing list ).

Credits goes especially to Cristian Costantini.

Replace CfDocument with Flying Saucer Xhtml renderer

2009-12-23T00:00:00-08:00

As per my previous post about Xhtml Railo capabilities I will post my firsts experiences using Flying Saucer as enhancements of cfdocument tag.

Now, cfdocument is not bad but the rendering capabilities are quite limitated and when I discovered that cfdocument, up to cf9, do not support justified text alignment I decided to give a try with Flying Saucer.

The library works taking your xhtml and rendering that into a pdf processing your css.

What is good is that css2 and 3 are processed correctly so, for example, you can create a page header like:

div.header {
display: block;
position: running(header);
}
@page {
  size: 8.5in 11in;
  margin: 18% 0%;
  @top-left {
   content: element(header);
  }
}

The element in the body that is selected as .header is not rendered as normally you expect but is rendered into any page heading.

Of course same works for footer. See more about css @page here.

Creating a page-break is a breath:

div.break{
    page-break-after:always;
}

Any div with class break will make a new page starts from the div position.

I also discovered that pdf needs fonts to be embedded into the file itself.

This is not supported in css spec but Flying Saucer added some extra css ‘helper’ so that embedding a font is easy like this:

@font-face {
    src: url(file:///TradeGothicLTStd.ttf);
    -fs-pdf-font-embed: embed;
    }

So far the possibilities looks immense and I think they are .

I have created a java class that the absolute path of the xhtml you need to convert and the path of where you want your pdf to be placed and does the job for you.

package com.andreacfm.utils;
import com.lowagie.text.*;
import org.xhtmlrenderer.pdf.ITextRenderer;
import org.xhtmlrenderer.resource.XMLResource;
import org.w3c.dom.Document;
import org.xml.sax.InputSource;
import java.io.*;

public class PDFReader{
    public void createPDF(String url, String pdf)throws IOException, DocumentException {
        OutputStream os = null;
        try {
            os = new FileOutputStream(pdf);
            ITextRenderer renderer = new ITextRenderer();
            Document doc = XMLResource.load(new InputSource(url)).getDocument();
            renderer.setDocument(doc, url);
            renderer.layout();
            renderer.createPDF(os);
            os.close();
            os = null;
            }
         finally {
            if (os != null) {
                try {
                    os.close();
                    } catch (IOException e) {
                    // ignore
                }
             }
         }
     }
 }

You can call it like :

<cfset objPDFReader = createObject('java','com.andreacfm.utils.PDFReader').init()>
<cfset objPDFReader.createPDF(xhtmlPath,pdfPath)>

To install the library download the source.

Copy: core-renderer.jar iText-2.0.8.jar andreacfm.jar ( if you want to load also my util class )

into folder WEB-INF/lib

At this point flying saucer is ready to go but I found some more details to be fixed.

DO NOT MAKE THESE STEPS ON PRODUCTION ENVIRONMENT BEFORE TESTING YOUR APPLICATIONS.

For cf8 users. I have been forced to replace the xalan library that ships cf8 with the latest xalan release due to a bug that prevent the correct namespaceevaluations. I downlaoded the xalan source from here. I then copied serializer.jar,xml-apis.jar,xalan.jar,xsltc.jar and xerceImpl.jar into

WEB-INF/cfusion/lib/updates

In this way when you restart cf server the new xalan version is loaded ( update folder is at the top of jrun classpath ). This worked for me but I cannot be 100% sure that any other xml implementation of cf server will have an impact.

For Railo Users. Flying Saucer works fine with itext 2.0.8. Version 2.1.2, that ships with Railo, brakes previous code. You will need to downgrade to 2.0.8 to make it works correctly. Due to the fact that Railo is often deployed on differents Application Server this can be done in differents ways. Contact me if you want to share yoru experience on this point. I personally added a folder to the Tomcat classpath.

Bad html to Xhtml. The Railo way.

2009-12-22T00:00:00-08:00

I have worked quite hard in the last period with an interesting xhtml rendering java library called "flying saucer" ( I will post more about that in the next future).

This library takes a valid xhtml string and is capable to convert it into a pdf document ( and more formats ) .

What makes this lib special is the ability to format the output using css 2 and 3 stataments. And I could not imagine ahow many things css 2 and 3 is capable of....

I was just worried about the source doc cause that must be a perfectly valid xml document. Sometimes, depending on how the string to be parsed is generated, respecting the strict xml rules can be difficult.

I then discovered that Railo ships an htmlFormat() function that is capable to "repair" your bad html and gives you back a nice xhtml format.

Look at this example:

This is a very bad html piece of code saved into a variables and parsed into htmlParse()

<cfsavecontent variable="html">
Text
<h3>Title
    <ul>
        <li>item<li>
        item
     </ul>
     <li>More text<img src="" ></li>
</cfsavecontent>
<cfset xml=htmlParse(html)>

Here is the output generated by htmlParse()

<?xml version="1.0" encoding="UTF-8"?>
<html>
<body>Text
    <br />
    <h3>Title</h3>
    <ul>
        <li>item</li>
        <li>item</li>
    </ul>
    <ul>
        <li>More text <img src=""/></li>
    </ul>
</body>
</html>

As you can see this is a perfectly valid xhtml string.

I am now sure that I can give to my xhtml rendrering library the xhtml formts it needs with no worry about how bad the source can be.

Thanks to Railo for this amazing feature.

RailoAjax 0.5.2 with cfmap is out

2009-12-11T00:00:00-08:00

Railo Ajax arrived to version 0.5.2.

From this release cfmap has entered into the set of tags that RailoAjax ships. Cfmap support is still experimental and do not cover event the 50% of the ACF version but development is on the way.

See more here.

Remember that the demo app that you see online is installed ( if required ) when RailoAjax deploy on your Railo server. So you can have a look to the demo code that can help you on development stage.

Another important announcment is that CFMENU is on the way to appear from a community contribution. Cfmenu has been added to 0.6 milestone ( at least in alpha version ).

Next step will be focused on docs. For a month or so the main efforts ( over cfmap implementation ) will be on dodumenting what has been done up to know keeping an eye on bugs of course.

Do not hesistate to contact me for any question and of course .... project is open ... so feel free to jump in ....

Where Railo comes from......

2009-12-08T00:00:00-08:00

[youtube:1LwG1Qmgtb0]

My first cfwheels plugin - ioc interface

2009-12-07T00:00:00-08:00

I decided to play around with cfwheels cause I was amazed by some examples I saw around and I have to admit is good fun.

After 1 hr testing I realized that no ioc support is build into cfwheels and ..... I really cannot live with no Ioc container available at any time so I decided to add a plugin for managing a beanFactory into cfwheels.

Probably is not the best cfwheel plugin ever written but was very easy and painless. While I tend to be very OO guy I am amazed by conventions in last period ( I am also playing with Sean Corfield FW1 ). While I am also an happy user of Coldbox and ModelGlue I find that sometimes frameworks added complexity also to easy tasks. From here my desire to look into frameworks that make of conventions their core basement.

In my mind conventions means less code in default situations and about this cfwheels and fw1 at the moment are the best. Btw I also think that for a more complex task Coldbox really has something more to help development of more advanced applications.

You can find the plugin here to play with it and have a look to cfwheels.

ColdBox Book Released

2009-12-03T00:00:00-08:00

I am a big coldbox fan and I am very glad to post about the release of the ColdBox Book. I am ordering a copy for me and, if you are serious about coldbox, I strongly recomend it.

Coldbox has always been very well documented and the book will surely be an interesting way to go deeply into coldbox framework.

Thanks to Luis for the hard job.

Railo Ajax 0.5.1.5 released

2009-11-08T00:00:00-08:00

A new version has been released.

The most interesting news is the complete refactor of the UI tags. RailoAjax library now provide bridges classes that need a speficic adapter to perform the action required. This allows to switch between one library support to another with no need to change the core code.

An example can be found here.

Once the concrete implementation is done ( the Ext cfwindow is already done ) you can choose the library using the cfajaximport tag.

<cfajaximport library="ext />

Having implemented a bridge pattern for any UI implementation has also allowed us to provide a set of new events provided directly by the Railo.Events engine that do not rely on the specific implementation making code even more portable. The following event has been added :

Window.beforeCreate
Window.afterCreate
Window.beforeShow
Window.afterShow
Window.beforeHide
Window.afterHide
Window.beforeClose
Window.afterClose
Layout.afterTabSelect
Layout.beforeTabInit
Layout.afterTabInit
Layout.beforeTabCreate
Layout.afterTabCreate
Layout.beforeTabRemove
Layout.afterTabRemove
Layout.beforeTabSelect
Layout.afterTabSelect
Layout.beforeTabDisable
Layout.afterTabDisable
Layout.beforeTabEnable
Layout.afterTabEnable

What is usefull is that these events will always be usable in the same way not depending by the the tag concrete implementation. So If I need to listen to a window hide event and I have choosed the ext implementation I can use both the following syntax:

Railo.Events.subscribe(callback,'Window.beforeHide')
//or
Railo.Window.getWindowObject('mywin').addListener('beforeclose',callback,this);

The RailoLayout.js package has already been rewritten with the default jquery implementation.

Version 0.5.2 will allow ui tags to receive an options arguments called 'args'. This struct will be converted into json and pushed into the implementation init method. In this way any config defined by the jquery or ext apis will become available. I am also working on a start for cfmap implementation.

Cf Event Manager 1.0

2009-10-25T00:00:00-07:00

After more than 1 year of testing I have finally reached a stable version of a feature I use since long time.

A previous version released on riaforge 6 months ago has been completely rewritten and extended.

### Who Em is for??

Developers interested in developing cfml using an events based programming paradigm in the every day coding practice (not only inside an MVC like model glue or coldbox).
Anyone interested in making his own applications extensibles.
Developers looking for a base framework to build on.

### Is Em an MVC framework ??

No, EM is about events.

Almost any application is based on events so EM can be the base of almost any cfml application or framework you want to build.

A dedicated site has been created http://cfeventmanager.com
Tickets, Road Map and Docs ( actually 60% ) can be found at http://trac.cfeventmanager.com

Please have a look and let me have your feedbacks. A demo site is included in the downlaod package or is visible on the site.

Railo Projects

2009-10-22T00:00:00-07:00

I have just finished to move RailoAjax project to the new, and final location, into the brand new space Railo is creating for supporting OS projects.

Site is now visible at http://projects.getrailo.org/projects/railoajax/

Svn has been migrated and can be found at http://svn.getrailo.org/svn/railoajax/ ( checkout as guest/guest)

Trac install http://getrailo.org/trac/railoajax/

If you have a started project related to Railo or an idea you and you need support on your development please visit :

### http://projects.getrailo.org

or drop me a line.

Templating in jQuery with jTemplates

2009-10-15T00:00:00-07:00

I am working in these days on the front side of an application that need to manage a huge amount of data pushed in JSON format.

These datas are not needed to be analyzed or filtered.

What I need is to be able to display info ( coming in a unique set of data ) in many different part of the page using quite complex html generated by many conditional statements. Of course I need to be able to refresh the different areas individually.

I have used in the past spry or ext in these case but I always considered both oversized for this job, at the end the dataset has not to be manipulated.

I have then found a very powerfull solutions in jTemplates. This is a wonderfull templating tool that can be used as jquery plugin or in plain js. Between the features available :

conditional statements
looping
parameters
nested templates

Performance are very good. Have a try I really recommend this.

Railo Ajax 0.5.1.4

2009-10-08T00:00:00-07:00

This version of RailoAjax starts the support of functions not strictly related to a tag or to a UI object like tabs or windows.

Firsts functions to be supported are:

Railo.Ajax.submitForm
(formId,url,callbackhandler[,errorhandler,httpMethod,asynch,returnFormat,beforeSend])

You can use this fucntions to ask a form to be ajax submitted at any time with no need to trigger the submit event.

Railo.Ajax.ajaxForm
(formId[,target,callbackhandler,errorhandler,returnFormat,beforeSend])

This function is used to configure a form to be submitted in ajax mode. The main difference with the previous one is that in this case the form will be submitted in ajax mode in any case, and not only when invoked by the function itself.

Railo.Ajax.navigate is on development stage.

ColdFusion 9 is out

2009-10-05T00:00:00-07:00

I was expecting the release for Max but this morning I found the new CF9 available for download from Adobe Web Site.

Many intersting news respect to cf8 are availble :

Orm Support
Cfspreadsheet
Caching
Exposing of services like mailing, pdf manipulation etc….
Many more….

A lot of job will start now to test, on official release finally, all the new possibilities that cf9 ships.

Good job!

RailoAjax.org

2009-10-03T00:00:00-07:00

The RailoAjax project has finally arrived to his own location.

RailoAjax.org is a the home site that will show news, guides to get started and will be updated with any usefull information about releases, road map, tutotials etc…

The documentation part has been moved into a dedicated Trac Install that can be found at http://docs.railoajax.org.

The Trac install will be used for:

Docs in wiki format
Tickets
Milestones and road map
Svn Browse

A new extension provider has been created and is already available:

http://railoajax.org/provider.cfc

Use the Railo’s google group list for posting any related question or contact me at : andrea@railoajax.org.

The spece on assembla site will be closed in teh next days.

RailoAjax core is jquery free.

2009-09-18T00:00:00-07:00

To make library lighter, especially for core usage, I have removed the jQuery dependency from the core RailoAjax library. What does this mean ??

Core tags like cfajacproxy or cfdiv do not use any UI lib and they rely on the lonely RailoAjax library. Up to version 0.5.1 some task like binding and xhr calls where made with the jQuery help and we were forced to load jQuery in any page.

From version 0.5.1.1 ( already available ) RailoAjax is free from jquery dependency:

XHR

You can now use RailoAjax as a XHR utility:

<p>var x = new Railo.XHR() ;<br />x.request({<br />url : url,<br />success:....<br />});<br />

DOM Events

Dom event binding can be added like this:

Railo.Util.addEvent(dom element, event, callback );

Btw I decide to keep one dependency in RailoAjax that is Sizzle.js.

Sizzle is the most powerfull selector engine out there. Sizzle is fast, flexible and come from jQuery core.

Check out docs if you like.

You can use sizzle just as you were used to use jQuery selector:

<p>var element = Sizzle('#myId');</p>

Of course Sizzle return array of dom elements and not jQuery Objects.

Railo Ajax 0.5.1

2009-09-13T00:00:00-07:00

RailoAjax 0.5.1 has been released.

This update added the initial support for cflayout and in particular for the tab type. Over the cf8 compatibility I am trying to add more things like e deeper callback support and some extra functionalities from tje jquery UI library.

You can update from Railo Admin ( if you already installed the extension ) or install from these 2 extensions providers:

http://www.andreacfm.com/railoEx/andreacfm.cfc
or
http://preview.getrailo.org/ExtensionProvider.cfc ( this will be
updated tomorrow - monday 14 during the day).

Let me have your feedback and wishlist for the next project ehhancement.

Railo Ajax 0.5.0.3

2009-09-07T00:00:00-07:00

I have just updated the RailoAjax extension provider with the new release. Many bugs have been fixed and a started cflayout ( just for tab up to now ) has been added to the demo page. Please let me have yur feedbacks, bugs, suggestions etc...

You can grab a copy from svn repository or use the following extension provider:

Svn

AndreaCfm Extension Provider : http://www.andreacfm.com/railoEx/andreacfm.cfc

From Railo preview server : http://preview.getrailo.org/ExtensionProvider.cfc

Change log:

0.5.0.3
-------------------------------
* Cflayout-tab binding.
* Added support for tab add,hide,remove.
* Support for tab custom styling.
* Defined demo structure
* Bug fixing.
* Started docs in wiki.getrailo.org.

0.5.0.2
-------------------------------
* Added cflayout tab initial support.

0.5.0.1
-------------------------------
* New examples in demo pages.
* Support for context root deployment.

Railo Ajax Extension Provider

2009-08-29T00:00:00-07:00

I have created a Railo extension provider from my website. For the moment the only application you can install is the Railo Ajax Project that is also available from the http://preview.getrailo.org/ExtensionProvider.cfc provider.

So now you have more choice... and I had the occasion to go deeper into railo extensions programming...

Just add this url in the providers list of your Railo Admin ( server or web ) :

http://www.andreacfm.com/railoEx/andreacfm.cfc

Verify the provider and then you will find the Railo Ajax application available in the applications list. Run the install thread that will also install some demo into yoru webroot.

IMPORTANT:

If you have already installed the extension from the http://preview.getrailo.org/ExtensionProvider.cfc provider stay with that. I will update both the providers with new versions at the same time but as the providers are different and the extension have the same id some conflict is possible. Just choose one provider.

Railo Ajax Extension 0.5 now available from Railo Admin

2009-08-27T00:00:00-07:00

Some moths ago I started to work on a project to create Railo support for ajax tags. The idea was to implement CfAjaxProxy using the new custom tag based on cfc format that Railo makes available.

We decided to use jQuery as library to work on. I have a good feeling with it and we kept the door opened also for UI tags implementation. Things went quite well and I am particulary happy of the Bind system that manage cfc/url and javascript bindings.

I have also added support for cfdiv and for testing purposes also of cfwindow and cfajaximport ( this is really more as internal use for now ). Installing the Railo Ajax Extension you will also have the option to install a demo page that I will make more explicative in the next days. New examples, comments and notes are on the way.

You can find install isntructions here while project is actually hosted here. Please use assembla site for tickects and any other support needs. You can also post on the railobeta Google Group.

A special thanks to the Gert that hepled me a lot in writing the Railo Extension ( a post/tutorial is on the way ).

Railo 3.1.1 Released

2009-08-12T00:00:00-07:00

As expected in the community Railo 3.1.1 has been released for cfunited.

At the moment there is no official post by the team but my Railo has updated to version 3.1.1 right now so I guess .... here we are.

Over the usual bug fixing ( Railo users are used to get bug fixing very fast ....... think about that.....) this release is important cause is the first stable release after that Railo choosed the OS way. Since some month now I am using Railo as my only cfml engine and I take this occasion to say thanks to Gert, Micheal and all the team for the good work!

You can download Railo here.

Fusion Debug 3.0

2009-08-12T00:00:00-07:00

As I blogged in the past I am a fusion debug user and I was waiting the new release that also cover Railo 3.1 as debuggable cfml engine. Here more informations about the new fusion debug release:

New features included in FusionDebug 3.0

Full support for Railo 3.1 Open Source / Enterprise
Conditional Breakpoints
Break on Runtime Exceptions
Run To Line
Custom Extensions

Detailed Feature Focus: http://www.fusion-reactor.com/fd/featurefocus/

Quick Links

Download: http://www.fusion-reactor.com/fd/downloads.cfm
Upgrade: http://www.fusion-reactor.com/fd/upgrade.cfm
Buy: http://www.fusion-reactor.com/fd/buy.cfm

Other Sources

Fusion Newsletter: http://www.fusion-reactor.com/newsletter/August2009.cfm
Press Release: http://www.prweb.com/releases/2009/08/prweb2733124.htm

SwfObject Mango Plugin Released

2009-08-09T00:00:00-07:00

Again I was amazed of how easy is creating a plugin for Mango blog platform.

I needed to load swfobject library in any page and I made up a plugin to add this functionality to my mango installation.

Plugin is very easy and once activated just load swfobject 2.2 on any page for use of any other code or plugin. Here you can get it!

Last Version : 2.2
Require : Mango 1.3+
Auto Install Url : http://mangoswfobject.riaforge.org/index.cfm?event=action.download

EventManager Vol 1

2009-07-12T00:00:00-07:00

I start today a series of post on the usage and documentation of my EventManager for coldfusion. You can find more docs and svn code here.

Initialize The EventManager

EventManager is done to work standalone or to be easily integrated with Coldspring. Both examples will be provided.

Standalone

Init( Events:Array , Listeners:Array , XmlPath:String , AutowireEvents:Boolean , Debug:Boolean , Scope:String )

The init method takes the following arguments.

Events:Array - default arrayNew(1) - Array of structs representing the events to register.
Listeners:Array - default arrayNew(1) - Array of structs representing the listeners to register.
XmlPath:String - default "" - Relative Path to an xml file containing events and listeners to be registered.
AutowireEvents:Boolean - default false - If true any event create for being dispatched is autowired using beanInjector.
Debug:Boolean - default false - If true force Em to save a trace of any operation executed.
Scope:String - default 'request' - Says to Em how to save the tracing info if debug mode is true. Request use the request scope and clean up the trace memory any time the request die. Instance persists the informations into the EventManager instance itself.

.....add more events.... .....add more listeners.... .init(events,listeners) />

### Xml Syntax via xmlPath

You can setUp your events/listeners using xml notation. The xmlPath argument you can pass to init mode represent the relative path to the xml config file.

.init(xmlPath='/myapp/config/eventmanager.xml') />

In init method using the xmlPath attribute will not overwrite or stop the eventManager from loading arrays of events and listeners if provided.

<code class="coldfusion"><cfset eventManager = createObject('component','EventManager.EventManager')<br />.init(events,listeners,'/myapp/config/eventmanager.xml') /> <br /></code><br />

The previuos example will load all the events from array and xml and then will register listeners from array and from the xml too.

See xml for schema details. In teh resource folder are present both .dtd and .xsd to validate your xml.

### Coldspring Tip

If laoded via coldspring you can use the great syntax tool to create arrays and struct from xml that coldpring shipd for free

myEvent EventManager.Event ....... more events here ... myEvent evapp.listeners.mylistener or methodToFire .................... more listeners

Fusion Debug available for Railo

2009-07-09T00:00:00-07:00

One of the lack in the Railo world was the availability of an inline debugger. I always use fusion debug or internal cf inline debugger when using abode cf and sometimes I felt the lack of that developing with Railo.

The good news is that a railo compliant version of Fusion Debug will be available very very soon ( the public beta programm has just finished some week ago ). I had the opportunity to test the beta product and was working just fine as I expected it.

The functionalities are great and basically the same of the Fusion Debug version for coldfusion. Installation gave me some trouble that I easily solved on the google groups that the guys of Integral setted up to support .

As far as I know the enterprise Railo edition will include a license of both Reactor and Debug products. I am a Fusion Debug license owner but I am not sure if the Railo product will need a license update or not. I am waiting the product release in the next weeks to check it.

In conclusion I think that having an inline debugger available make Railo even more a robust solution.

Cf Event Manager

2009-06-05T00:00:00-07:00

I have now released a first version of a tool that I am implementing and using since a while.

CfEventManager is exactly what the word say. An EventManager tool for cfml programming.
Some of the features:

Very light with a simple API to use/implement.
Flexible to allow registering of events / listeners from cfml syntax, xml file and programmatically on runtime.
Ability to cache the listeners objects.
Use the built in event object or create your own in few easy steps.
Ability ti stop event propagation.
Order the listeners with a customized priority order.
Autowire events object via coldspring by using the Brian Koteks beanInjector class.

On next releases to 1.0:

Dispatching of async events.
addEventListener based on regex match.

Download and Svn

Docs ( not completed yet )

Project Page on this Blog

First step on CentOs

2009-04-30T00:00:00-07:00

After deciding to move to Railo I get curious about OS systems and I am trying to set up a test environment using CentOs that looks like the best Enterprise linux distribution now available ( I am very new to linux world so I am possible completely wrong ).

I installed centos 5.3 on a virtual machine and now ?????

I will post my experience and newbie tips like:

STARTING APACHE ON CENTOS

<code class="coldfusion">
START APACHE
/sbin/service httpd start

RESTART APACHE
/sbin/service httpd restart

STOP APACHE
/sbin/service httpd stop

ALL THE OPTIONS
/sbin/service httpd
#will output all the possible methods you can call on httpd service. </code>

More newbie tips on CentOs, up to installing a development environment for railo, in the next future.

Text Ads Mango Plugin 0.1

2009-04-20T00:00:00-07:00

I have now released the very first version of TextAds , a Mango plugin that enable the management and display of text ads on your mango installation.
At this first stage plugin support just one provider planning to add more in the next future.
Let me have your feedback.

I am also interested in knowing which provider ( over adwords ) of text ads you are working with.

Last Version : 0.1
Last Update : 20 apr 2009
Require : Mango 1.3+
Auto Install Url : http://andreacfm.com/get/com.andreacfm.mango.textads.zip

Speed up your eclipse

2009-04-07T00:00:00-07:00

I think that any eclipse users has experimented the fact that eclipse tends to slow down. In the past I had to reinstall the whole environment especially after loading new plugins that was probably breaking something down. Btw I always followed as best practice to clen up eclipse any 6 months and I learned fast how to export preferences to be able to push them into the new install. In this way to pass to a new and clean eclipse install is quite painless.

In the last period I tried to reduce the number of opened projects in my workspace to the really important ones, and I also experimented the solution of mantaining many workspaces but I do not feel very compofortable with that.

I then got the idea to check what kind of settings eclipse was passing to the jvm and blogging around I found a great post of Mike Henke.

I added the following arguments to my eclipse.ini file:

<code class="coldfusion">
-vm
C:Program FilesJavajre1.6.0_12injavaw.exe
-vmargs
-Xms512m
-Xmx512m
-XX:PermSize=128m
-XX:MaxPermSize=128m
-Xverify:none</code>

The vm path depends on what do you have available in your machine, but I suggest you to update at least to version 1.6 update 12. Be carefull do not leave extra white spaces and .... look your turbo eclipse start to fly...

Railo 3.1 is out

2009-04-01T00:00:00-07:00

At the and arrived the day of the release of Railo 3.1. This is a milestone due to the fact that from this date Railo is officialy Open Source and most important joins a wide supported project like Jboss.

Many news that I think will make the fortune of Railo that I am starting to consider any day more like my choice for the future:

Brand new sites taht will be soon filled with news and docs ( getRailo.com and getRailo.org )
Beta 3.1 version on Resin
First experiment ( this is whant I am mostly interested in ) of jboss/railo installer on IIS7
Railo will now have an extension manager connected to the website repository. There will be an api to give any developer the road to follow to write your own extensions and the place where to share them......I think this will be the key.

Good luck to railo and to the railo team!

Running Mango on Railo. Preserve single quotes issue.

2009-03-10T00:00:00-07:00

Trying mangoblog on my Railo installation I found at once a bug that invole the different way that railo and cf have to preserve the single quotes in sql syntax where the sql statement is represented by variables.

Mango Blog use a class called QueryInterface where most of the query devoted to collect data ara executed and cached so to speed up teh next identical request.

The used method is this:

<cffunction name="makeQuery" access="public" output="false" returntype="any">
        <cfargument name="query" required="true" type="string">
        <cfargument name="cacheMinutes" required="false" type="numeric" default="-1">
        <cfargument name="returnResult" required="false" type="boolean" default="true">

        <cfset var customQuery = queryNew('id')/>
        <cfset var queryStatement = trim(arguments.query)>

        <cfif arguments.cacheMinutes GT -1 AND arguments.returnResult>
            <cfquery name="customQuery" datasource="#variables.datasource.name#" username="#variables.datasource.username#" password="#variables.datasource.password#" cachedwithin="#createtimespan(0,0,arguments.cacheMinutes,0)#">
            #toString(queryStatement)#
            </cfquery>
        <cfelse>
            <cfquery name="customQuery" datasource="#variables.datasource.name#" username="#variables.datasource.username#" password="#variables.datasource.password#">
            #toString(queryStatement)#
            </cfquery>
        </cfif>

        <cfif arguments.returnResult>
            <cfreturn customQuery />
        </cfif>

    </cffunction>

</code>

As you see the sql syntax is represented by the variable queryStatement.

To be sure that the essential sinqle quotes are preserved Railo add an psq attribute:

<code class="coldfusion">
<cfquery name="q" datasource="dsn" psq="true">
.................

</code>

Since from cf8 this code is accettable also in coldfusion due to the added ability to pass an argumentcollection to most of the tags where only the recognized attributes are evaluated while the others are skipped.

But I didn't want to loose cf7 compatibility ( this will crash trying to evaluate the psq attributes ) so i tried to use, also for Railo ,the preserveSingleQuotes() function and surprise....is working just fine. Following Railo docs "psq" attributes should be the safest way but after about 2 weeks of runnign Mango with this change I am now convinced that preserveSingleQuotes() will server us ok in this case.

<code class="coldfusion"><cfif arguments.cacheMinutes GT -1 AND arguments.returnResult>
            <cfquery name="customQuery" datasource="#variables.datasource.name#" username="#variables.datasource.username#" password="#variables.datasource.password#" cachedwithin="#createtimespan(0,0,arguments.cacheMinutes,0)#">
            #preserveSingleQuotes(queryStatement)#
            </cfquery>
        <cfelse>
            <cfquery name="customQuery" datasource="#variables.datasource.name#" username="#variables.datasource.username#" password="#variables.datasource.password#">
            #preserveSingleQuotes(queryStatement)#
            </cfquery>
        </cfif>

</code>

In this way we keep a full compaitbility from on cf7, cf8 and Railo too.

Jquery Ui 1.7

2009-03-06T00:00:00-08:00

Has been released today version 1.7 of jquery UI library. I have never used it so much but from this realease i think that UI becomes a valid options.

In my opinion the library has a big lack that is the fact that looks like the jquery team is not interested in developing also a data management tool to be use with the UI widgets but .... we can mix it with spry dataset or extjs stores.

Some of the biggest news from the jquery blog:

jQuery 1.3 compatibility

jQuery 1.7 is the first release that is compatible with jQuery 1.3. That’s a good thing (if you can make the switch), since jQuery 1.3 brings major performance improvements to many areas of jQuery UI. Specifically, firing events, DOM operations, and getting element offsets have had massive performance improvements. More about the jQuery 1.3 release…
Revamped and optimized plugins

In addition to a long list of bug fixes and improvements, we’ve refactored and optimized each plugin to use the cleanest HTML possible, with a flexible set of options to make it easy for developers to extend and tweak widgets. We’ve also added a new progress bar plugin in this release.
CSS framework

jQuery UI 1.7 is built upon a brand new and powerful CSS framework that is designed to support not only jQuery UI’s own plugins, but also custom plugin development, so any developer can easily make their plugins ThemeRoller ready. It is a special kind of CSS framework that is aimed specifically at user interface development as opposed to overall page layout. The framework provides classes for commonly used UI elements, states, containers and icons and is manipulated by jQuery UI ThemeRoller. More about the jQuery UI CSS Framework…
Themeroller v2

ThemeRoller has been completely redesigned to complement the new CSS framework and widget designs. ThemeRoller now resides in a vertical sidebar and has loads of new features. We also created a ThemeRoller Developer Tool (a bookmarklet, so you can bring ThemeRoller into any web page) and a Theme Switcher (so you can switch between themes with a simple drop-down box).
Demos & Documentation

Maybe you’ve seen it already: We merged the top navigation links “Demos” and “Documentation” into a unified Demos & Documentation section, so it’s easy to browse demos and read the documentation all in one integrated experience. We’ve grouped demos of similar features and options together so you can easily tab from one to another and compare. As you navigate within a page, we update the URL to ensure accurate bookmarking and deep linking.
Full offline documentation

Full documentation for each plugin is now included in the release. Just take a look at the /docs/ folder in the development bundle. There’s a separate (and simple) html file for each jQuery UI plugin method. There’s no styesheet for these files yet, but they’re quite functional even without. We’ll see about making it a little more like the website Demos & Documentation in a future release.
Major website improvements

We refactored the download builder (using progressive enhancement, so it now works with JavaScript disabled) and integrated a base theme into the download along with a demo html file of all the widgets for easy integration. We refactored and improved the landing pages for the Development and Support sections to be more information-rich and up-to-date.
CSS framework and themes on Google AJAX Libraries API

As before, the latest stable release of jQuery UI (now 1.7) is hosted on Google’s CDN. New in this release, however, Google is also hosting the new jQuery UI CSS Framework, as well as our current suite of pre-built themes: base, black-tie, blitzer, cupertino, dot-luv, excite-bike, hot-sneaks, humanity, mint-choc, redmond, smoothness, south-street, start, swanky-purse, trontastic, ui-darkness, ui-lightness, and vader.
Themes bundle

You can now download all the ThemeRoller Gallery themes at once: jquery-ui-themes-1.7.zip. Or if you’re savvy with svn: http://jquery-ui.googlecode.com/svn/tags/1.7/themes/.
A new dedicated blog

If you’re reading this, you probably know it already. We finally made the switch to our very own blog at http://blog.jqueryui.com/, where we’ll regularly blog about development, theming, and more during each release. To link the jQuery and jQuery UI blogs, Richard Worth is starting a “This week in jQuery UI” series on the jQuery UI blog, while Karl Swedberg (of learningjquery.com) will do a “This week in jQuery” series on the jQuery blog, and they will link to eachother.

Ses Url on railo and coldfusion on Jrun 4

2009-03-01T00:00:00-08:00

Going on working with my new multiserver installation I falled into an issue that took me a bit of time to go throught.

I could normaly run my application using cf, railo and openbd but all the application was failing trying to call a ses url like:

<code class="coldfusion">http://railo/index.cfm/mypage/
</code>

The server is simply not able to find the .cfm mapping and just do not invoke any cfm engine like .cfm mapping was not in the url.... what made me think is that this happen only with the instances I added to jrun but not to the main cfusion server ( the ones that I installed jrun with ; in my case cf8 ).

I started look around and especially in the web.xml ( placed under the web-inf folder of any server instance ) file where mapping and settings for the jrun server instance are placed ( In my case file is here : C:JRun4serverscf7cfusion.earcfusion.warWEB-INFweb.xml) . With my surprise I found that in any cf instance added to Jrun this code is commented by default:

<code class="coldfusion">
</code>

Basically if you uncomment this code and restart the server also a mapping like : .cfm/page make the server invoking the coldfusion engine while before the jrun server simply was not able to recognize the mapping and was answering that no application was setted up to answer to the request.

While I solved the cf issue I found more problems to set up railo mapping cause as we all know jrun is not the railo "first choice" and settings are a bit different as in the default railo installation under Resin .... After some testing I added this code to C:JRun4servers ailoWEB-INFweb.xml , restared the server and also railo started to respond correctly...

<code class="coldfusion">
<servlet-mapping>
     <servlet-name>CFMLServlet</servlet-name>
     <url-pattern>*.cfml/*</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>CFMLServlet</servlet-name>
    <url-pattern>*.cfm/*</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>CFMLServlet</servlet-name>
    <url-pattern>*.cfc/*</url-pattern>
</servlet-mapping>

</code>

Please note that I need to restart completely Jrun and not only the railo instance to make chanhges being recognized. I am not sure wht ( probbaly some kind of main config cache ) but after restarting jrun also Railo instance started to work fine with ses url.

I have not yet solved the matter with openBd but I plan to look into it soon.

Xml parsing issue on railo and openbd.

2009-02-17T00:00:00-08:00

As per my previous post I have installed Railo and Open BlueDragon on Jrun 4 as instances of a multiserver installation that also support cf8 and cf7.

Starting my tests I noted that both Railo and OpenBd in this particular configuration shows issues performing xml parse operations.

I got errors on both servers running code like:

<code class="coldfusion">
var xml = xmlParse(xml);
result = xmlSearch(xml,'/items/');
</code>

Googling around I discovered that Jrun miss some classes/configurations that both Railo and OpenBd native installtion provide.

I added this line in the java.config file as java.args ( I cut it for making it readable but you must add it all in one line with no spaces ).

<code class="coldfusion">
-Djavax.xml.parsers.DocumentBuilderFactory=
com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl
</code>

Restart the server and the xml functionalities will be regulary available.

Installing Railo and Open BlueDragon with ColdFusion 8 Multiserver on JRUN4

2009-02-09T00:00:00-08:00

In the last meeting of the Italian CFUG we got a very interesting speach about the ability to install coldfusion as multiserver ( Jrun 4 platform ) and the convenience to deploy under it more instances of coldfusion or of any other JAVA J2EE Web or Enterprise Application. I so started my tests for setting up my personal test environment with Adobe cf, Railo and Openbd all deployed under the same multiserver installation.

I started my test installing Cf8 as multiserver and the process ended succesfully. Cf8 is now installed in c:\jrun4serverscfusion

At this poit Jrun 4 is installed and is reachable through port 8000.

I use IIS 7 locally so I decided to let coldfusion installer take care of the appropriate settings over my default web site. Up to here nothing really changed in the ways I use cf: iis is correctly mapped, cf admin is always reachable through cfide an so on. What change is the fact the cf8 is now a single instance of a JRUN multiserver installation ready to receive and manage more applications.

I downloaded Railo War file from here.

Back to the Jrun4 administrator I created e new server ( I called it Railo ) and this was confirmed on port 8302.

On the Pictures you see my Jrun4 with many instances already deployed so just keep them as example.

Follow the next steps:

1) Change the Railo.war file extension to .zip and unzip that.

2) Go to your {jrun4 folder}/servers/Railo/ and delete the default-ear folder. ( Optional but recomended )

3) In the Jrun4 admin panel select the railo server ( if is not running switch it on ) .Go to the J2EE Componenets tab and click on deploy in the Web Application Area .

4) Search the folder where you unzipped the war file and confirm. Wait the time jrun need to deploy railo and....maybe looks too easy but.....you are done. Railo is deployed and ready to serve your cfm pages.

You can now reach your railo installation like http://localhost:{installation port}/{server name - railo in my case}/railo-context/admin/server.cfm.

Now I have Railo installed and working but I want to set up a real test suite that gives me the ability to test the same code with different engine with no files copy or syncro.

1) Craete a new site in IIS ( I have IIS 7 on Vista ). Point it to your webroot ( in my case d:wwwroot ) and add a custom header like 'railo'.

2) In the Jrun administrator go in the J2EE components tab and click on the server name. In the Web Application Overviewwhere change your context root to "/" and point the document root to the position of your IIS wwwroot ( d:wwwroot for me).

3) Now we need to set up our web server. In your jrun installation folder go in the bin folder and open the wsconfig file. A java tool will open up.
Click on Add. Select railo as jrun host, IIS as web server and railo as the site name we want to configure. Click on advanced and add .cfm and .cfc as mimtypes. Confirming the tool will add the correct mapping to your IIS 7 so that the railo web site will use railo engine and not cf8 for processing cfm and cfc files.

4) As last step open your host file .
On vista should be something like : C:WindowsSystem32driversetchosts

Add this 2 line :

127.0.0.1 railo
127.0.0.1 cf8

Save and close the file.

Now if you open your browser and try to call http://cf8/ the call will be directed to 127.0.0.1 and in my case will call the IIS default web site.

But if I call http://railo/ my IIS is setted to recognice railo as railo web site header and process cfml using railo engine.

For testing it I simply put an index.cfm file under wwwroot with this call inside:

    <cfdump var="#server#" />

http://cf8/index.cfm

http://railo/index.cfm

So our test suite is ready. Following the same step you can easily deploy Open BlueDragon ( you can fin ethe war file here ) as well as more instnaces of cf8 or previous version like cf7 or 6.1 ( be carefull to your jre version for previous cf version support ).

I find this solution really effective to test exactly the same code versus more engine without too many troubles.

And from here ..... clustering deploying more web application in the same server instance....many new possibilities to explore.

I am now seriously starting playing with railo and openbd and I will go on posting about them as on our beloved cf8 as well.

Testing jdk 1.6.0_11

2009-02-03T00:00:00-08:00

I have made a fast speed test to see how much the new jdk has increased my cf8 speed.

The test was very easy and consisting on the looping 1000 times around a createObject statement and run a simple init method on each like following:

<cfloop from="1" to="1000" index="i">
    <cfset createObject('component','testobject').init() />
</cfloop>

Here the results

JDK 1.6.0_7 ( as my previous built on cf8 )

ColdFusion : 2.4 secs average

Railo : 1.1 secs average

JDK 1.6.0_11

ColdFusion : 1.2 secs average

Railo : 0.7 secs average

I was really surprised to discover that my cf8 increased the craeteObject speed of 50% and I have honestly to say that also the railo speed really impressed me

Learning Ext.js

2009-01-31T00:00:00-08:00

I have recently read the first book written about the js library Ext.js.

The book is written bye : Shea Frederick, Steve 'Cutter' Blades and Colin Ramsay.

I was a bit afraid of bying the very first book about Ext and honestly I have to say that after the first 2 chapters my doubts were growing very fast.

Infact the book in the firsts chapters tends to treat really basic arguments with a very scholastic approach. Many writer tend to start their books with quite basic staff but in this case think the first 30/40 pages could have a had a better use.

After that things start to get interesting. The book analize Ext approaching the Form api passing then to Grids, Tree, Layout Drag and Drops etc... Any macro area of the Api is analyzed with some working example and many suggestion and tips.

The examples for any argument are well documented and explained.

I also appreciated the fact that the authors spent a lot of pages giving tips or ideas on how the example could be coded in a different way pushing the reader to explore more the Ext Api.

And here was the big surprise about Ext. Following the book examples I found a lot of Ext features that are are documented only in the api with no higlight in extjs web site or forums.

I so discovered how really work the store class and the easy that is to implement your application ( also without usign ext widgets ) using the Store class as your dataset repository. This makes your app really agnostic about the data format you are receiving. Ext map the data using a reader class and makes your application not coupled to the kind of data format ( array, json, xml ) that your application is receiving.

I was also impressed about the gris and especially working with the inline editing. Ext is able to make your data persist on client marking as dirty the modified elements up to the data commit. Amazing.

So. I was surprised about Ext power and stability.

I have already started to play with the library widgets ( but I am also considering the Ext Data funsctionality with no Ext widget support ) and I really want to recomend the book that can really open your eyes to the Ext powerfull World.

jdk1.6.0_11 speed up coldfusion createObject

2009-01-28T00:00:00-08:00

During 2008 many posts in the cf community proved how a bug in the java 1.6 jdks was slowing down the creation of coldfusion objects.

I personally realized that starting using more frameworks like coldspring, transfer and in general due to the fact that cf8 gives to developers ( finally!! ) the ability to code more tight to a really OO architecture. I started noting that applications with a large use of coldspring became very slow on start up ( also 20/30 seconds ) and in some case I had to give up with Transfer framework cause the performance were degrading to a very low level (I could use some shortcut and implement the framework but I do not like to use a feature at 50% ! I prefer to use a completely new road and implementing that at 100%).

Btw the bug was found in the 1.6 jdks versions and last jdk release solve it. From the first test look like performance relly speed up. The same application that was starting in 20/30 sec is now loading in 5/6 seconds that is a reasonable time due to the high number of object generations.

You can donwload jdk from here and change default jdk in the cf admin ( for standalone instance ) or in jrun admin panel for multiserver installs.

Jquery 1.3 and Sizzle

2009-01-22T00:00:00-08:00

One of the most interesting thing of the new jquery release ( 1.3.1 with bug fixing ) is the new css selctor engine called "Sizzle".

The css engine has been abstracted from the jquery core code so to be usable alsoinstand alone mode. Normally this shoud not be so important news but the fact that sizzle parsing speed looks to be so impressive make it available also to others library like prototype,mootools and others.

Find more about Sizzle Sizzle.

OPS javaScript easy event manager.

2009-01-13T00:00:00-08:00

At this step is just an idea.

How many times did you find to deal with many objects and to start loosing control over the events flow of teh applications.

I use many times different libraries ( I always try to follow the best practice ) implementing his own way to manage events. it works but many times is not a very efficient way of desgin your applications. It's a long time I have in mind to build a centralized event manager framework-agnostic to be used as external support for :

create new custom events
resgister events in a respository
being able to subscribe to these events
dispach teh eevnt from any place in my application

I finally started to build OPS as a simple events manager.

Here a fast example of a very very alpha release, just to post the concept:

/* Craete e new event using the OPS factory.
I also pass a callback that will receive the full event like argument.
*/
var myEvent = new OPS.Factory.Event('myEvent', function(ev){
        alert(ev.getData());
    });

/*
register the event in the OPS.Events repository
*/
OPS.Events.addEvent(myEvent);

/*
my observer is an object that fill up an input filed when something happen
*/
var observer = function(ev){
    document.getElementById('div_Foo').value = ev.getData();
}

/* subscribe the observer to run when myEvent is dispatched */
OPS.Events.subscribe( observer , myEvent );
$(document).ready(function(){

    $('#select_Foo').change(function(){

    /* on select change I add data to myEvent */
        myEvent.setData($(this).val());
        /* dispatch the event from the OPS repository passing the event itself ( with data added ) as argument */
        OPS.Events.dispatchEvent(myEvent);
    });

});

As you see in the example I before create e new event using the internally OPS.Factory.Event class giving a name and optionally a callback.
The event is then added to repository that store it by name.
An observer method is subscribed to the event that is then dispatched passing event object itself as argument with a dynamic data argument that can store anything.
As you see teh event is dispached as answer to a change attached with jquery but could dispatched in any other postion.

I will add a sort of api and more examples/ test quite soon.

New site .. back on Mango