Kevin Sylvestre

Faster Testing in Rails with Guard for Zeus, RSpec, and Cucumber

Sat, 09 Mar 2013 16:44:00 -0500

Two amazing tools that focus on improving how tests are run rather than written in Ruby on Rails are Zeus and Guard. So what are they?

Zeus

Zeus will preload a Ruby on Rails application so that you don’t have to whenever running rake, spec, or server commands.

Guard

Guard monitors the file system and executes tasks whenever files are change.

Integration

Step 1. Setup Your Gems

Follow this example Gemfile configured to work with growl, guard, rspec, cucumber and capybara:

group :development do
  gem 'growl'
  gem 'guard'
  gem 'guard-bundler'
  gem 'guard-cucumber'
  gem 'guard-rspec'
  gem 'guard-zeus'
  gem 'rb-inotify', require: false
  gem 'rb-fsevent', require: false
  gem 'rb-fchange', require: false
end

group :test do
  gem 'capybara'
  gem 'capybara-webkit'
  gem 'rspec-rails'
  gem 'cucumber-rails', require: false
end

Step 2. Setup Your Guards

Follow this example Guardfile configured for cucumber and rspec:

guard 'bundler' do
  watch('Gemfile')
end

guard 'cucumber', command_prefix: 'zeus', bundler: false do
  watch(%r{^features/.+\.feature$})
  watch(%r{^features/support/.+$}) { 'features' }
  watch(%r{^features/step.+/.+$})  { 'features' }
end

guard 'rspec', zeus: true, bundler: false do
  watch(%r{^spec/.+_spec\.rb$})
  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
  watch('spec/spec_helper.rb')  { "spec" }

  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
  watch(%r{^app/(.*)(\.erb|\.slim|\.haml)$})          { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
  watch('config/routes.rb')                           { "spec/routing" }
  watch('app/controllers/application_controller.rb')  { "spec/controllers" }

  watch(%r{^app/views/(.+)/.*\.(erb|slim|haml)$})          { |m| "spec/features/#{m[1]}_spec.rb" }
end

It is possible to

Step 3. Install Growl Notify

Growl Notify

Step 4. Bundle and Install Zeus

bundle install
gem install zeus

Step 5. Start Zeus and Guard

zeus start
bundle exec guard

Progress in Developing iOS and Cocoa

Sat, 02 Mar 2013 02:04:00 -0500

Over the past few iterations of iOS and Cocoa Apple has fundamentally changed the language and improved nearly every aspect. The removal of memory management (and replacement with ARC) has solved more than a few headaches. The addition of short form expressions and blocks means code can be refactored greatly. Here’s a snippet to show what an improvement it has been:

Old:

- (void)userSignupSuccess:(User *)user
{
  ...
}

- (void)userSignupFailure:(NSError *)error
{
  ...
}

- (void)signup
{
  NSArray *objects = [NSArray arrayWithObjects:@"Kevin", [NSNumber numberWithInt:24], [NSDate date]];
  NSArray *keys = @"name", @"age", @"modified";
  NSDictionary *params = [NSDictionary dictionaryWithObjects:objects forKeys:keys];

  UserProcessor *up = [[UserProcessor alloc] init];

  up.delegate = self;
  [up create:params];

  [up release];
}

New:

- (void)signup
{
  [User create:@{ @"name" : @"Kevin", @"age" : @24 } 
    withSuccess:^(User *user) { ... } 
    andFailure:^(NSError *error) { ... }];
}

This isn’t the best of it though. An amazing new package manager has taken off that follows a similar format to the Ruby and Python equivalents. It is called CocoaPods and it rocks! Special thanks to Apple for making developers lives that much better and a huge thanks to all the open source developers who work for free every day to improve the ecosystem!

Deploying Rails with JRuby to Heroku

Fri, 16 Nov 2012 01:44:00 -0500

Step 1: Modify Your Gemfile

#ruby=jruby-1.7.0
ruby '1.9.3', engine: 'jruby', engine_version: '1.7.0'

gem 'puma'
gem 'rails', '3.2.9'
gem 'puma'
gem 'jruby-openssl', platforms: :jruby
gem 'activerecord-jdbcpostgresql-adapter', platforms: :jruby
gem 'therubyrhino', platforms: :jruby

Step 2: Modify Your Procfile

web: bundle exec rails server puma -p $PORT -e $RACK_ENV

Step 3: Configure Your Application

heroku create
heroku config:set PATH=bin:/app/vendor/bundle/jruby/1.9/bin:/usr/local/bin:/usr/bin:/bin 
heroku config:set GEM_PATH=vendor/bundle/jruby/1.9

Step 4: Deploy

git push heroku master

Setting Up Mac OS X For Development

Sat, 28 Jul 2012 17:29:00 -0400

Step 1: Install Xcode

Open the App Store (located in the dock)
Search for ‘Xcode’ and install
Open ‘Xcode’ and select Preferences (⌘,)
On the ‘Downloads’ tab install the ‘Command Line Utilities’

Step 2: Install XQuartz

Browse to http://xquartz.macosforge.org/landing/
Download the latest DMG (2.7.2 or newer) and run the XQuartz.pkg

Step 3: Install Everything

From Terminal: curl -sL goo.gl/gfdqL | bash

Finished version can be found here: http://gethearts.com/.

Mon, 20 Feb 2012 22:17:15 -0500

Finished version can be found here: http://gethearts.com/.

Lessons Apple Should Learn from Ruby and Rails

Sun, 06 Feb 2011 20:10:00 -0500

I’ve been a practicing iOS and Mac developer for a few years and I love many aspects of Apple’s platforms. Apple’s interface design software is incredible, programs run fast even on mobile devices, and the debugging tools are fantastic. However, with experience comes bitterness. My “grass is always greener” beliefs comes from having also been writing Ruby (on Rails) code as well. Rails has introduced me to a variety of conventions that I think should be in the Cocoa frameworks. So, I’ve decided to compare and contrast a few snippets of Cocoa and Rails and list my two biggest issues.

The first issue with Mac development is the language. Objective-C might have been the hottest thing in town in the 1980’s but it has cooled off over the last 20 years. One of my biggest frustrations is with the amount of code required to get started. For example, compare these two class declarations:

Ruby:

class Person
  attr_accessor :name&#13;
end

Objective-C:

#import "Foundation/Foundation.h"

@interface Person : NSObject 
{
    NSString *name;
}

@property (nonatomic, retain) NSString *name;

@end


#import "Person.h"

@implementation Person

@synthesize name;

- (void)dealloc
{
    [name release];
    name = nil;
    [super dealloc];
}

@end

The above code explains where my frustration stems from. Having lots of code is a pain. It is difficult to read, difficult to troubleshoot, and easy to do wrong. I often struggle with programming in Objective-C and follow DRY (don’t repeat yourself) paradigm.

The second problem with developing in Cocoa is that the framework designers went in with some questionable goals. I first learned Cocoa by watching presentations from Apple Engineers and can remember hearing “Cocoa makes the easy things easy and the hard things possible” as a mantra. As Robert Martin stated in his 2009 Rails Conference presentation in “What Killed Smalltalk Could Kill Ruby Too” this is insane. The real motto should be something along the lines of “make the easy things trivial and the hard things easy”.

A great example of making hard things easy can be found in how Rails handles persistent storage. Active Record was integrated into Rails to make saving, storing and updating database records a breeze. Core Data was designed by Apple to torture developers. For example, see some of the steps required to make the previous example persistent:

Rails:

Person.all.each do |person|
  puts "Hi #{person.name}"
end

Cocoa:

NSManagedObjectModel *managedObjectModel = [[NSManagedObjectModel alloc] initWithContentsOfURL:[NSURL fileURLWithPath:@"model.mod"]];
NSPersistentStoreCoordinator *persistentStoreCoordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:[self managedObjectModel]];
NSManagedObjectContext *managedObjectContext = [[NSManagedObjectContext alloc] init];

[persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:[NSURL fileURLWithPath:@"data.sqlite"] options:nil error:NULL];
[managedObjectContext setPersistentStoreCoordinator:persistentStoreCoordinator];

NSFetchRequest *request;
NSEntityDescription *entity;

request = [[NSFetchRequest alloc] init];
entity = [NSEntityDescription entityForName:@"Person" inManagedObjectContext:context];

[request setEntity:entity];

NSArray *people = [context executeFetchRequest:request error:NULL];

for (Person person in people)
{
  NSLog(@"Hi %@", person);
}

[request release];
[managedObjectContext release];
[persistentStoreCoordinator release];
[managedObjectContext release];

This isn’t a language limitation, this is a framework problem. Core Data could have been designed to give developers the same one line access to data that Rails has, but good defaults were never selected. As such flexibility was created at the cost of many developers time. Apple should have set out with a set of goals for doing basic CRUD operations without ever having to look through copious amounts of documentation.

I don’t hate Apple; let me assure you that the opposite is true. I understand that the hardware and software shipped by the company over the past five years will be marked as some of the best ever created. I just hope that someone in Cupertino is thinking about the developers as the frameworks and languages continue to progress.

Video

Tue, 21 Dec 2010 06:54:01 -0500

Are Grid Systems Wrong?

Sun, 14 Nov 2010 06:33:00 -0500

I am finishing in the process of finishing up a project and have started to question the ‘correctness’ of grid systems. Although they are extremely powerful I see a few things I wish were better:

New Markup Grid systems require the introduction of new markup into the HTML (adding ‘grid-1’, ‘grid-2’, ‘grid-3’, etc. to divs, etc.). This is terrible HTML to inject because it is non-semantic (adds no meaning). A workaround is to switch to using smarter stylesheets with SASS and Compass, however for many projects this isn’t an option.

Annoying Layouts Grid systems rely on having ‘gutters’ between elements. Unfortunately this can make integrating with non grid system elements a pain. One solution is to switch to using a more precise grid system.

Commitment Issues The last criticism of grid systems pertains more to design decisions. Once a designer (or developer) starts using grid systems they get hooked. Just because the grid system can format a beautiful about page, does not mean it should be used within the core of an application.

Conclusion Although the above issues are serious, life is much better with grid systems. Use them, but use them carefully.

Concept logo for online video portfolio site.

Mon, 08 Nov 2010 20:44:06 -0500

Concept logo for online video portfolio site.

OptiPNG

Tue, 02 Nov 2010 15:34:00 -0400

I recently needed a small project to test out Platypus, a tool used to create simple native Mac applications. After only 30 minutes I managed to create a container for OptiPNG, a PNG compression library (download DMG or Zip). The icon was found on Icon Finder and was designed by Louise Harobe. The DMG was created using DMG Canvas.

New icon I’ve been playing around with.

Wed, 20 Oct 2010 19:35:40 -0400

New icon I’ve been playing around with.

Best Idea Ever

Wed, 20 Oct 2010 15:32:00 -0400

This morning I had an epiphany. Someone should design a sticker that will fade at a given rate. One could purchase a sticker that fades in two days to remember when to water the plants, two weeks to remember when the milk is bad, two months to remember when to replace a shaving razor head, etc. Once a product was replaced, a new sticker could be put on overtop. Better yet, the product could be licensed to companies that want customers to repurchase at given time intervals. Patent pending…

A skin for a JW Player.

Mon, 18 Oct 2010 21:39:38 -0400

A skin for a JW Player.

A sample ‘generic’ mac web site design for the...

Sun, 17 Oct 2010 06:24:16 -0400

A sample ‘generic’ mac web site design for the vector drawing application.

An icon in the works for yet another vector based drawing...

Sun, 17 Oct 2010 06:22:28 -0400

An icon in the works for yet another vector based drawing application.

Visual Editors for Creating Web Content

Thu, 14 Oct 2010 18:21:00 -0400

During my youth I fondly remember exploring the Internet and discovering how web sites were made. During the time I was happy to develop sites for both paying and free clients including: the Yukon Information Technology Industry Society, the Yukon River Trail Marathon, the Canada Winter Games, and a small development company Sorrento Systems. My process was simple: I used Dreamweaver and Fireworks. Sure layouts often involved complex tables and hundreds of spliced images. At the time I didn’t appreciate clean HTML and had no use for CSS.

Flashing forward to present day I work as a software developer and code projects using modern what I consider modern web frameworks. I now write streamlined code. I fear using a table tag. My processes includes TextMate, Photoshop, Illustrator, Transmit, Versions and Kaleidoscope. Code is often tested, abstracted and maintainable.

The question I ponder is if the process today is better than that which I stumbled on in my youth. Now I seem to spend countless hours designing in Photoshop or Illustrator, only to have to recreate the designs in HTML and CSS. I switch between tools for different steps of projects and will reiterate when required. I can no longer find a one-stop tool to do everything.

Maybe web tools could use an equivalent to Apple Interface Builder that allows for a one-stop design place. Then again, maybe it is time I finally learn VIM and give up on all the tools.

NSError Is NSAwful

Thu, 14 Oct 2010 18:14:00 -0400

NSError is a contender for one of the worst features of the cocoa framework. Who thought these are these better than exceptions? Don’t developers see that these are just fancy return codes? Here are some major problems:

Most developers don’t handle errors. Exceptions add due pressure to not let things slip. With ‘NSError’ it is so easy to pass NULL or never check the return.
Mobile devices don’t have any easy way to display errors. Sure desktop applications have ‘NSApp’ that can present them, but what about iOS?
Most documents don’t detail what errors can occur. For example, the documentation for ‘NSFetchedResultsController’ states ‘contains an error object that describes the problem’. Great.

The Switch to Rails 3

Wed, 16 Jun 2010 02:01:00 -0400

Switching to Rails 3 for a recent project wasn’t an easy decision. On an initial investigation, too many GEMS lacked support for the latest offerings of the community. However, the excellent new router and ability to integrate more easily with a variety of JavaScript frameworks made switching worth the costs (thus far). If you are interested in switching, be sure to http://www.railsplugins.org/ and see if compatibility will be an issue for you. Otherwise, go for it!

Why Can't I Switch into GIT?

Tue, 08 Jun 2010 12:30:00 -0400

GIT out-trumps SVN in almost every way. The decentralize repository is better, the branching is better, and the social aspects (through github) are incredible. However, I can’t make the transition because I am hooked on Versions and Kaleidoscope. Having a great GUI to show changed files, and side by side comparisons is more important than having an amazing command line tool. Until someone writes a great GIT client (and no, none exist right now) I probably won’t move my repositories. However, the ability to use SVN to commit to GIT Hub (here) might sway me.

Recurring Billing

Sat, 05 Jun 2010 13:44:00 -0400

Most web app ideas fall under an advertisement model or a freemium model. In the later case, a great application to simplify recurring billing is Chargify. The software lets developers link to a payment form or integrate custom forms with the service through a RESTful API (or a gem).

Once integration is done, administrators can track and update subscribers through a gorgeous web interface.

Overall, the application is easy to use and offers many features over ActiveMerchant. The support team for the application is generally quick to respond and the pricing is reasonable. Looks like a big time saver.