ar-extensions, Rails 2.x followup

on July 18, 2008 @ 01:41 AM

First things first, ar-extensions moved to Lighthouse and Github. So please no more tickets or patches on rubyforge. I’ll close out or move over the ones on rubyforge that currently reside there.

• ar-extensions at Lighthouse
• ar-extensions at GitHub

Now, the fun stuff.

ar-extensions and Rails 2.x compability

For the most part ar-extensions 0.7.0 (and below) is not compatible with Rails 2.0.x and 2.1. The import functionality works, but ar-extensions will bork on some edge cases of using ActiveRecord::Base.find methods. It won’t return the wrong value, it will simply raise an exception. So if you’re using ar-extensions in your Rails 2.x app, the app itself will probably bork (and I realize that you probably already know this). If you’re using the import functionality in isolation then you should be fine.

Some of the loading issues with ar-extensions that people had are due to ar-extensions being loaded during the time that Rails goes through the loading process (if you put require ‘ar-extensions’ in config/environments/development.rb, test.rb or production.rb). You can get around this by moving if after the Rails::Initializer.run block in your config/environment.rb file.

Tonight I made several commits to get ar-extensions closer to Rails 2.1.0 compatibility. HEAD right now is Rails 2.0.1 compatible, but not 2.0.2 or 2.1.0 compatible. As soon as ar-extensions is compatible I will release 0.8.0. I am hoping for it to be released within the next few days. And by compatible I mean that ar-extensions not only passes its own tests, but it also doesn’t break any of ActiveRecord’s tests.

Using Seed Data with RSpec Stories

on July 17, 2008 @ 02:29 PM

Yesterday I needed to introduce seed data into our application. In order for our story suite to continue to run I needed to populate seed data into the testing environment when the stories ran. I didn’t want to use the production seed data in my test environment, but I wanted to keep things simple. I am already using using seed_fu from Michael Bleigh to handle the seed data for production. Why not leverage it for stories as well?

I made a minor modification to the task to support passing in an argument to rake or setting an environment variable so you can load “fixtures” from a different directory. In my “stories/helper.rb” file I have added near the top:

system "rake db:seed FIXTURE_PATH=stories/fixtures"

This loads the seed data from “RAILS_ROOT/stories/fixtures”. Here’s the modified seed_fu rake task:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

namespace :db do
  desc "Loads seed data from db/fixtures for the current environment."
  task :seed => :environment do
    fixture_path = ENV["FIXTURE_PATH"] ? ENV["FIXTURE_PATH"] : "db/fixtures"
    Dir[File.join(RAILS_ROOT, fixture_path, '*.rb')].sort.each { |fixture| 
      puts "\n== Seeding from #{File.split(fixture).last} " + \
         ("=" * (60 - (17 + File.split(fixture).last.length)))
      load fixture 
      puts "=" * 60 + "\n"
    }
    Dir[File.join(RAILS_ROOT, fixture_path, RAILS_ENV, '*.rb')].sort.each { |fixture| 
      puts "\n== [#{RAILS_ENV}] Seeding from #{File.split(fixture).last} " + \
          ("=" * (60 - (20 + File.split(fixture).last.length + RAILS_ENV.length)))
      load fixture 
      puts "=" * 60 + "\n"
    }
  end
end

After this my seed data was resembling the typical format:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

ExpenseCategory.transaction do
  ExpenseCategory.seed(:object_code) do |s|
     s.object_code = "1234"
     s.name = "Foo"
  end

  ExpenseCategory.seed(:object_code) do |s|
     s.object_code = "1235"
     s.name = "Bar"
  end

  ExpenseCategory.seed(:object_code) do |s|
     s.object_code = "1236"
     s.name = "Baz"
  end
end

And while I like this it’s a little verbose. So I modified seed_fu to introduce the seed_many method to consolidate that:

1
2
3
4
5
6
7

ExpenseCategory.transaction do
  ExpenseCategory.seed_many(:object_code, [
     { :object_code => "1234", :name => "Foo"},
     { :object_code => "1235", :name => "Bar"},
     { :object_code => "1236", :name => "Baz"}
  ])
end

It maintains a simple API and highly readable seed data. I’ve committed this to my fork of seed_fu, and am hoping that Michael accepts the patch and adds it to seed_fu.

• The patch for the rake FIXTURE_PATH: http://github.com/zdennis/seed-fu/commit/4d391aa214c369f161e37c194b07d49e55312b35

• The patch to add the seed_many method: http://github.com/zdennis/seed-fu/commit/9f7e8b27b7cb175911474a898ea282771ab2a5c3

ar-extensions, Rails 2.x

on July 17, 2008 @ 02:34 AM

There are some issues with ar-extensions and Rails 2.x. At first glance it mainly has to do with load order and what to load. I’m going to try to post an update or at least instructions tomorrow so people can use ar-extensions with Rails 2.x and up.

I’m going to be moving the codebase to github and will start work on ar-extensions to get closer to a 1.0 release later this fall. I plan to kick out 0.8 which includes some bug fixes and any Rails 2.x issues as soon as possible.

I am also looking into using Lighthouse for tickets. Rubyforge’s bug tracking isn’t the greatest and apparently there have been tickets there for a while that I had no idea about (sorry about that).

0.9 will be the first release where I look to improve and cleanup the codebase. Thanks for your patience.

Any questions, comments or suggestions feel free to let me know. Thanks,

Refactoring Your Rails Application - Tutorial Content

on June 03, 2008 @ 11:43 PM

• Rails Refactoring Catalog from the tutorial
• Refactoring Your Rails App tutorial slides
• Refactoring Your Rails App example app from the tutorial

The example app is also available from github if you’d like to download the revisions and the different branches used for the tutorial

• http://github.com/zdennis/strac/

Just refer to the refactoring branch and any other branch with “refactoring” in the name.

The official project which the example app is based on is called Strac. The official github repository can be found at http://github.com/mvanholstyn/strac/

If you have any questions, comments or feedback on any of the material or the example app feel free to email me at zach dot dennis at gmail dot com.

RailsConf: RYRA, how'd it go?

on May 29, 2008 @ 06:40 PM

In regards to the tutorial on Refactoring Your Rails Application, how you felt the talk went?

I’ll post more later with slides and links for the downloadable code.

H.R. 5353 - I called, have you?

on May 05, 2008 @ 09:58 AM

I just got off the phone with my state representative Peter Hoekstra’s office to urge him to support the Internet Freedom Preservation Act os 2008—H.R. 5353

For more information on the issue or to determine who to call and what to say, please see www.savetheinternet.com

Book Review - Ruby on Rails: Enterprise Application Development

on May 03, 2008 @ 12:50 PM

I know Slashdot is a busy place, but come on, four months and a book review is still pending, and they don’t respond to any emails? Anyways here is my review of “Ruby on Rails: Enterprise Application Development”.

Ruby on Rails – Enterprise Application Development by Elliot Smith and Rob Nichols targets a new niche in the Rails world of published books. Its goal is to connect all of the dots that make up typical Rails development for developers who have been through the tutorials, but wonder ‘what do I do next?’

The focus of this book is breadth and not depth. The authors do a good job of balancing the explanation of essential Rails concepts while letting the reader know when they are approaching a more advanced topic that won’t be covered in depth.

Throughout the book the authors follow a fictional, yet realistic scenario in which Rory the IT guy implements a simple web-based contacts management application. Each chapter builds on the previous walking the reader through the whole process of development to production deployment.

There is no Rails development until Chapter 4, pg 91. The emphasis of the first 90 pages is understanding what Rails is and why you would use it, as well as introducing the problem scenario that will be used throughout the book. This would be a bigger turn off then it was, but the authors made up for this a little walking the reader through installing everything required for Rails development on multiple operating systems.

Rather then focus on a single platform for development or production the authors use a mixed environment of Ubuntu Linux, OSX and Windows and a cross platform Eclipse IDE. They also take the time to walk the reader through installation and setup of each platform as it pertains to Rails development.

The majority of the development in this book sticks to the functionality included in Rails itself. When it comes to core components of Rails the authors do a great job of covering them: migrations, models, validations, associations, controllers, filters, views and view helpers.

Plugins are not covered except for acts_as_attachment, which is now deprecated in favor of attachment_fu.

The only issue I had with the book was with the sections on testing. The authors cover unit and functional testing with the built-in Rails testing framework. Unfortunately, the example tests are horrible and should not appear in production quality code. The sections on testing should only be used to understand how the built-in testing framework works in Rails and not as an example for writing tests. It is too bad that the authors didn’t cover integration testing either.

A good thing that did come out of the testing sections in this book is the encouragement for developers to write tests which expose bugs before fixing them. It’s the only way to ensure you really fixed it.

Rails 1.2.3 is used throughout the book so any changes, improvements or deprecations in Rails 2.0 aren’t covered. If the reader follows the book with Rails 1.2.3 they should have no issues walking through and developing the code themselves. If the reader follows the book with Rails 2.0 they should be aware of some of the changes, those can be found at http://weblog.rubyonrails.org/2007/12/7/rails-2-0-it-s-done

The things that stuck out to me were:

• view template file naming conventions
• the verbosity of not having named routes
• the lack of the db:rollback rake task

The authors take the time to walk the reader through setting up and using Subversion as an integral part of Rails software development. It also includes setting up and using Apache and Mongrel to serve Rails. As the book moves from development to production deployment the user is shown how to deploy automatically from Subversion to their production server using Capistrano.

There were a few minor typos and one redundant sentence on page 52. This is considerably lower then other technical books that I’ve read.

The only giant red sections marked in my copy are the ones on testing. Take those examples with a grain of salt.

Overall, the majority of the book is filled with good advice for novice Rails developers like, “do not wait until your application is built before you create and test the production environment” and “involve the end users throughout the process”.

If you are a novice Rails developer who understand bits and pieces of Rails this book does a good job of connecting the other dots because the authors take the time to go through the full process of development to production. On the other hand if you have a good grasp on the whole Rails development process you can skip this book.

A good chapter outline of this book can be found at PACKT’s web site

Net Neutrality - Save The Internet

on May 03, 2008 @ 12:44 AM

If you haven’t heard of Net Neutrality before, wikipedia describes it as:

”... a principle that is applied to residential broadband networks, and potentially to all networks. A neutral broadband network is one that is free of restrictions on the kinds of equipment that may be attached, on the modes of communication allowed, which does not restrict content, sites or platforms, and where communication is not unreasonably degraded by other communication streams.”

Unfortunately there are corporations out there which want to control access, speeds and content available to those connecting to the Internet through their services. Below is an informative 10 minute video (I found it at http://www.matthewgood.org/2008/05/net-neutrality/). If you have the time please hit play.

If this issue concerns checkout www.savetheinternet.com . I urge you to spread awareness of the issue and contact your congressman.

form_test_helper, select_form update

on April 02, 2008 @ 05:28 PM

Revision 71 of form_test_helper includes a bug fix for the select_form method. Previously calling select_form with a block would submit the form. The fix forces you to call submit on the form. So…

1
2
3
4
5
6
7
8
9
10

# THIS which used to submit the form
form = select_form 'trip' do |form|
  form.trip.destination = "bahamas"
end

# WILL NOW LOOK LIKE THIS
form = select_form 'trip' do |form|
  form.trip.destination = "bahamas"
end
form.submit

This doesn’t affect the usage of submit_form which still acts as expected.

This will be included in the next release of form_test_helper. Currently trunk for form_test_helper works with Rails 2.0.0 and higher (including today’s most recent trunk commit).

The form_test_helper edge docs have been updated as well and can be found here

Rails Ticket #11491

on April 01, 2008 @ 12:46 AM

If you have a few minutes, please review and comment on Rails ticket #11491.

http://dev.rubyonrails.org/ticket/11491

In short, it adds the ability for “render :partial => some_collection” to render the correct partial based on each element in some_collection. Currently Rails uses the first element to determine what to render for every element in the collection.

Thanks in advance,

More People != More Progress

on March 25, 2008 @ 03:38 AM

There is a common misconception that the best way to add capacity to a project and reduce its completion date is simple—just throw more people at it. Although there is some truth in this, it is usually applied at the wrong times and it ends up having a very negative impact on the project.

This mindset that project development is a series of tasks and that somehow you can just throw people at them and everything will work out is foreign to me, because it won’t work out—at least not when it’s applied in haste.

Adding value to a project is more than completing tasks. Tasks are not isolated during project development. They are features which build on top of one another. Making good responsible decisions and understanding the code base both technically and conceptually goes a long way to help exploit easier and better ways of implementing features. This also helps keep the code base well factored, which in turn helps teams progress consistently and avoid creating a giant roadblock of technical debt which may have lurked just ahead.

What is a factory and why FactoryLoader?

on March 22, 2008 @ 12:58 AM

This statement and question were posted to the http://www.gr-ruby.org mailing list as it pertained to the release of FactoryLoader. This post should answer the question “what is a factory?” and also provide more insight into what FactoryLoader’s role is.

1
2

> I've read over your website, but I still have a lagging question which
> completely blinds my ability to see the usefulness of it: What is a factory?

A factory is “a mechanism for encapsulating complex creation logic” [0].

Here’s an example. Let’s say that you start writing an application that is a project management tool for a business. To start with they need the ability to create Projects. This is no big deal, you have a ProjectsController#create action and it makes your Project by doing something similar to the below:

1
2
3
4
5
6
7
8
9
10

  def create
    project = Project.new params[:project]
    if project.save
      flash[:notice] = "successfully created the project"
      render :action => "create"
    else
      flash[:error] = "failed to create the project"
      render :action => "new"
    end
  end  

Now a few weeks later the customer says that in order to create a project it needs to be assigned a project manager off the bat (the currently logged in user). This is not a very big deal since you have a “current_user” already, you just update your controller to look like:

1
2
3
4
5
6
7
8
9
10
11

  def create
    project = Project.new params[:project]
    project.manager = current_user
    if project.save
      flash[:notice] = "successfully created the project"
      render :action => "create"
    else
      flash[:error] = "failed to create the project"
      render :action => "new"
    end
  end

A few more weeks go by and your customer says that projects are tied to company budgets and when they are created they need to be automatically assigned to the correct budget based on the type of project. So we update to ProjectsController#create looks like the below:

1
2
3
4
5
6
7
8
9
10
11

  def create
    project = Project.new params[:project]
    project.manager = current_user
    project.budget = Budget.find_by_project_type(project.type)
    if project.save
      flash[:notice] = "successfully created the project"
    else
      flash[:error] = "failed to create the project"
      render :action => "new"
    end
  end  

Uh oh. There are important business rules being applied in the controller. The controller’s responsibility is to map an incoming request with an outgoing response and to know high level what the application needs to be doing. It should not know the intimate details of Project creation. Since we’re implementing the business rules on the controller we can’t re-use them for anything, unless we make a POST request to ProjectsController#create. This is quite limiting.

Another option to make them more reusable would be to tuck this away in the Project model itself. Perhaps we add a before_save callback which finds the appropriate budget. Even then we’ve only moved the budget logic out of the controller and there is still requirement for a Project to have a manager. If we go this route we’ll be separating two important pieces of how a Project gets constructed from each other. We would have the ProjectsController#create action setting the manager and then a before_save callback on the Project model finding a budget, both of which are required for a Project to be constructed.

One thought to remedy this would be put everything in the Project model, maybe in a before_save callback or overriding the constructor. But we quickly hit a roadblock because our Project model doesn’t know about the current user, that is application state and only the model knows about that. We could do something stupid and make the current_user global to the application, but that is a bad decision with pretty bad repercussions.

It’d be nice if we had a single object responsible for constructing a Project with these business rules. This is where a ProjectFactory comes into play. The ProjectFactory looks like:

1
2
3
4
5
6
7
8

  class ProjectFactory
    def create(project_attrs, manager)
      project = Project.new project_attrs
      project.budget = Budget.find_by_project_type(project.type)
      project.save!
      project
    end
  end

And the ProjectsController#create action looks like:

1
2
3
4
5
6
7

  def create
    project = ProjectFactory.create params[:project], current_user
    flash[:notice] = "successfully created the project"
  rescue 
    flash[:error] = "failed to create the project"
    render :action => "new"    
  end

This is pretty straightforward. I just moved some of the lines from the action into the factory. More importantly then just moving line of code is that the act of constructing a valid project (given the customer’s requirements) isn’t the responsibility of the Project. The act of constructing a valid project is a process by itself which is important to the customer, so we isolate it in a ProjectFactory.

This is valuable because:

• the business logic used to construct a project is in one spot. Should the customer change, add or remove requirements you only have to go to one spot to implement them. Granted if the method signature to this changes you have to go update the spots calling the create method, but you the actual logic for constructing the project isn’t spread throughout multiple files or classes.
• it promotes reusability (the whole DRY thing), since my ProjectFactory is much more reusable then my ProjectsController.
• it promotes single responsibility
• it provides clearer meaning to the code base because we aren’t muddying up the controller or the Project model with creation logic
• it makes for easier testing and easier to understand tests

The technical implementation of this pattern is mentioned in the GoF book [1]. The value of the pattern as it applies to Domain Driven Design is mentioned in the DDD book by Eric Evans.

Hopefully that helps clarify what a factory is, by seeing how it is used and some of the value it provides. This relates to the FactoryLoader because sometimes the progression of creation logic is over time.

For the first few weeks or months of a project you are hardcoding things like “Project.create” in multiple spots. When the customer starts introducing requirements for constructing (or updating) a Project you have to go update all of those spots with the same code (violating DRY) or go find all of those spots and refactor them to use a ProjectFactory, and then make a ProjectFactory. It doesn’t happen all the time, but when it does happen it can be time consuming, frustrating and painful to do.

What FactoryLoader would do in our example is it give us a ProjectFactory upfront w/o having to write any code. If we used FactoryLoader in the above example our ProjectsController#create action would look like:

1
2
3
4
5
6
7
8
9
10

  def create
    project = ProjectFactory.create params[:project]
    if project.save
      flash[:notice] = "successfully created the project"
      render :action => "create"
    else
      flash[:error] = "failed to create the project"
      render :action => "new"
    end
  end  

Where the ProjectFactory is created for you by FactoryLoader (you didn’t create the class, FactoryLoader did dynamically). There’s only one line that differs between the example that uses the FactoryLoader and the one that doesn’t.

Now when the customer starts adding business rules for creating a Project you can create your own ProjectFactory class and implement the customer’s business rules. FactoryLoader will see that you have provided your own ProjectFactory so it won’t dynamically create one. Since all of the spots where you create a Project are already using a ProjectFactory they get the changes for free. Overall you get to touch less code for the changes and you get to spend less time refactoring if any refactoring is needed.

The goal of FactoryLoader is to allow developers the ability to scale to these customer requirements with less pain. The above examples have been quite trivial, hopefully they are clear enough and meaningful enough to express why I wrote FactoryLoader,

— Zach Dennis http://www.continuousthinking.com

• 0 – Domain Driven Design by Eric Evans
• 1 – Design Patterns: Elements of Reusable Object-Oriented Software by Gamma, Helm, Johnson and Vlissides

Factory Loader

on March 18, 2008 @ 06:10 AM

FactoryLoader is intended to help scale object creation with less pain and less refactoring by creating factory classes for basic object construction.

In the early stages of a project object creation is simple and dependencies are kept to a minimum. As the project grows so does the complexity of object creation and its dependencies. It doesn‘t make sense to create custom factory classes upfront to deal with complex object construction that may not exist yet. But when those custom factories are needed it is usually painful and time consuming to update the code base to use them. It‘s also easy for developers to give-in due to time constraints and start making bad decisions.

This is where FactoryLoader comes into play. It automatically creates a Factory class for your objects and provides a create method which passes any arguments along to your object‘s constructor.

When you need to have custom factory behavior you can implement the factory without having to update other code references (assuming you‘ve used the factory in the rest of your application rather then direct class references).

  project/
    init.rb
    lib/
     |--things/
            |-- foo.rb
            |-- bar.rb
     |--factories/
            |-- bar_factory.rb

Given the above project directory structure you could have the following code in init.rb:

1
2

 factory_loader = FactoryLoader.new("lib/factories")
 factory_loader.load("lib/things")

The first call constructs a factory loader telling it which directory is used to store developer-written custom factories.

The second call will create an in-memory factory class for each *.rb file in the lib/things/ directory. A FooFactory class will be created to correspond with the foo.rb file. The generated factory will provide a create method which will pass along all arguments to the constructor of the object it wraps. So…

 FooFactory.new.create :a => :b

is the same as:

 Foo.new :a => :b

Even though a bar.rb file exists a BarFactory will NOT be created. This is because we told the FactoryLoader that custom factories are storied in lib/factories/ and a bar_factory.rb file exists there, so FactoryLoader assumes you want to use a custom factory. It also assumes that the class inside of bar_factory.rb is BarFactory.

FactoryLoader dynamically creates the factory classes — they are not written to disk. FactoryLoader also uses file naming conventions to determine what to do. For example:

1
2

   foo.rb => FooFactory
   crazy_dolphins.rb => CrazyDolphinsFactory

Factory.new

The dynamically created factories are classes and create is an instance method on them. You have to construct a factory in order to use it. This is so the factories themselves can be easily used in dependency injection frameworks.

Making a custom factory

So you’re using FactoryLoader to do the work of creating factories for you. Let’s say our Foo object now has some creation logic that we do not want in Foo’s constructor. To put it in the FooFactory just create the file in lib/factories/foo_factory.rb. The contents of foo_factory.rb might look like:

1
2
3
4
5
6
7
8
9

class FooFactory  
  def create options={}
    if business_logic_passes?
      Foo.new options
    else
      raise "business logic failed"
    end
  end
end

Install it!

gem install -r factory_loader

More Info

• RDOC: http://mhs.rubyforge.org/factory_loader/rdoc/
• Public git repository: git://github.com/zdennis/factory_loader.git
• Homepage: www.continuousthinking.com/factory_loader

Author

Me, Zach Dennis

Special Thanks

• Dave Crosby at Atomic Object
• Ryan Fogle at Atomic Object

Trying RSpec's Rubyesque Stories

on March 05, 2008 @ 12:35 AM

Today my pair and I wrote some stories using the rubyesque RSpec story style along with a corresponding step file. It went better then expected. We ended up a story like:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# in stories/expenses/a_user_creating_a_misc_expense_story.rb
Story "User creating misc. expense", %|
  As a user 
  I want be able to submit an expense reimbursement request for a misc. expense
  so that I can be reimbursed for business expenditures|,
  :steps_for => :expense,
  :type => RailsStory do
 
  Scenario "creating a misc. expense unsuccessfully" do
    Given "a user at a new expense reimbursement page"
    # ....
  end
  
  Scenario "creating a misc. expense successfully" do
    Given "a user at a new expense reimbursement page"
    # ...
  end
end


# in stories/steps/expense.rb
steps_for :expense do
  Given "a user at a new expense reimbursement page" do
    go_to_root
    click_new_expense_reimbursement_link
  end

  # ...
end

Mocha's error messages suck

on February 26, 2008 @ 08:04 PM

Mocha’s parameter matching error messages suck.

When writing a failing test similar to the below snippet I am given the error message “undefined method `keys’ for :no_args:Symbol”

@user.should_not_receive(:update_attributes).with(has_key('name'))

I love Mocha’s parameter matching, but what kind of error message is that?

This is not the first time I’ve gawked at Mocha’s error messages, but this time just did it for me. My pair didn’t know if we should ping or if we had broken our app.