Testing a rounding problem

Floating numbers are characterized by their precision. That's why floating numbers are always inexact though a specification for calculating that kind of numbers should define its precision. It can be one digit up to 15 digits or whatever.
Anyway. The question is, how to test the defined precision? In the following example I expect a precision of 2 digits. For understanding reasons I show the code first followed by the test. The class is simple circle stuff with a method, which returns the calculated area:

class Circle
  attr_accessor :radius
  def initialize radius=1
    @radius = radius
  end
  def area
    radius * radius * Math::PI
  end
end

There are the 2 accessors for the instance variable "radius" and the constructor "Circle#initialize" with a default parameter for a unit circle. And at least there is the algorithm for calculating the area of a circle in "Circle#area", which returns the most possible precise result. The RSpec test is:

# circle_spec.rb
require './circle.rb'
describe Circle do
  describe "#area" do
    it "should calculate the area of a circle" do
      radius = 2
      circle = Circle.new radius
      circle.area.should be_within(0.01).of(12.56)
    end
  end
end

"Matchers#be_within" ensures that the precision should be 2 digits, nevertheless the method returns a more precise number.

Supported by Ruby 1.9.3

Respond to method missing

You have to deal with dynamic method calls and somebody threw an "Implement method_missing" at you?
You google how to do it and maybe find an article like "method_missing, baby!". You code what you gotta code...
But that's only half of the truth. You probably missed to "respond_to?":

class Person
private
  def method_missing method_name, *args
    if %w(runs walks goes drives).include?(method_name.to_s)
      puts "#{self.class} #{method_name}."
    else
      super
    end
  end
end

which means, you broke the POLS (Principle Of Least Surprise):

person = Person.new
person.respond_to? :runs # => false
person.runs # => "Person runs."

Curious! An object, which claims not to respond to a receiver, but instead seem to respond? None would expect such behavior. The solution is to overwrite Person#respond_to? likewise:

class Person
  MOTIONS = %w(runs walks goes drives)
  def respond_to? method_name
    MOTIONS.include? method_name.to_s
  end

private
  def method_missing method_name, *args
    if MOTIONS.include?(method_name.to_s)
      puts "#{self.class} #{method_name}."
    else
      super
    end
  end
 end

and accordingly:

person = Person.new
person.respond_to? :runs # => true
person.runs # => "Person runs."

If it walks like a duck and if it quacks like duck, it is a duck. Ruby duck typing.
Lastly I want to point to another great article about the Principle Of Least Surprise: The Tao Of Programming. Funny.

Supported by Ruby 1.9.3

method_missing, baby!

Meta programming in Ruby is a pleasure. And there are a lot of reasons for. One is method_missing.
A famous example of its "magic" is ActiveRecord and the dynamic finders in Ruby On Rails (active _record/dynamic_matchers.rb).
The approach is simple. Every time an object method was called, which is not defined, (or better a receiver gets an unknown message), Delegator#method_missing cares about it. You can overwrite method_missing in your class. And that's the hook that can be used for dynamics. And it IS used widely.
I demonstrate how to, in a very simple example.
The story is: I want people to move in different ways:

class Person
private
  def method_missing method_name, *args
    if %w(runs walks goes drives).include?(method_name.to_s)
      move method_name
    else
      super
    end
  end

  def move kind
    puts "#{self.class} #{kind}."
  end
end

There is no public method defined in the class "Person". It looks like no person can move in any way. But:

Person.new.runs

returns:

Person runs.

So what happened?
A new person object was instanciated and an message ("runs") was sent to it. Simply because the message is not defined, method_missing is sent instead. Please read the overwritten Person#method_missing carefully. If the message ("runs") is one of "runs", "walks", "goes" or "drives" the private method Person#move is sent internally. That's all. And that's why:

person = Person.new
person.walks
person.drives

returns:

Person walks.
Person drives.

And that's also why:

Person.new.swims

still calls the super method_missing:

undefined method 'swims' for # (NoMethodError)

Method missing, baby!

Supported by Ruby 1.9.3

Boolean method parameter assignment in Ruby

At first: prevent using boolean parameters in method definitions.
But let's assume you have to call a method that expects a boolean parameter like:

class Human
  def go backward=false
    puts "#{self.class} is going " + 
      (backward ? "backward" : "forward")
  end
end

A human can go forward and backward.
We want a human to go backward. If you would code it this way:

human = Human.new
# human goes backward
human.go true

please go on reading, because there is something to improve. At first the output is as expected:

Human is going backward

The code works but you have to agree, that "human.go true" is not readable (that's why there is a line of documentation). But we can improve the readability:

human = Human.new
human.go :backward

also results in:

Human is going backward

In Ruby a Symbol and all objects except instances of Nil and False class are true. Besides using an expressive Symbol can save the line of documentation, because the code documents itself. Awesome! Going forward could be default or explicit:

human = Human.new
human.go # default forward
human.go not(:backward) # explicit

The "not" before the Symbol inverts the assigned parameter. You also could use a bang ("human.go !:backward"). The result:

Human is going forward
Human is going forward

Though I'd prefer having a well designed API method ;-)

Supported by Ruby 1.9.3

Ruby iterators

Ruby iterators are very sweet. But sometimes some of them seem to be ignored. And there is only reason I can imagine: they are not known. Instead, "Enumerable#each" is used as the universal weapon. No it's not. It's worth to read the API of Enumerable before coding an odd iteration. This is about your reputation. Let's start.

Use Case: How to accumulate a collection of items?

Enumerable#inject and its alias Enumerable#reduce iterate over all items and applies a binary operation to a memo (which contains the accumulated temporary value). A simple accumulation:

puts [2,3,4,5].inject { |sum, i| sum += i }

If a block is passed like here, the first parameter is the memo and the second is item itself.
The result is:

14

You also can set an initial value for the memo (sum):

puts [2,3,4,5].inject(1) { |sum, i| sum += i }

and the result is:

15

There is also a shorter way of the same accumulation by passing a symbol instead of the block. Then the items are sent to that method (in this case "+") of memo. Take a look:

puts [2,3,4,5].inject(1, :+)

with the same result:

15

Use Case: How to copy a collection and manipulate its items?

Enumerable#collect and its alias Enumerable#map iterate over all items like Enumerable#inject does, but applies an operation to each item (and that's the important difference). For example I could want to increment every number:

numbers = [2,3,4,5]
puts numbers.collect { |number| number += 1 }.inspect

Therefore it returns a new collection containing the modified items:

[3, 4, 5, 6]

Please note that the original collection "numbers" still contains the original items.

Use Case: How to search a collection for the first proper item?

Enumerable#find finds the first item in a collection for which the block returns true. For example I would want to find the first even number in a collection of numbers:

puts [3,4,2,5,1].find { |number| number.even? }

and found:

4

Please note, that 2 is also even but wasn't picked, because its index in the collection is higher than the index of 2.

Use Case: How to search a collection for every proper item?

Enumerable#find_all and its alias Enumerable#select are kind of similar to Enumerable#find, but they find ALL items in a collection for which the block returns true. That's why both return an array.
The same example collection of names:

puts [3,4,2,5,1].find_all { |number| number.even? }.inspect

finds not only 2, but also 4:

[4, 2]

Use Case: How to search a collection for every improper item?

Enumerable#reject is opposite to Enumerable#find_all. It finds all items for which the block returns FALSE. To me it exists more for readability reasons. But in the context of the same numbers example, which I used before, it would look like:

puts [3,4,2,5,1].reject { |number| number.even? }.inspect

copies the original array without the even numbers:

[3, 5, 1]

Use Case: How to search a collection for the item having the minimum value?

Enumerable#min_by can be confused with Enumerable#find, since it seems to do the same job. But a closer look, highlights that Enumerable#min_by is a more concise iterator for just value comparison. The same "even number" example:

puts [3,4,2,5,1].min_by { |number| number % 2 }

This time I determine the first even number with the modulo-2-algorithm (Numeric#even? also does modulo 2 internally). The first number with result 0 (minimum number) is picked for return:

4

You definitely would go for Enumerable#find to find the first even number, but I'd like to mention another example to illustrate the concision of Enumerable#min_by:

puts %w(Bob Al Susan).min_by { |name| name.length }

finds the shortest name:

"Al"

Use Case: How to search a collection for the item having the maximum value?

Enumerable#max_by is the sibling of Enumerable#min_by. It finds the first item having the maximum value:

puts %w(Bob Al Susan).max_by { |name| name.length }

finds the longest name:

"Susan"

Use Case: How to search a collection for the items having the minimum or maximum value?

Enumerable#minmax_by is the third sibling in family. It returns an array with 2 elements. One for the item having the minimum value and one for item having the maximum value:

puts %w(Bob Al Susan).minmax_by { |name| name.length }

finds the shortest and the longest name:

["Al", "Susan"]

Use Case: How to select all items of a collection as long as they are proper?

Enumerable#take_while iterates over a copied collection and keeps every item, for which the block returns true. If the first item is not proper due to the return value of the block, the iteration stops and returns the result array.
The names example:

puts %w(Bob Al Alexander Susan).take_while { |name| name.length < 8 }.inspect

stops during the third iteration ("Alexander" consists of 9 letters) and returns:

["Bob", "Al"]

Please note, that the fourth item ("Susan") wasn't selected, though it would satisfy the condition. And that is the difference to Enumerable#find_all.

Use Case: How to remove all items in a collection as long as they are proper?

Enumerable#drop_while iterates over a copied collection and removes every item from the new array, for which the block returns true. If the first item is not proper due to the return value of the block, the iteration stops and returns the result array.
The names example:

puts %w(Bob Al Alexander Susan).drop_while { |name| name.length < 8 }.inspect

stops during the third iteration ("Alexander" consists of 9 letters) and returns:

["Alexander", "Susan"]

Supported by Ruby 1.9.3

Lambda is not a Proc

I guess you already know about Procs. The lambda in Ruby is also a closure. Therefore, it encapsulates logic which can be executed at the time it is encountered. It even an be put into a particular context by passing it to a function. So far nothing new.
That's why I start with explaining the lambda and later compare with the Proc.
A simple lambda:

my_lambda = lambda { puts "A lambda" }
my_lambda.call

returns:

A lambda

Sure, you can pass a parameter:

my_lambda = lambda { |param| puts "Parameter: #{param}" }
my_lambda.call(1)

returns:

Parameter: 1

And yeah you can also pass more than one parameter like:

my_lambda = lambda { |p1, p2| puts "Parameters: #{p1}, #{p2}" }
my_lambda.call(1, 2)

returns:

Parameters: 1, 2

You also can pass the lambda to a method for some reasons:

def my_function(block)
  puts "before lambda"
  block.call
  puts "after lambda"
end
my_lambda = lambda { puts "inside lambda" }
my_function my_lambda

returns:

before lambda
inside lambda
after lambda

Though there are not many reasons for passing logic to an object method without using data of that object. You would more often want to "send logic" to an object for dynamically using its data. Then you pass a parameter like:

def my_function(block)
  number = 0
  block.call(number)
end
my_lambda = lambda { |p| puts "inside lambda: #{p += 1}" }
my_function my_lambda

returns:

inside lambda: 1

At this point I note an essential property of closures. They automatically carry with them the bindings from the code location where they were created.

 
word = "Foo"
def redefine_word(block)
  word = "Bar"
  puts word
  block.call
end
redefine_word(lambda { puts word })

You really have to take care of the scope, when you send a block to a function. Consider the output:

Bar
Foo

The difference between lambda and Proc

There is another exciting detail I want to put the finger on. Control keywords like return, raise, break, redo, retry do NOT have any impact on the further execution. And that's an important difference to Procs. A lambda example:

 
def my_method
  puts "before lambda"
  my_lambda = lambda do
    puts "inside lambda"
    return
  end
  my_lambda.call
  puts "after lambda"
end
my_method

returns:

before lambda
inside lambda
after lambda

And now the same snippet with a Proc:

 
def my_method
  puts "before Proc"
  my_proc = Proc.new do
    puts "inside Proc"
    return
  end
  my_proc.call
  puts "after Proc"
end
my_method

returns:

before Proc
inside Proc

Boom! The "return" inside the Proc prevents executing all following logic (line 8 of "my_method"). Good to know, isn't it? Another important difference concerns the parameters of the block. Lambdas are strict:

my_lambda = lambda { |p1, p2| puts "Parameters: #{p1}, #{p2}" }
my_lambda.call("One")

ends up in an exception:

wrong number of arguments (1 for 2) (ArgumentError)

But a Proc is liberal:

my_proc = proc { |p1, p2| puts "Parameters: #{p1} and #{p2}" }
my_proc.call("One")

returns:

Parameters: One and

Keep the differences in mind, when you choose a Proc or a lambda for closuring.

Supported by Ruby 1.9.3

The quick Proc

In the previous post Yield your block in Ruby I described how to code a block and its short cut "yield". You may have noticed that another kind of closure, the Proc. The goal behind is the same as the already explained block. But you will get into the situation to save a block for later dynamic use. I used a Proc the first time in my very first Ruby On Rails project.
That's why I also explain the Proc in a Rails example now.
Let's assume a model Machine:

class Machine
  attr_accessor :in_progress
  attr_accessible :name
  validates :name, :presence => true, :unless => Proc.new { |machine| machine.in_progress.blank? } 
end

having the accessor methods generated through "attr_accessor". Furthermore there is the model attribute "name" for the machine name. I want the machine validate its name for presence only in the case of the machine was already started.
That's why there is the third call "validates". And it is only called, when the :unless key contains a false. Since the validation call is dynamic, there is a Proc assigned. It executes its code not before the validation call and can return true or false depending on the value of the instance variable @in_progress.
I agree, the logic of the Proc also could be put into an instance method, say "in_progress?" (as it would be generated by Rails, if it was a model attribute).
But why should I? I only need the logic once and this way it is more readable, because it is located next to the key.
So when do I use a Proc?
I do, when some logic should be called dynamically and not be put into a method for some reasons.

Supported by Ruby 1.9.3, RubyOnRails 3.1

Yield your block in Ruby

In Ruby there are some topics which are not often discussed and even some developer not really know about. One of them are closures.
The Ruby closures are called blocks, Procs and lambdas. They enclose logic, which can be invoked outside of its immediate scope.
Every Ruby developer already used a block when running the well known Array#collect! or Hash#select!. An easy to understand (and 100% true) example:

languages = ["Ruby", "Python", "Javascript"]
languages.collect! do |language|
  "#{language} is awesome!"
end

The introduction so far. But how does the Proc behind (e.g. Array#collect!) work, how to do something similar and when to use it?
To illustrate the functionality of such closure I start with the Proc itself:

class Array
  def power!(&block)
    self.each_with_index do |number, index|
      self[index] = number * number
      block.call(self[index])
    end
  end
end

I re-opened the Array class and added the power! method. I sticked to Ruby conventions and put a bang at the end (if you don't know why, read about the bang convention). The method itself expects a block (or rather enclosed logic) to be passed. That is why there is an ampersand before the block parameter. Inside it only iterates over its items, squares each and calls the block on the result. Quick & simple.
The Proc is called:

numbers = [1, 2, 3, 4]
numbers.power! do |number|
  puts number
end

and prints:

1
4
9
16
 => [1, 4, 9, 16]

Well. Simple but pretty static. The call of "puts" is injected into the scope of the method "power!" by putting it into the block. Let's enhance the same example and rename the method:

class Array
  def iterate!(&block)
    self.each_with_index do |number, index|
      self[index] = block.call(number)
    end
  end
end

The method "iterate!" is pretty comparable to the stuff Array#collect! does. It iterates over each item and stores the result of the called block. In a conclusion "iterate!" offers much more dynamics. We also could square:

numbers = [1, 2, 3, 4]
numbers.iterate! do |number|
  number * number
end

There is a keyword known for calling the block. Its name is "yield". Using it you don't pass a "&block" to the method. The Array#iterate! would look like:

class Array
  def iterate!
    self.each_with_index do |number, index|
      self[index] = yield(number)
    end
  end
end

Finally I want to point out that you also can pass as much as parameters as you need to your closure. An example with two parameters would be:

class Array
  def iterate_with_index!(&block)
    self.each_with_index do |number, index|
      self[index] = block.call(number, index)
    end
  end
end

and calling it:

numbers = [1, 2, 3, 4]
numbers.iterate_with_index! do |number, index|
  puts index
end

returns:

0
1
2
3
 => [nil, nil, nil, nil]

I use blocks to keep my code DRY and to achieve more readability. And there will be a point you can't ignore them.

Supported by Ruby 1.9.3

Ruby On Rails calling SAP

Some years ago I had to tap several RFC of SAP. Believe me, communicating with SAP is no fun (in fact SAP is the acronym for Shitty Awful Pain or more seriously Slow Account Program), but without the RFC connector of Piers Harding it would have been impossible. Since SAP is a so called monopolist in the ERP layer, you might have to deal with it and know how to do.
First step is to download the current sapnwrfc of Piers:

user$ curl -o sapnwrfc-0.26.tar.gz http://www.piersharding.com/download/ruby/sapnwrfc/sapnwrfc-0.26.tar.gz

untar it:

user$ tar -xzf sapnwrfc-0.26.tar.gz

build a gem:

user$ gem build sapnwrfc.linux.gemspec

and install the generated gem. The name depends on the version and architecture of your machine. For example:

user$ gem install sapnwrfc-0.26-x86_64-darwin-11.gem

Check, if it is working in your irb:

require 'sapnwrfc' 

Preparations finished.
The basic requisite is an existing RFC module you want to interact with and to know the specific connection parameters. Put them into a configuration file (config/sap.yml):

ashost: your.sap_host.com
sysnr: "00"
client: "510"
user: your_user
passwd: your_pass
lang: EN
trace: 1

Furthermore you have to know the SAP RFC you want to call. In my case it is the fictive RFC "zEquipments". I create a model (models/equipment.rb) as the calling Ruby endpoint:

require 'sapnwrfc'
SAPNW::Base.config_location = "#{Rails.root}/config/sap.yml"
SAPNW::Base.load_config

class Equipment
private
  def self.connect(&block)
    rfc_connection = SAPNW::Base.rfc_connect
    discovered_connection = rfc_connection.discover("CRHD")
    rfc = discovered_connection.new_function_call
    block.call rfc
    rfc_connection.close
  end

public
  def self.find_all_by_site site
    equipments = []
    self.connect do |rfc|
      rfc.EQUIPMENT_PARAMS {
        "WERKS" => site.to_s
      }
      rfc.invoke
      rfc.RETURN.each do |equipment|
        equipments << equipment["ARBPL"].strip
      end
    end
    equipments.uniq!
  end

  def self.find_by_objid objid    
    name = nil
    self.connect do |rfc|
      rfc.EQUIPMENT_PARAMS {
        "ARBPL" => objid.to_s
      }
      rfc.invoke
      name = rfc.RETURN.first["ARBPL"].to_s.strip
    end
    name
  end
end

The first line is self-explanatory. The two following lines load the SAP configuration initially. I first coded a separate private class method for connecting to the SAP system, because I use the logic for connecting twice. The first public class finder method "find_all_by_site" expects the name of the site where the equipments are located in. It connects to the RFC and passes the site parameter. The result collects the names of the found equipments and removes all duplicates (you never know with SAP).
Please note the implemented block for connection. I'll cover the use of closures in the post "Yield Your Block in Ruby".
The second public class finder method searches for a certain equipment having a specific OBJID (the unique identifier for every equipment in SAP) and returns its name.
Conclusion: 2 finder methods calling the same SAP RFC with different parameters returning a collection of equipment names or a certain equipment name.

Supported by Ruby 1.9.3, RubyOnRails 3.1 and SapNwRfc 0.26

Save time per Rails controller query

Ruby On Rails is sooo elaborated. It ships with a lot of optimizations included, like query caching, page caching and so forth. But this is about optimizing a continuous polled controller. Let's assume getting the current state of some machines. Therefore I use a simple cyclic remote link as I described in an earlier post or in CoffeeScript. It queries the controller once per 10 seconds.
The database migrations:

class CreateMachines < ActiveRecord::Migration
  def change
    create_table :machines do |t|
      t.string :name
      t.integer :state_id
      t.timestamps
    end
  end
end
class CreateStates < ActiveRecord::Migration
  def change
    create_table :states do |t|
      t.string :name
    end
  end
end

The models/machine.rb:

class Machine < ActiveRecord::Base
  belongs_to :state
  validates_presence_of :state_id
end

And the models/state.rb:

class State < ActiveRecord::Base
  has_many :machines
end

The controllers/machines_controller.rb:

class MachinesController < ApplicationController
  def index
    respond_to do |format|
      format.html {
        @machines = Machine.includes(:state).order("machines.name ASC")
      }
      format.js {
        @machines = Machine.where("machines.updated_at >= :updated_at",
            { :updated_at => session[:last_status_request] }).includes(:state)
      }
    end
    session[:last_status_request] = Time.now
  end
end

If a simple GET request was received by the MachinesController, it returns all machines including their state and sets the request timestamp in the session initially. They are displayed in the views/machines/index.html.erb:

<ul>
  <% machines.each do |machine| %>
    <li>
      <%= machine.name %>: <span id="<%= dom_id(machine) %>_state"><%= machine.state.name %></span>
    </li>
  <% end %>
</ul>
<%= link_to 'Refresh', machines_path, :remote => true, :class => 'auto_remote' %>

The XMLHTTPRequest triggered by the remote link reaches the format.js part of the MachinesController. Please notice that only those machines are queried, who have been updated since the last status request timestamp. So a lot less machines and their state are queried, instantiated and sent back to the client.
The result is processed in the index.js.erb:

<% @machines.each do |machine| %>
  state = $('#<%= dom_id(machine) %>_state');
  state.text("<%= machine.state.name %>");
<% end %>

This post was more about the conception how to save processing time than an optimized-to-the-bones tutorial. For example you better should render a 304 Not Modified, if no state was updated since the last polling request.
Supported by Ruby on Rails 3.2.8

The AOP in Ruby

Needless to say Ruby stands for readable codes, prototyping mixins and other paradigms. In this post I present the paradigma of aspect oriented programming in Ruby (short AOP). What is it good for?
Say you included a cool gem, but it contains one feature, you have to enhance to fulfill your requirement. You have got two options:

1. copy the code of the feature and overwrite the method with the enriched logic
2. AOP

The drawback with the first option is the copy & overwrite part. Overwriting means your application will never benefit from bugfixes and enhancements of the original code.
That's why you better go with the aspect oriented paradigma, recycling the original code and injecting new logic.
Fortunately Ruby as a great metaprogramming language offers an easy exposure to AOP. Easy as follows.

module ActsAsExample
  def feature
    @feature ||= "The original"
    @feature + " feature is oh-some."
  end
end

The ActsAsExample module contains the feature method. Including it into the Example class:

class Example
  include ActsAsExample
end

Using the included feature:

Example.new.feature

returns The original feature is oh-some., as expected. Let's add a new aspect to the Example class:

class Example
  include ActsAsExample
  alias_method :original_feature, :feature

  def feature
    @feature = "My new cool fancy"
    original_feature
  end
end

The use of the same feature method:

Example.new.feature

now returns My new cool fancy feature is oh-some.. The feature method behaves different compared to the original code though the original code was used.
A bugfix of the ActsAsExample module to:

module ActsAsExample
  def feature
    @feature ||= "The original"
    " feature is awesome."
  end
end

will break through to the Example class and again calling the feature:

Example.new.feature

returns the bugfixed My new cool fancy feature is awesome. and please note that no change was made in the copy method of the Example class.
Clean!
Maybe my example is not the best, but I hope it illustrates how easy AOP in Ruby is.
Additionally I point to the Ruby Aquarium framework.
Supported by Ruby 1.9.3

VI: best Ruby IDE since 1976

First I have to admit that you caught me in a lie.
The very best editor for developing software is not the VI but its conduction, the great VIM (Vi IMproved). It's not "cool" like TextMate and Apple hipsters might give a sniff at VIM, but it's available on every professional OS (Windows is none!)
From time to time you also have to debug some logic on a remote server, possibly even on a production server. Then your best choice is tunneling via SSH and debugging in your terminal by using VIM.
The mentioned method of operation is not only for Rubyists. It's the way to go for everyone working on remote machines. Even those Java island guys have to turn their back on NetBeans/ IntelliJ/ Eclipse in some situations.
Other good points are VIM's portable configuration, the high level of customizability and extensibility and not to forget its powerful and skilled community.
Well, none says VIM is intuitive. There is a learning curve when you first start using it, and it does require a bit of a commitment. But you will be rewarded for the rest of your coding life time.
If VIM is not already installed on your Debian based system (like Ubuntu), just do:

user$ sudo apt-get install vim vim-common

or in Fedora:

user$ sudo yum install vim-common vim-enhanced vim-minimal

As a next step maybe you will want to edit your vimrc:

user$ vi ~/.vimrc

There you can configure a lot and it will be part of your VIM life style. It could look like this:

set nocompatible " make VIM useable by switching off the compatibility to grandpa VI
 
set diffexpr=MyDiff() " overwrite the default diff function of VIM
function MyDiff()
  let opt = ''
  if &diffopt =~ 'icase' | let opt = opt . '-i ' | endif
  if &diffopt =~ 'iwhite' | let opt = opt . '-b ' | endif
  silent execute '!C:\Vim\vim61\diff -a ' . opt . v:fname_in . ' ' . v:fname_new . ' > ' . v:fname_out
endfunction
 
set history=500 " keep 500 lines of command line history
set tabstop=4 " set the tab Stops to 4 white spaces
set shiftwidth=4 " set the indention to 4 white spaces. along with tabstop=4 it implies an indention with 1 tab
set noexpandtab " do not replace Tabs with white space while editing
 
set nobackup " do not write Backup Files while saving

set showmatch " jump to the opening bracket briefly, if a closing bracket is typed

set cindent " cindent is a quite intelligent indention

set fo=croq " continues the comments in the next line

set foldmethod=marker " tagged lines with {{{ and }}} can be hidden with zc or opened with zo
set mousehide " hides mouse pointer while typing

set background=dark " set the background dark

syntax on " enable syntax highlightening
filetype on
filetype indent on
filetype plugin on

Of course there are a lot more options. Surf the web for it.
I won't go into details how to use the VIM. It is well documented in VIM. Just type :help. Moreover there are many tutorials out there. I suggest the official VIMdoc and the great screencast at peep code.com. For getting further tips visit the VIM Runpaint

Ruby conventions: methods with ? and !

Today I cover the Ruby convention of using a question mark or exclamation mark in method names.
Following the convention eases the readability of Ruby codes.
The question mark is for methods returning boolean values, like:

class Language
  attr_accessor :name

  def initialize(name)
    @name = name
  end
  
  def downcased?
    name == name.downcase
  end
end

and:

language = Language.new "ruby"
language.downcased?

returns:

=> true

Next. The exclamation mark in Ruby methods. In general, methods with trailing "!" indicate that the method will modify the object it's called on. The ones without are called "safe methods", and they return a copy of the orignal with changes applied to the copy, with the callee unchanged. For example:

original = "RUBY"
copy = original.downcase

The variable:

copy

contains:

=> "ruby"

while:

original

is still:

=> "RUBY"

and please compare with trailing "!":

original = "RUBY"
copy = original.downcase!

The variable

copy

contains:

=> "ruby"

So a trailing "!" in a method name should mark that the object itself will be modified, when called. Syntactic sugar!
Supported by Ruby 1.9.3

Soft delete for ActiveRecord

Master data often require to be kept even if they are deleted by the user. One reason could be the requirement to be able to reactivate the record (RoR's ActiveRecord::Base). Another one could be to keep the references. No matter what the demand is. It's simple to solve.
I coded a module to reuse the logic and named it RecordActivation:

module RecordActivation
  extend ActiveSupport::Concern
  self.included do
    scope :active, where(:active => true)
    validates_presence_of :active
    before_validation :activate, 
      :on => :create, 
      :if => Proc.new { |r| r.active.nil? }
  end

  def activate
    self.active = true
  end
 
  def activate!
    activate
    save!
  end
  
  def deactivate
    self.active = false
  end
 
  def deactivate!
    deactivate
    save!
  end
end

As an example I created a Task migration:

class CreateTasks < ActiveRecord::Migration
  def change
    create_table :tasks do |t|
      t.string :name
      t.boolean :active
      t.timestamps
    end
  end
end

... and included the module into the model:

class Task < ActiveRecord::Base
  include RecordActivation
end

Let's go into detail in terms of the module.
Please notice that I extended my module with ActiveSupport::Concern. It resolves module dependencies and should be preferred when it comes to module handling. The second I want to point to, is the snippet which is run, when the module is included:

    scope :active, where(:active => true)
    validates_presence_of :active
    before_validation :activate, 
      :on => :create, 
      :if => Proc.new { |r| r.active.nil? }

It spends a scope to the Task model. So finding all active tasks means:

Task.active.all

If you want to ensure, that the activation flag is qualified, add the validation by validates_presence_of. Also make sure that the flag is set initially before creation by calling the method "activate" (but only if the value is not set already/ still NULL). By default all new created records are active.

Task.new.save!

... will create a new active task.
Four instance methods allow to set or reset the boolean flag. Those with an exclamation mark at the end of their name force the saving immediately (following the convention). For example:

Task.active.order("created_at").first.deactivate!

will deactivate the oldest task at the database.
That's all.
Supported by Ruby on Rails 3.2.8

Rubies on RVM

Sometimes you are forced to switch your time-tested Ruby application to a newer Ruby version. You don't need to be scared. There is RVM, the Ruby Version Manager. It let you use different Rubies conveniently by just a simple command. You even can install several gemsets per Ruby version! It's easy to install:

user$ \curl https://raw.github.com/wayneeseguin/rvm/master/binscripts/rvm-installer | bash -s stable

Please notice the backslash before curl. This prevents misbehaving if you have aliased it with configuration in your ~/.curlrc file. Make sure your current terminal session has loaded RVM:

user$ source ~/.rvm/scripts/rvm

When you open a new shell, RVM is loaded automatically. Test if your installation was successful:

user$ type rvm | head -n 1
rvm is a function

Your terminal should output: rvm is a function Finally, see if there are any dependency requirements for your operating system by running:

user$ rvm requirements

Installation done. Let's play around with certain Rubies. First install one, e.g. Ruby 1.9.2:

user$ rvm install 1.9.2

Use the crisp Ruby installation:

user$ rvm use 1.9.2

Check the version of your current Ruby:

user$ ruby -v

If you want to know which Ruby versions you already got on your RVM, list them:

user$ rvm list known

Set your favourite Ruby as default:

user$ rvm use 1.9.2 --default

One huge benefit of RVM is the possibility to install several named gemsets independent from your installed Ruby.
Create a gemset for Rails 3.2.9 (on your default Ruby 1.9.2):

user$ rvm gemset create rails_329

Use it:

user$ rvm use 1.9.2-head@rails_329

Install you first gem (Rails 3.2.9) on you gemset:

user$ gem install rails -v 3.2.9

List the gemsets on your current choosen Ruby:

user$ rvm gemset list

There are a lot more options for RVM (e.g. user installation or benchmarking your code against several versions of Ruby and many more). I just referred to only a few/ some of the most important.
For going into detail please visit the RVM page. There you also will find an answer, if you discovered an issue depending on your used OS. Anyway you should take a look.

From JavaScript to CoffeeScript

CoffeeScript makes you write clean and more readable JavaScript code. Syntactic sugar! Typically you'll code 30% less lines. Good to know the code compiles one-to-one into the equivalent JavaScript, and there is no interpretation at runtime. As a first example I convert the snippet of the cyclic remote link using jQuery into CoffeeScript. You can compare the simple logic in JavaScript and CoffeeScript yourself. First the code in JavaScript once again:

$(document).ready(function(){
    jQuery.each($('a.auto_remote'), function(){
     setInterval(function(remote_link) {
        $.ajax({ url: $(remote_link).attr('href') });
      }, 10000, this);
    });
});

In CoffeeScript it is tidy like this:

$(document).ready ->
  jQuery.each $("a.auto_remote"), ->
    setInterval ((remote_link) ->
      $.ajax url: $(remote_link).attr("href")
    ), 10000, this

The first that attracts attention is the syntactic sugar like Ruby, Python or Haskell also offer. No semicolons, less brackets, just more readable. Furthermore you noticed the alias "->" for functions. Practical:

$(document).ready(function(){
    // some codes
});

In CoffeeScript:

$(document).ready -> // some codes

... sweet.
Read the CoffeeScript Tutorial and check how your JavaScript looks like converted into CoffeeScript.
Supported by CoffeeScript 1.4.0

Github is a cool cat

I assume you are comitted to the coolness of GIT. Installing GIT on a Debian based Linux is easy:

$ sudo apt-get -y install git-core

There are 2 options to host the code: On your own system or on Github.
I recommend the second choice. The infrastructure is already existing and Github furthermore includes simple ticketing to assist your development process. In the end it is free (Github is THE spot for social coding).
Github is a real cool cat.
So go on by setting the default name for GIT to use when you commit:

$ git config --global user.name "Your Name Here"

Set the default email for GIT to use when you commit:

$ git config --global user.email "your_email@youremail.com"

... your email address for Git should be the same one associated with your GitHub account. The last option we need to set will tell git that you don't want to type your username and password every time you talk to a remote server. To use this option, you need to turn on the credential helper so that git will save your password in memory for some time:

$ git config --global credential.helper cache

By default git will cache your password for 15 minutes. You can change this if you like. You can set the cache to timeout after 1 hour (setting is in seconds):

$ git config --global credential.helper 'cache --timeout=3600'

That's all. Now call on Github and launch your repository.

If you need further information go to: https://help.github.com/articles/set-up-git
or sign up your Github account directly: https://github.com/signup/free

Simple cyclic remote link using jQuery

Create a link in the view template you want to trigger a cyclic request:

<%= link_to 'Refresh', root_path, :remote => true, 
  :class => 'auto_remote' %>

I chose the root url as destination, but it should be the route you want to call. Then add a javascript snippet in your application.js (or the js file you use in the view):

$(document).ready(function(){
    jQuery.each($('a.auto_remote'), function(){
     setInterval(function(remote_link) {
        $.ajax({ url: $(remote_link).attr('href') });
      }, 10000, this);
    });
});

In my example the request is triggered every 10th second. Supported by Ruby on Rails 3.2.8 and JQuery 1.8.3