Ruby on ZiGzAg

Grep in Ruby - A powerful Enumerable method

2010-03-31T00:00:00-07:00

Grep in Ruby – A powerful Enumerable method

31 Mar 2010 – ZhuHai

If you were a Unix shell fan, I bed that the “grep” command would be in your top-used list. But as for the Ruby programming, are you still prefer “grep” to the other methods come with the “Enumerable” module?
Do you know in most of the situation, using “grep” is more handy and powerful than the commonly used “map” or “select” methods? I will try to unveil the power of “grep” method in this post.

First of all, let’s review what “grep” do for an Enumerable object:
(Quoted from the Rdoc document of Ruby)

    enum.grep(pattern)                   => array 
    enum.grep(pattern) {| obj | block }  => array 
    Returns an array of every element in enum for which Pattern === element.
    If the optional block is supplied, each matching element is passed to it,
    and the block's result is stored in the output array.

Simple enough,right? Here I will show you some convenient use cases:

Simpler select – Filtering by pattern matching rather than giving a block to “select”.

Most of the time, we use the “select” method for filtering the elements in an Enumerable object by giving a block as criterion. Such as using ['a','1','b'].select{|x| /^\d*$/ === x} to filter out the numeric string. But by applying “grep” method with a Regexp pattern instead of a block, we get a shorter version: ['a','1','b'].grep(/^\d*$/). This shortcut not only works for the RegExp pattern matching, But also works for all objects that overwrote the “===” method. Such as “Range” and “Class”. Therefore we can easily filter out elements like:

[1,10,100,1000].grep(1..100) # => [1, 10, 100]
[1,'a',2,'b'].grep(Integer) # => [1,2]

It is very easy to customize your filtering as well, just have you categorization logic defined as case equal(“===”) in your own class, then the instances of that class can be easily filtered out from an Enumerable object using the “grep” method.

Easier transforming using grep with Regexp and $n

It is not uncommon that we need to select some elements from a String collection according to some pattern and want to strip out part of the origin. Like the below example:
Given a String Array like ['hello.rb','world.rb','public.html'], and what we expected is the Ruby files without the extension name like: ['hello','world'].
Without thinking it too much, we can achieve this goal by combining the “select” and “map” methods just like #1 line below. But after we get familiar with the “grep” method and convention of the Regexp, we can have a more compact and elegant expression like #2 line:

['hello.rb','world.rb','public.html'].select{|x|x=~/\.rb/}.map{|x|x[0..-4]}
['hello.rb','world.rb','public.html'].grep(/(.*)\.rb/){$1}

Selective bulk transforming – combination of “select” and “map”

Among the Ruby methods of Enumerable, normally we use “select” for filtering and use “map” for bulk transforming. But as the examples showed before, the “grep” method can act as a combination of those two methods. Here it is called “selective bulk transforming”. A simple example is to pickup the numeric string and transfer them into Integer instances. See the following two versions for comparison:

['a','1','b','2'].select{|x| /^\d*$/ === x}.map{|x| x.to_i}
['a','1','b','2'].grep(/^\d*$/){|x| x.to_i}

Or, even we make them shorter by the &symbol block, the version using “grep” looks more lovely:

['a','1','b','2'].select{|x| /^\d*$/ === x}.map(&:to_i)
['a','1','b','2'].grep(/^\d*$/,&:to_i)

Conclusion

Although the definition and implementation of the “grep” method from Enumerable module is simple, but by combing with other Ruby expression like case equal(“===”), Regexp, and “&symbol” block, It become a very handy and powerful method. Therefore next time when you come across some situation need to use “select + map”, keep “grep” in your mind beforehand.

From TextMate to VIM for Rails Coders

2010-02-14T00:00:00-08:00

From TextMate to VIM for Rails Coders

18 Feb 2010 – GuangXi, China

In this post I will show you my experience of switching editor from TextMate to VIM for Rails developing. I will do a comparison with them in major aspects of coding efficiency. Hope it will help you choose the best editor fit for yourself. Your comments of either TextMate or VIM are all welcomed here.

When started coding in Rails, I chose TextMate as my editor because it seems amazing as showed in the fantastic RailsCasts from Ryan Bate.

Indeed the journey ramping up the learning curve of Rails with TextMate was very delightful. I continued using it in several projects and became familiar with it until one day I had to give off my deer Mac Book and fall back to a Windows laptop. During the period waiting for my next Mac, I need to write Rails code without TextMate.

Developing Rails on Windows is a miserable experience for me. Therefore I rather chose to SSH my remote Linux box with PUTTY instead of using any windows GUI IDE. I used to write script in VI on Linux but for daily rails coding, VIM with some plugins would be better.

After I switched from TextMate, I found myself even more efficient and comfortable working with VIM at some points and still miss some stuff in TextMate. Here are the major differences I could count:

The mouse is not needed anymore.

If you are a keyboard shortcut lover, I bet you don’t like shifting your hand between the keyboard and mouse while coding. Believe it or not, relocating the finger position, finding your mouse on desk and pointer on screen may be not a time-killer but it would distracts your attention all the time. While in TextMate, the shortcut system is powerful but still not powerful enough to support your work without the help from your Mickey.

But in VIM. After get used to the navigation keys, you will found it very efficient and do not need the mouse anymore. Here are some examples:

Locate your cursor: Using keys like hjklwb$^ to move your cursor. Pain at the beginning but works pretty good after you get familiar with them.
Go there quicker: Jumping to the line using ***G or Jumping to the word using /XXX.
Find the previous/next occurrence of current word: Just type # or *. Simpler than CMD+E plus CMD+G in TextMate.
Even the Columnar editing works pretty good with Block-wise visual mode activated by CTRL+v. Good enough comparing the ALT+Drag in TextMate.

Project Drawer: Miss it sometimes but not much.

When you just involved in a project, the tree opened in the project drawer could do you a favor for showing the structure clearly. But after you dig into the project deeper, you will find the Project Tree became more and more useless. Usually I close the drawer and using CMD+T to open files quickly. In VIM, I installed a tree plugin called NERDtree, but frankly I don’t use it very often. With the Rails plugin. I used the file navigation commands below(Press tab when typing those command save a lot of time):

:Rmodel,:Rcontroller,:Rview,:Rmigration for jumping to the file when the name came into my head.
:A,:R for jumping to the ‘Alternative’ or ‘Relative’ file of current file. Just like ALT+CMD+DOWN in TextMate.
Want to open the file named under the cursor, just type gf.

File tabs: Would not miss it after get used to Window-splitting.

As for the file tabs. I used it heavily in TextMate and get used to switching tabs using CMD+number. The version of VIM that I am using(7.2) also contain the support for tab browsing. But It still not work as good as TextMate does. But start to getting more and more familiar with the windows splitting function in VIM, I do not miss the tab browsing so much. Since the major switching is the Model/UnitTest or Controller/View, and that will be perfectly done by windows splitting.

Project searching: Still finding a better way.

While I writing rails code,especially when debugging In TextMate,I used the Project searching CMD+SHIFT+F quite often. But in VIM, I have to fall back to the shell command like find . -type f|grep rb$|xargs grep xxx. Do you have any suggestion for it?

Snippets: The Killer feature that I miss the most.

I thought the Snippets come with different bundles as the killer feature of TextMate. Although there is a similar plugin called SinpMate available for VIM, But when it comes to the shortcut name that you are not familiar with, TextMate provides you a quick way CTRL+CMD+T for hint. I REALLY expect that this could come into the VIM plugin.

Conclusion

There are still a lot of detail differences between these two excellent editors that I did not list here. But the overall experience for me of switching from TextMate to VIM is exciting. Especially imagine that in the near future, I can bring out my iPad + Wireless Keyboard and go on hacking code quickly with TouchTerm(A SSH client App for iPhone) + VIM… Doesn’t it cool enough? Any comments are welcomed here or tweet me @zigzagchen.

Resource

rails.vim — Ruby on Rails: easy file navigation, enhanced syntax highlighting, and more#
The NERDtree — A tree explorer plugin for navigating the filesystem.
snipMate — TextMate-style snippets for Vim.
Zigzag’s .vim setting — My VIM setting repository on GitHub.
From TextMate to Vim — Annother post in the same topic.
Vim for TextMate Fans — Same topic with a screenshoot

Customizing your scaffold template become easier in Rails3

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

Customizing your scaffold template become easier in Rails3

18 Jan 2010 – Beijing

In the weekend of BugMash for Rails3. I planned to make a experiment of a showcase using Rails3 and the new released jQuery 1.4. Rails3 in this experiment would act as a back-end service provider using JSON and the UI stuff would be all handled by jQuery. Therefore making a scaffold generating will save my time for just exposing my simple models in the JSON format.

After the generating, the controller code is look like:

def index
  @tasks = Task.all
  respond_to do |format|
    format.html # index.html.erb
    format.xml  { render :xml => @tasks }
  end
end

Actually this is not near from what I need. RESTful methods that handling JSON are enough and html/xml is not needed.

In rails 2.x there are no support in the core framework to change the scaffold template easily.

I anticipated the scaffold generator would become smarter in Rails 3 just like using some options like —type=JSON then the generated result will be changed.
But the magic did not happen. I called for help in IRC #railsbridge and josevalim told me a easy way to customize my own generating template:
Just make a copy of the template at
rails/railties/lib/generators/rails/scaffold_controller/templates (or it’s github link) to
RAILS_ROOT/lib/templates/rails/scaffold_controller/controller.rb
The code in template is look like

# GET /<%= table_name %>
# GET /<%= table_name %>.xml
def index
  @<%= table_name %> = <%= orm_class.all(class_name) %>
  respond_to do |format|
    format.html # index.html.erb
    format.xml  { render :xml => @<%= table_name %> }
  end
end

I modified it to my own version:

# GET /<%= table_name %>
def index
  @<%= table_name %> = <%= orm_class.all(class_name) %>
  render :json => @<%= table_name %>
end

Then run generating again. Then it comes the controller that I need:

# GET /tasks
def index
  @tasks = Task.all
  render :json => @tasks
end

Easy enough, right?

Ready_for_i18n 0.3 released -- support for non-english projects.

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

Ready_for_i18n 0.3 released — support for non-english projects.

31 Dec 2009 – Beijing

In the initial version of ready_for_i18n(Introduced here), We had an assumption that the locale of your project to be extracted is English, therefore the key in the dictionary file can be just come from the literal word. But there are also so many non-english local projects that need to be internationalized. So we come out an idea to introduce a simple key-text mapping mechanism. Still simply using one command of ready_for_i18n and follow these steps to get you non-english project ready for i18n.

(Assuming you are in the app/views directory of your rails project.)

Using ready_for_i18n . --nokey > cn.txt to extract all text and label in your views.
Open the cn.txt and go for google translate (or other tools you like or do it manually) then paste the result in a new file called en.txt with the following cautions — (Do NOT change anything in cn.txt but you can change the translated en.txt just remember keeping the same line number of en.txt with cn.txt).
Using ready_for_i18n . . --keymap=cn.txt:en.txt > cn.yml Then all your views will be replaced to an i18ned version and the generated cn.yml dictionary file will use the keys from en.txt and values from cn.txt.

That is it. It is a bit more steps than extracting the English project, but still simple enough, right?
Besides, if you do not satisfied with the default simple key mapping for your English local project, you can also using this way to change you key mapping as your will.

The 0.3 version of ready_for_i18n also contain some bug fixes and the following enhancements:

Support for a Dry run mode — Just using one parameter for your view path, then ready_for_i18n will not replace any of your view files but just generate an dictionary file to STDOUT. You can redirect this out to file as you want.
Support a lazy-lookup(explained as the following screenshot→ clipped from Rails i18n guide) extracting that will help you generate a more structured dictionary file. Just using --dot options in the ready_for_i18n command.

Well, Hope this tool will help you in the coming year! Looking forward to your comments.

Happy new year!

Get your local Rails application ready for I18N

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

Get your local Rails application ready for I18N

17 Dec 2009 – Beijing

Think of the following scenario:
You have created your lovely Rails application and managed to get it real. After a period of time it become more and more popular. People around the world love your application. Then somebody start to ask wether you can provide an version in their language. Some active users even made a commitment that they will contribute the translation to their language.

Pretty good news yet, but when you look back to you application code, you already have over hundreds ERB pages with many hard-code text being spread in HTML and ERB tags…
Although Rails > 2.2 provide a handy way of doing I18N by the I18n.translate( t method in helper), Found out all the text need to transfer is a tedious and error-prone task.

An I18N Textmate Bundle written by Sven Fuchs may do you a favor when extracting those text. But you still need to find every explicit string and name the keys of them manually.

Could we make an automatic tool for this boring task? Since if the hard-coded text is written in English, we can conventionally name the key with the same name. (just lowercase it and connected with underline other than space). And the texts need to be translated in ERB seem to have some common attributes: they either exist in the HTML text node or in some helper methods like link_to, label_tag, etc…

Based on the above assumption, My colleague Rainy pair-programming with me the following tool called ready_for_i18n . and release it at Gemcutter. After install it by
gem install ready_for_i18n
just run:
ready_for_i18n <you view path> <target path>

Then the tool will transform your view like the screenshot #1(Diff result) and also generate a dictionary en.yml file looked like screenshot #2.
Have the similar I18N problem? Check it out and any of your comments are welcome here and also on the project home at github .

Screenshot #1: Diff result of the transform result with the original view file

Screenshot #2 Auto generated en.yml

A Simple Global Setting class

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

A Simple Global Setting class

10 Dec 2009 – Beijing

Almost in every web application, the administrator user need to setup some system parameters on the fly.
These parameter settings are different from the application configuration, which normally stored in the yml files under the config directory. Some of the developers incline to create a migration and store such properties into DB.

But for most of the simple situations, the YAML file just work fine. We only need to wrap it a little like a GlobalSetting class listed below.

So that you can save your params got from controller directly like:
GlobalSetting.save param[:setting]

And retrieve them just by:
GlobalSetting[:TAX_RATE]

The setting hash you save can have more complex structure combined by arrays or other hashes,like:
GlobalSetting.save {:ACCOUNT => {:TAX_RATE => 0.2}}

Instead of using
GlobalSetting[:ACCOUNT] && GlobalSetting[:ACCOUNT][:TAX_RATE]
for avoiding the NoMethodError, we have a more DRY way:
GlobalSetting[:ACCOUNT, :TAX_RATE].

Source Code of global_setting.rb

class GlobalSetting
  cattr_accessor :file_path
  self.file_path = File.join(RAILS_ROOT,'config','setting.yml')
  
  def self.[](*keys)
    keys.inject(setting){ |m,k| m[k] if m.is_a?(Array) || m.is_a?(Hash)}
  end
  
  def self.[]=(key,value)
    setting[key] = value
  end

  def self.save(hash = nil)
    hash = setting unless hash
    File.open(file_path,'w+'){|f| f << hash.to_yaml}
    @setting = load
  end

  def self.merge(hash)
    setting.merge!(hash)
    save
  end
  
  private
  def self.setting
    @setting ||= load 
  end
  
  def self.load
    File.file?(file_path) ? YAML.load_file(file_path) : {}
  end
end

The Unit Test Code showing how to use it

class GlobalSettingTest < ActiveSupport::TestCase
  def setup
    GlobalSetting.file_path = File.join(RAILS_ROOT,'tmp','test_setting.yml')
    GlobalSetting.save :t1 => "v1",:t2 => "v2",:arr => ['a1','a2',3],
                       :h1 => {:nh => "nested" }
  end
  def test_load
    assert_equal("v1", GlobalSetting[:t1])
    assert_equal("v2", GlobalSetting[:t2])
    assert_equal(3, GlobalSetting[:arr][2])
  end
  def test_update
    assert_equal("v1", GlobalSetting[:t1])
    GlobalSetting[:t1] ="c1"
    GlobalSetting.save
    assert_equal("c1", GlobalSetting[:t1])
  end
  def test_load_from_top
    assert_equal("v1", GlobalSetting[][:t1])
  end
  def test_dig
    assert_equal(3, GlobalSetting[:arr,2])
    assert_equal("nested", GlobalSetting[:h1,:nh])
    assert_nil(GlobalSetting[:t1,:foo,:bar])
    assert_nil(GlobalSetting[:arr,2,:dd])
  end
  def test_merge
    GlobalSetting.merge({:h1 => "new Value"})
    assert_equal("v1", GlobalSetting[:t1])
    assert_equal("new Value", GlobalSetting[:h1])
  end
end

Rails Rock Me

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

Rails Rock Me

9 Dec 2009 – Beijing

Since as a 7 years experienced Java developer, I have to admitted that the stuff that rock me this year is the Ruby language and the Rails framework. Here is the list:

In the construction of the project-portal within the company, Redmine (a flexible project management web application. Written using Ruby on Rails) is a big win against the awkward Liferay. We even think about replacing it for our commercial JIRA instance which used for years in our issue tracking.
The winning factor is that the “Keep It Simple” philosophy being gone through the language, framework and the application.
Happily fixed a small web project written in Ruby on Rails by a novice team. Cut the LOC from 7600 to 5500 while bring significant feature & performance improvements.
Adopted the Sonar as the quality metrics tool for the company. Glad to cooperated with the Sonar team in JRuby on Rails.
Following the RailsCasts and Ruby5 news keep me exciting about the community growth with the contribution from lots of clever guys here.
Learning Ruby by reading the Book named The Well-Grounded Rubyist and scripted it in small tasks bring me back the joyful memory of learning programing in the early day.
Github inspired me to dig deeper into the beauty of the open-source world and start blogging like a hacker.
To be continue …