OnRails.org: Category Ruby On Rails

Moving "private" and non-Rails related entries to <a href="http:blog.wanja.com">http:blog.wanja.com</a>

Daniel Wanja — Mon, 17 Nov 2008 04:59:00 +0000

I received a couple of comments and emails about my non-Rails related entries, more specifically about the iPhone related entries. So from now on I will move these type of entries to my new "private" blog http://blog.wanja.com. As I am starting the development of a new iPhone app and will report about it over there. I am still doing quite some Rails related work and will keep posting about it here (http://onrails.org). I am also experimenting with MacRuby, which is so cool, and will report about it here unless it's specific to iPhone development. I short if you are only interested in Rails or Ruby keep ready this blog, if you are interested in the other "stuff" I play with, such a iPhone, games, Wii, PS3, programming the Wii Remote, and any other geek stuff, check out http://blog.wanja.com

Flex test coverage?

Daniel Wanja — Sat, 11 Oct 2008 02:36:00 +0000

It’s hard to imaging writing a Rails application without using rcov and get that fuzzy feeling you tested most if not all you application. Or at least get a good idea of what’s tested. I heard way back that Alex Uhlmann was working on some test coverage tools, but I didn’t see anything coming out from Adobe. I haven’t used test coverage for my Flex apps, but want to start. Any body has any good hints, stories, frameworks they use for test unit coverage in Flex? A quick google search pointed me to this article describing Flexcover, just what I was looking for. Please share your experience.

Thanks! Daniel.

UPDATE: I am playing with FlexCover and just saw this “Flexcover is a joint effort with Alex Uhlmann of Adobe Consulting, who has been working on a related set of ideas.”. So I guess this is really Alex’s work that Steven was referring to which is now open source under the MIT license. Cool!

Compassionate Communications. A different kind of Rails application.

Daniel Wanja — Thu, 19 Jun 2008 04:29:00 +0000

I have been working with Sean and Lee on Compassionate Communications a Ruby on Rails website. My role was small thanks to the ActiveMerchant plugin, I helped with the online payment but my part was done in no time. The site launched just before Rails Conference and I wanted to write about what the site is. It's about giving, reaching out, helping...but I didn't find the right words to describe it. The team at Compassionate Communications made the following video that captures the essence of what they want to achieve way better I could describe..so go check it out.

Advanced Rails Studio: Custom Form Builder

Daniel Wanja — Fri, 13 Jun 2008 21:42:00 +0000

Custom Form Builder

Use a custom form builder to clean up your html.erb files.

lib/label_form_builder.rb

class LabelFormBuilder < ActionView::Helpers::FormBuilder
  helpers = field_helpers +
            %w{date_select datetime_select time_select} +
            %w{collection_select select country_select time_zone_select} -
            %w{hidden_field label fields_for} # Don't decorate these

  helpers.each do |name|
    define_method(name) do |field, *args|
      options = args.last.is_a?(Hash) ? args.pop : {}
      label = label(field, options[:label], :class => options[:label_clas])
      @template.content_tag(:p, label +'<br/>' + super)  #wrap with a paragraph 
    end
  end
end

Then you can remove all the <p> and label tags from you form.

app/views/users/edit.html.erb

<h1>Editing user</h1>

<% form_for(@user, :builder => LabelFormBuilder) do |f| %>
  <%= f.error_messages %>
    <%= f.text_field :name %>
    <%= f.text_field :address %>
    <%= f.text_area :comment %>
    <%= f.check_box :check %>
    <%= f.submit "Update" %>
<% end %>

<%= link_to 'Show', @user %> |
<%= link_to 'Back', users_path %>

Add this to your application initializer to have all form use this form builder

ActionView::Base.default_form_builder = LabelFormBuilder

Then you can replace

<% form_for(@user, :builder => LabelFormBuilder) do |f| %>

with

<% form_for(@user) do |f| %>

Now the same form with no custom builder was looking like this before.

<h1>Editing user</h1>

<% form_for(@user) do |f| %>
  <%= f.error_messages %>

  <p>
    <%= f.label :name %><br />
    <%= f.text_field :name %>
  </p>
  <p>
    <%= f.label :address %><br />
    <%= f.text_field :address %>
  </p>
  <p>
    <%= f.label :comment %><br />
    <%= f.text_area :comment %>
  </p>
  <p>
    <%= f.label :check %><br />
    <%= f.check_box :check %>
  </p>
  <p>
    <%= f.submit "Update" %>
  </p>
<% end %>

<%= link_to 'Show', @user %> |
<%= link_to 'Back', users_path %>

Advanced Rails Studio: Meta Programming

Daniel Wanja — Fri, 13 Jun 2008 16:57:00 +0000

Chad is giving a very nice presentation walking us through meta programming step by step. You can see the code examples we are creating during his talk, but just looking at the code will note give the whole picture.

# ruby it self uses meta programming
class Person
   attr_accessor :name
end

chad = Person.new
chad.name = 'chad'

# classes are open

# create new class
class Blah
  def greeting
    puts "hello"
  end
end

# reopen class and return id
class Blah
  def do_something!
    greeting
  end
end

b = Blah.new
b.greeting
b.do_something!

# reopen existing class
class String
  def encrypt
    tr "a-z", "b-za"
  end
end

puts "cat".encrypt

# Conceptually ruby (the virtual machine) creates a structure to represent the class
# And this structure can dynamically be defined and changed at runtime.

{
  :String => {:name => "String",
              :methods => {
                :ecryypt => '<method body>',
                :tr  => '<method body>',
                :update => '<method body>',
              },
              :instance_variables => {
                "@name" => "Chad"
              }
  }
}

# replace existing method
class String
  def encrypt
    upcase.reverse
  end
end

puts "cat".encrypt

# Rails extends base classes in activesupport. I.e Fixnum 20.minutes.ago
class Fixnum
  def minutes
    self*60
  end
end

puts 20.minutes

class Fixnum
  def from_now
    Time.now + self
  end
  def ago
    Time.now - self
  end
end

puts 20.minutes.from_now
puts 20.minutes.ago

# Class definition are executed line by line
class Chad
  #exit  #uncomment this and the program will halt here!
  puts "Hello, defining #{self}"
end
puts Chad.new.inspect

# Can conditionaly create class
class Chad
  #exit  #uncomment this and the program will halt here!
  puts "Hello, defining #{self}"
  puts "Type OK when prompted"
  response = gets.chomp
  if response == "OK"
    def greeting    
      puts "OK"
    end
  else 
    def greeting    
      puts "O NO!!!"
    end
  end  
end

puts Chad.new.greeting
# Could use this to have different code for RAILS_ENV is "Prodution" or "Development"

# Sending messages to Object. Object receive message, all method calls have received

"Chad".upcase         #,I.e. String "Chad" gets message upcase
puts "Hello"          # event 'puts' is a message
puts self.class.name  # Even when running script, running in context of an Object

class Person
  def initialize(name)
    @name = name
    greeting
    puts "self.inspect: #{self.inspect}"
  end

  def greeting
    puts "0, hello #{@name}."
  end

end
puts Person.new('daniel').greeting

# Calling class methods
class Person
  puts "Puts is send to self. Self is person:#{self} when defining class."
end

# Can point to a class
person_class = Person
puts person_class.class

class Man
end

class AstroMan
end

# Factory method, classes are just object that can be passed around
def man_or_astroman
  klass = (rand(2) > 0 ? Man : AstroMan)
  klass.new
end

puts man_or_astroman
puts man_or_astroman
puts man_or_astroman
puts man_or_astroman

# Constance in Ruby are not Constants
if false  #Don't run this
  String = "HAHAHA"   #You can even change the class constants implementation
  # You'll get a warning (Warning: already initialized constant String), but you can change it
  Integer = "bla"
  Array = 123
end

# Methods can be defined on Objects and not just Classes
animal = "Cat"
def animal.speak
  "woof"
end 
puts "animal.speak: #{animal.speak}"
# "dog".speak doesn't exists, only the specific animal instance has speak
# It's not often done in Ruby, but in another context you'll do it all the time...

# .. Adding class methods (singleton methods (not related to pattern)).
class Human
    def self.announce_self
        puts "I AM #{self}, and I AM BEING DEFINED"
    end
    announce_self # Can invoked defined class method while defining class
end

# Same as doing def Human.annouce_sef end
Human.announce_self

# We are getting closer to has_many
class Superman < Human
  announce_self
end

# Let's try doing something similar to ActiveRecord
module ActiveRecord
  class Base
    def self.has_many(*things)
      puts "#{self} has_many #{things}"
    end
  end
end

class BuzzLightYear < ActiveRecord::Base
  has_many :space_ships # does nothing for now but it's valid syntax
end

# This is more the way Rails works
# Can do included hook and extend
module ActiveRecord
    module Associations
        module HashManyAssocation
          def self.included(klass)
            klass.extend(ClassMethods)
          end
          module ClassMethods
            def has_many(things, options = {})
              # TODO: define methods
              puts "#{self} has many #{things}"
            end
          end
        end
    end
end

module ActiveRecord
  class Base
    # INCLUDE
    include ActiveRecord::Associations::HashManyAssocation  
  end
end

class AstorMan < ActiveRecord::Base
  has_many :space_ships
end

# But could simply extend
module ActiveRecord
    module Associations
        module HashManyAssocation
            def has_many(things, options = {})
              # TODO: define methods
              puts "#{self} has many #{things}"
            end
        end
    end
end

module ActiveRecord
  class Base
    # EXTENDS
    extend ActiveRecord::Associations::HashManyAssocation
  end
end

class AstroMan < ActiveRecord::Base
  has_many :space_ships
end

# acts_as_ ... to add functionality without extend ActiveRecord::Base
# We could use include with the included hook

module SuperHero
  def self.included(klass)
    klass.extend(ClassMethods)
  end
  module ClassMethods
    def acts_as_superhero
      puts "I'm a bird, I'm a plane, no I'm #{self}"
    end
  end
  def fight_crime
    puts "OK, fighting crime"
  end
end

# use include
class AstroMan < ActiveRecord::Base
  include SuperHero
end
AstroMan.new.fight_crime

# And include in your base class
class ActiveRecord::Base
  include SuperHero
end

# then acts_as is available
class SuperMan < ActiveRecord::Base
  acts_as_superhero
end
SuperMan.new.fight_crime

# Calling non-existant methods
class Chad  
  def method_missing(method_name, *args)
    puts "You called #{method_name} with #{args.inspect}"
  end
end
Chad.new.just_do_it('again', 'and again')

# Calling non-existant classes
def Object.const_missing(name)
  puts "Trying to get to non existing clas #{name}"
  # trick: could require the file if class is missing
end
AnythingClass

# Now that we went through the concepts let's do some meta programming

# eval
def evaluator(str, a_binding)
  a_value = 123
  eval(str, a_binding)
end

str = "puts a_value"
a_value = 321
evaluator(str, binding)  # -> 321. binding is the current scope of the program
evaluator(str, nil)      # -> 123. don't pass binding

# instance_eval
class Thing
    def a_value
        123
    end
end

Thing.new.instance_eval("puts self.a_value") # -> 123. run in context of an instance

# Two more 'eval': class_eval and module_val

#class_eval 
class Person
end

Person.class_eval do  # Be in context of class
  p self            # -> Person
  def greeting
    puts "Hello"
  end
end

Person.new.greeting  # defining instance method

def add_greeting_to(klass)
  klass.class_eval do
    def greeting
      puts "Greeting"
    end
  end  
end
add_greeting_to(String)
"asdf".greeting    # -> Greeting

# module_eval is basically same thing as class_eval

# define_method
class Chad
  define_method(:foo) do |arg1|
    puts "hello, #{arg1}"
  end
end

Chad.new.foo(:bar)

RailsConf registration opens today. Be ready!

Daniel Wanja — Tue, 29 Jan 2008 14:10:53 +0000

May 29-June 1, 2008 in Portland, Oregon,

UPDATE: registration is now open.

UPDATE2: I’ll be presenting with Tony a 3 hour tutorial on Powering AIR Applications with Rails. See you all there!

Rails 2.0

Daniel Wanja — Fri, 07 Dec 2007 16:07:46 +0000

Rails 2.0 is out! Thanks guys for all the hard work, this release is just impressive.

Acts_as_nested_set ActiveRecord rendered with mx:Tree in Flex.

Daniel Wanja — Sat, 24 Nov 2007 03:30:13 +0000

ActiveRecord: app/models/category.rb

app/models/category.rb

class Category < ActiveRecord::Base
  acts_as_nested_set
end

Controller: app/controllers/categories_controller.rb

app/controllers/categories_controller.rb

class CategoriesController < ApplicationController
  def index
     Category.result_to_attributes_xml(Category.root.full_set)
  end
end

Flex Application: ActsAsNestedSet.mxml

ActsAsNestedSet.mxml

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" 
    layout="vertical"
    applicationComplete="categories.send()">
<mx:HTTPService id="categories" url="http://localhost:3000/categories" resultFormat="e4x" />
<mx:Tree dataProvider="{categories.lastResult}" 
    labelField="@name"
    width="100%" height="100%" />    
</mx:Application>

Result:

XML generated by Category.result_to_attributes_xml(Category.root.full_set):

XML generated by Category.result_to_attributes_xml(Category.root.full_set)

<node name="Main Category" id="15" description="">
  <node name="Cameras &amp; Photo" id="16" description="">
    <node name="Bags" id="17" description=""/>
    <node name="Accessories" id="18" description=""/>
    <node name="Analog Cameras" id="19" description=""/>
    <node name="Digital Cameras" id="20" description=""/>
  </node>
  <node name="Cell Phones" id="21" description="">
    <node name="Accessories" id="22" description=""/>
    <node name="Phones" id="23" description=""/>
    <node name="Prepaid Cards" id="24" description=""/>
  </node>
  <node name="Dvds" id="25" description="">
    <node name="Blueray" id="26" description=""/>
    <node name="HD DVD" id="27" description=""/>
    <node name="DVD" id="28" description=""/>
  </node>
</node>

I used the http://wiki.rubyonrails.org/rails/pages/BetterNestedSet plugin.

Too cool!

UPDATE: The BetterNestedSet plugin doesn’t work out of the box with Rails 2.0 RC1. Thanks Joel for that info. Read more in the comment of this blog entry.

UPDATE2: Thanks Fabien, BetterNestedSet now works with Rails 2.0!

RailsLogVisualizer0.7 for AIR beta 2.

Daniel Wanja — Thu, 08 Nov 2007 04:12:00 +0000

I recompiled the RailsLogVisualizer for AIR beta. I added drag&drop of log files to bypass an AIR bug on Leopard. File.browseForOpen doesn't trigger the Event.SELECT when the file is selected. I haven't yet tried this version of the application on older versions of OSX or on Windows. Let me know how it works. Also the feedback when loading large log files could be improved, as the application seems to freeze once the progress bar is complete. Just be a little patient as the AVM is working hard for you to compute all these number.

Install RailsLogVisualizer0.7.air

Install Manually

1) Instal Adobe AIR beta 2. (See release notes if previous version was installed)
Download AIR for OSX Download AIR for Windows
Learn more on AIR

2) Download and install http://myspyder.net/tools/railslogvisualizer/RailsLogVisualizer0.7.air

For time.onrails.org the log file is currently 98Mb and is loaded and process in less than a minute. Here are the loading details:

Loaded 98571986bytes in 28093 milliseconds.
Parsing file. Please Wait this may take some time....
Parsing. Split 1639453entries in 1447 milliseconds.
found:220767 in 1925 milliseconds.
Aggregating data.
	aggregated:220767 in 13426 milliseconds.
	Aggregated:89135
	aggregated String :4440464(bytes) in 2790 milliseconds.

Then you can navigation through time and see how many request where processed and drill down in specific action and specific methods. For example, here we can quickly see that for October 99 people signed up, 869 did login, 22 forgot their password.

Enjoy, Daniel.

Sweet way to write Flex Unit tests for Rails

Daniel Wanja — Mon, 05 Nov 2007 15:11:56 +0000

Using ActiveResources from Flex? Using FlexUnit? Here is a nice way to write your tests.

Example Test Case

package tests
{
    import flexunit.framework.*;    
    import mx.rpc.AsyncToken;
    import mx.rpc.events.ResultEvent;
    import resources.Raffles;

    public class TestRaffles extends BaseTestCase
    {    
        private var raffles:Raffles;        
        public function TestRaffles(name : String = null)
        {
            super(name);
            fixtures(["raffles"]);
             raffles = new Raffles();
        }            
        public function testRemoteFindRaffle():void
        {
            assertRemote(raffles.show(1));
        }
        public function assertRemote_testRemoteFindRaffle(data:Object):void
        {
            Assert.assertTrue("Raffle show successfully called", data is ResultEvent);  
            assertEquals("MyString", data.result.name);
        }        

    }
}

Note this code is not yet a plugin and is using code you can find here: http://code.google.com/p/flexonrails/source. I was starting to use it on multiple projects so I thought it was to time find a home for it. Also it is using the org.onrails.rails.ActiveResourceClient Flex class. I would recommend that you use Alex MacCaw’s ActvieResrouce for Actionscript. I still need to talk with Alex and integrate this fixture loading code with his code.

The BaseTestCase Flex class is an extended TestCase that provides support for fixtures. Now in your constructor you can define which fixtures you want to reload between each test. Only tests methods starting with “testRemote” will trigger refreshing the fixtures. As you know, when using AMF or HttpService remote invocations are asynchronous and you cannot test the result of a remote call in the same method than where the call is made from. That’s why I added the assertRemote method which takes an AsyncToken as parameters. This will automatically invoke a method whos name starts with assertRemote_ followed by the test method name. This simplifies greatly writing asynchronous tests. FlexUnit provides the addAsync method, we just add the convenience assertRemote function to setup all the callbacks.

To make this work for you Flex with Rails project. You need to fixtures_controller.rb to your controllers and setup the following routes:

  if RAILS_ENV == "test"
    map.resources :fixtures, :new => { :test_results => :post }
    map.crossdomain '/crossdomain.xml', :controller => 'fixtures', :action => 'crossdomain'
  end

You need to extend your Flex TestCase from tests.BaseTestCase.

Enjoy, Daniel.