In this example, I am going to use a fairly inefficient piece of Ruby code I created a while ago for Project Euler (Problem 10) for finding the sum of all primes under 2000000:

class Integer
 
  def prime?
    return true if self == 2
    return false if (self & 1) == 0
    square = Math.sqrt(self).round + 1
    i = 1
    while i <= square
      i+= 2
      return false if (self % i) == 0
    end
    true
  end
 
end
 
numbers = (2..2000000).to_a
 
numbers = numbers.select { |n| n.prime? }
puts numbers.inject { |result, element| result = element + result }

At the time that I wrote this, I was relatively unaware of more efficient ways of resolving prime numbers (such as a euler sieve), however the code still ran under the allotted 2 minute window (52 seconds) so I went with it. Now to speed it up. To write a C extension you need, at a bare minimum two things:

1. an extconf.rb file – this file is used by ruby to generate the Makefile that is used to compile the extension
2. the source file for the extension (in this case primed.c)

Here is a look at these two files for my new version of problem 10:
primed.c

#include "ruby.h"
#include <stdlib.h>
#include <math.h>
 
VALUE Primed;
 
VALUE method_prime(VALUE obj, VALUE args)
{
	register uint64_t n;
	n = NUM2INT(obj);
	if (n == 2)
		return Qtrue;
	if ((n & 1) == 0)
		return Qfalse;
 
	register uint64_t sqrt_n = ((uint64_t)sqrt(n)) + 1;
	register uint64_t i=3;
	for (i; i<= sqrt_n; i+=2) {
		if (n % i == 0)
			return Qfalse;
	}
	return Qtrue;
}
 
void Init_primed() {
	Primed = rb_define_module("Primed");
	rb_define_method(Primed, "prime?", method_prime, -2);
}

extconf.rb

# Loads mkmf which is used to make makefiles for Ruby extensions
require 'mkmf'
 
# Give it a name
extension_name = 'primed'
 
# The destination
dir_config(extension_name)
 
# Do the work
create_makefile(extension_name)

First let me explain primed.c. The objective of this extension is to determine whether or not a number is prime, so that an integer can call x.prime? and return true or false. It is essentially identical to the method used in the pure ruby script above. One of the first thing you may notice is this line:

VALUE Primed

VALUE is a data type defined by Ruby that represents the Ruby object in memory. It is basically a struct that contains the data related to the object. In this case, the object will represent the “Primed” module in ruby, so it will contain data about the instance methods, variables, etc. for that module. All Ruby objects are represented in C by VALUE, regardless of their type within the Ruby VM, anything else will likely result in a segfault.

Next we define the actual method to calculate whether the value is prime. Note that because we need to return a Ruby object, we set the return type as VALUE as well. QTrue and QFalse are directly representative of true and false in ruby, and also return correctly within C (QTrue will evaluate as true, QFalse will evaluate as false).

Finally we see the Init_primed method. Every time a class or module is instantiated within the Ruby VM it calles Init_name. It is here we actually instantiate the Primed module and bind the method_prime function to the Ruby method prime?. Both functions used are pretty self explanatory as to what they do, except for the last argument used in ruby_define_method which is essentially the arity or number of arguments to expect in the Ruby method. In this case, -2 actually make ruby send back self as the first argument to the method_prime function, and an array of any other arguments as the second.

Now we have all of our code. The last thing to put in place is extconf.rb:

# Loads mkmf which is used to make makefiles for Ruby extensions
require 'mkmf'
 
# Give it a name
extension_name = 'primed'
 
# The destination
dir_config(extension_name)
 
# Do the work
create_makefile(extension_name)

Pretty simple right? Now when you call ruby extconf.rb it will generate a Makefile that you can use to build the extension. And the final result? Using the C extension the code runs in just under 3 seconds. Still not really efficient, but it demonstrates the point. When Ruby’s speed is the bottle neck, using C is a viable and easy option.

1. STOP SLAVE; # stop the Slave I/O threads
2. RESET SLAVE; # forget about all the relay log files

Then go to the master database and run these

1. RESET MASTER; # reset the bin log counter and wipe out bin log files
2. FLUSH TABLES WITH READ LOCK; # flush buffers and LOCK tables
3. show master status\G

Note what the show master status command returns. You’ll need to know the file name and the position.
You can do one of two things here, make a dump of the entire master database (in which case I suggest you follow this)
or you can just update the tables.
Usually we just need to update the tables so release the lock on the master database tables (UNLOCK TABLES;) and then run this command on the slave database (download maatkit tools here),

• cd ~/maatkit-5014/bin && sudo ./mk-table-sync –[print][execute] u=[user],p=[pass],h=[master_host_name] –databases [database_name(s)] localhost

I suggest you run –print before you run –execute. If you run –execute first, you have no idea what just happened. –print will let you know what it’ll do without actually doing anything.
Back to the slave database mysql client, issue these commands,

1. CHANGE MASTER TO MASTER_LOG_FILE=’[file name from show master status command]‘, MASTER_LOG_POS=[pos];

2. SLAVE START;

Run this command,

• show slave status\G

And check that these aren’t NO or NULL,

Slave_IO_Running: Yes
Slave_SQL_Running: Yes
….
Seconds_Behind_Master: 1634

If things aren’t back to normal, follow the instructions on this website.

With one equals sign you assign a value to a variable:

composer = "Beethoven"

With two equals signs you see if two things are the same thing:

puts "9th Symphony" if melody == "Ode to Joy"

With three equal signs you get, well, essentially you get a placeholder that you can use to define arbitrary relationships between objects which you will mostly never call by hand yourself but which Ruby will call for you when you run case statements:

class Composer
  attr_accessor :works
  def initialize(*works)
    @works = works
  end
 
  def ===(work)
    @works.include?(work)
  end
end

The trequals operator (ok, method) returns true or false depending on a condition I’ve defined. Now I can test a given work against a bunch of composer objects using a case statement:

beethoven = Composer.new("Fur Elise", "Missa Solemnis", "9th Symphony")
mozart = Composer.new("The Magic Flute", "C Minor Mass", "Requiem")
bach = Composer.new("St. Matthew Passion", "Jesu, Joy of Man's Desiring")
 
case "Requiem"
  when beethoven
    process_beethoven_work
  when mozart
    process_mozart_work
  when bach
    process_bach_work
end

The trequals is called behind the scenes by Ruby. Since I’ve defined it on the Composer class to look for a matching entry in that composer’s list of works, the case statement becomes a way of running different code based on which composer wrote the work in question.

This example is contrived, of course, because if it was this simple a need you’d probably just check “some_composer.works.include?(‘Requiem’)” by hand. But the example demonstrates the crucial point, that there’s no equality being checked for. A work in no way is the composer. It’s a relationship that the case statement is checking for–the given work was written by the given composer–and it’s a relationship that I’ve defined explicitly for my own music-categorizing purposes.

That case statements work this way is yet another example of the magical and powerful stuff that characterizes Ruby. Instead of simply a strict equality match, we can now switch against multiple types, all with different definitions of what qualifies as a relationship:

class String
  def ===(other_str)
    self.strip[0, other_str.length].downcase == other_str.downcase
  end
end
 
class Array
  def ===(str)
    self.any? {|elem| elem.include?(str)}
  end
end
 
class Fixnum
  def ===(str)
    self == str.to_i
  end
end
 
string_to_test = "99 Monkeys"
case string_to_test
  when "99 monkeys jumping on the bed"
    do_monkey_stuff
  when ["77 Rhinos Jumped", "88 Giraffes Danced", "99 Monkeys Sang"]
    do_animal_behavior_stuff
  when 99
    do_quantity_stuff
  when /^\d+\s+\w+/
     do_regex_stuff
end

Here, if the string to be tested is the first portion of the larger string (case-insensitively speaking), if it is part of any of the elements in the specified array, if it starts out with 99 (string.to_i returns only leading integers), or if it matches the given regular expression, the respective code will be run. In this case, it matches all of them, so only the code for the first case–the string match–will be run (in Ruby, switches automatically stop at the first match, so you don’t need to give each case its own “end” line).

Note that I didn’t need to define (actually, override) the trequals on the regular expression. The relationship operator is a method on Object, so all Ruby objects inherit it. If not overridden, it defaults to a simple double-equals equality check (thus contributing to the momentum of the misnomer “case equality”). But some standard Ruby classes already come with their own definition for trequals. Regexp and Range are the notable examples: Regexp defines it to mean a match on that regular expression, and Range defines it to mean a number that falls somewhere within that range, as such:

num = 77
case num
  when 1..50
    puts "found a lower number"
  when 51..100
    puts "found a higher number"
end

Note that since === is really a method, it is not commutative, meaning you can’t swap sides on the call; “a === b” is not the same as “b === a”. If you think through it, it makes sense. You’re really calling “a.===(b)”. If a is an array, you’re calling a method on Array, which will be defined for Array’s own purposes. If b is a string, and you swapped the order, you’d be calling a String method, which would have a different purpose for its trequals operator, so “b.===(a)” would most likely be something quite different. This concept also means that the variable you’re testing in a case statement is being passed as a parameter to the trequals methods of the various case objects, not the other way around. These two snippets are equivalent:

case "St. Matthew Passion"
  when mozart
    process_mozart_work
end
 
process_mozart_work if mozart === "St. Matthew Passion"

Note that the second snippet was not

process_mozart_work if "St. Matthew Passion" === mozart

It’s also good (although I’m not sure how useful) to know that the relationship operator is used implicitly by Ruby when rescuing errors in a begin-rescue block.

begin
  do_some_stuff
rescue ArgumentError, SyntaxError
  handle_arg_or_syn_error
rescue IOError
  handle_io_error
rescue NoMemoryError
  handle_mem_error
end

In this example, Ruby runs ArgumentError.===, passing it the global variable $!, which holds the most recent error. If that returns false, it moves along, doing the same with SyntaxError, IOError, and NoMemoryError, each in turn. With errors, the trequals is defined to just compare the class of the error that occurred with that of each candidate class (in this case, ArgumentError, etc.) and its ancestors.

It took me a long time before I cared about this little Ruby feature, which I think is sad. I think I just saw the phrase “case equality” and thought something like “Hmm, another subtle variation on what it means for two objects to be equal. I’m sure I’ll have occasion to use this someday. I’ll figure it out then.” But it’s more useful than that, and I think it would get better traction without the specious nomenclature.

Starting with the basics, we’ll first cover retrieving a project:

git clone [repository]

This will get the currently active branch from the repository

Obviously you’ll want to do something with this newly retrieved working copy of the project. Let’s first create a branch for the new features/bug fixes we’ll be coding.

git checkout -b [newbranchname] origin

Ok, so we got a new branch. While we’re coding, it’s a good idea to commit tons of times to preserve the changes we’ve just made. Don’t worry about the log, we’ll make it pretty later. Just commit often.

git add [filename(s)]
git commit

If it’s a small change that doesn’t require much explanation, you can use these commands

git add *
git commit -m "The commit message"

Or, even shorter

git commit -a -m "The commit message"

You finished that feature so now it’s time to merge that branch with the master branch (or some other branch depending on what VCS (Version Control System) paradigm you/your team chose). First, you should make those hard-to-read commits less hard-to-read. Let’s rebase!
Please note that if you rebase after pushing to the repository, you will create problems for those pulling from that repository. Rebase changes the history of the project. Your teammates merges will not be fast-forward[able]. It won’t be pretty, trust me.

git rebase -i HEAD~[number of commits back]

You’ll now be looking at something similar to this:

pick ce86448 A random commit
pick a8564a9 Another random commit

How you order things in this editor will affect the order of the commits. Note that merge commits are not shown here. They aren’t editable.
Replacing “pick” with “edit” will allow you to edit the changes you made as well as the commit message.
After you’ve edited the files you wanted to edit, you can now

git add *

then

git commit --amend

and move on.

As I mentioned before, you have the opportunity to clean up the mess you made with all those many commits using the rebase option. Here’s how:

1. Run the

   git rebase -i HEAD~[x]

   command from earlier

2. Replace “pick” with “squash” on the commit you want to be combined with one exactly previous to it.

   pick ace72dd I squashed these commits. I'm cool.
   squash e99fd59 This commit will be sqaushed with the one above it
   pick d0770e8 commited again
   pick af845d0 I'm really committed
   

Pretty straight forward and easy. Everyone loves rebasing
If you want to know more about git-rebase, I recommend checking it out here.

Now, you’ve made all these changes and everything looks great. What are you gonna call this pretty new feature? Are you gonna tag it? I would..

git tag -a [fancy_feature] -m "A fancy message for a fancy feature"

If you happen to leave out the -m, git will open an editor and you’ll be able to add your fancy message there, just like with commit!
Read more about tags here.
One scenario for using tags could be that, within a project, one wants to keep track of versions. Each commit could be tagged with a version number like with bug fixes in some VCSs. If something goes wrong, it’s really simple to go back to a previous version using git rebase, as we’ve already shown.

You’ve squashed those ugly commits, changed the commit message(s), and tagged everything. Time to merge. Switch to the master branch (or whatever branch you’re wanting to merge with) and type this command which will merge [branchname] with the current branch:

git merge [branchname]

You’ll probably want to fix any conflicts and continue with the merge.
It’s now safe to delete [branchname] because all the changes from that branch are now on the current one.

git branch -d [branchname]

This next feature is pretty neat. Say you’ve done a bunch of changes that haven’t been committed yet and you realize you aren’t on a feature branch. Here’s what you do:

git stash
git stash branch [newbranchname]

This will stash away all uncommitted changes, create a new branch and check it out, then unstash all your stashed changes into that new branch. Awesome

Stash is also useful in scenarios where you don’t want to commit yet but you need to switch to a different branch and do something. You could stash the current changes using the above git stash command, do the needed changes, then switch back to the branch you were working on and use this command to unstash the changes:

git stash apply

It’s a good idea to check out the other things offered by git stash (git-stash)

To get this new branch into the origin repository, do:

git push origin [branchname]

To delete a branch from the origin repository, do:

git push origin :[branchname]

Don’t forget the colon!

Another scenario; your co-worker does some work on a feature and gets stuck. You don’t want to type on their computer cause yours is set up just the way you want it. Is there a solution to this quandary? Yeah. There is…
Tell them to push their changes then do this:

git fetch origin [remotebranchname]:[localbranchname]

You now have the branch they were working on locally and can modify to your hearts content.

Noteworthy Notes

There’s a difference between

git pull

and

git fetch

The difference is that “git pull” will run a “git fetch” then a “git merge” to merge the retrieved head into the current branch.

git log -p path/to/file.rb

This command will show the history of a specific file;

git blame path/to/file.rb

will go line by line in a file and give a short description + the name of the person that changed the line last (brilliant, actually)

From the Git manual

check it out
A few configuration variables (see git-config(1)) can make it easy to push both branches to your public tree. (See the section called “Setting up a public repository”.)

$ cat >> .git/config <
      [remote "mytree"]
           url =  master.kernel.org:/pub/scm/linux/kernel/git/aegl/linux-2.6.git
           push = release
           push = test
EOF

Then you can push both the test and release trees using git-push(1):

git push mytree

or push just one of the test and release branches using:

git push mytree test

or

git push mytree release

To rebase your current working tree to obtain the changes from the master tree,
Suppose that you create a branch “mywork” on a remote-tracking branch “origin”, and create some commits on top of it:

git checkout -b mywork origin
$vi file.txt
$ git commit
$ vi otherfile.txt
$ git commit

…
You have performed no merges into mywork, so it is just a simple linear sequence of patches on top of “origin”:
o–o–o <-- origin
\
o--o--o <-- mywork
Some more interesting work has been done in the upstream project, and "origin" has advanced:
o--o--O--o--o--o <-- origin
\
a--b--c <-- mywork
At this point, you could use "pull" to merge your changes back in; the result would create a new merge commit, like this:
o--o--O--o--o--o <-- origin
\ \
a--b--c--m <-- mywork
However, if you prefer to keep the history in mywork a simple series of commits without any merges, you may instead choose to use git-rebase(1):

$ git checkout mywork
$ git rebase origin

This will remove each of your commits from mywork, temporarily saving them as patches (in a directory named “.git/rebase-apply”), update mywork to point at the latest version of origin, then apply each of the saved patches to the new mywork. The result will look like:
o–o–O–o–o–o <-- origin
\
a'--b'--c' <-- mywork
In the process, it may discover conflicts. In that case it will stop and allow you to fix the conflicts; after fixing conflicts, use git add to update the index with those contents, and then, instead of running git commit, just run

$ git rebase --continue

and git will continue applying the rest of the patches.
At any point you may use the —abort option to abort this process and return mywork to the state it had before you started the rebase:

The commands
Here’s a list of all commands covered in this tutorial:

git-clone

git-checkout

git-add

git-commit

git-rebase

git-tag

git-merge

git-branch

git-stash

git-push

git-pull

git-fetch
]]>
			http://www.pmamediagroup.com/2009/06/working-with-git/feed/
		0
		
		
		
		http://www.pmamediagroup.com/2009/06/culerity-and-celerity-javascript-enabled-testing-in-cucumber/
		http://www.pmamediagroup.com/2009/06/culerity-and-celerity-javascript-enabled-testing-in-cucumber/#comments
		Mon, 08 Jun 2009 23:02:30 +0000
		fugufish
				
		
		
		
		
		
		
		
		
		
		
		
		
		

		http://www.pmamediagroup.com/?p=821
		
			As you may know, testing JavaScript inesnsive applications using Cucumber can be a pain. There are several ways to handle this; Selenium, Watir and the like. The easiest way I have found however is by using Celerity a jRuby API for htmlUnit, a fully functional headless browser that completely supports JavaScript, and you don’t have to serve your application on jRuby to use it!. I was able to get Celerity to play nice duruing Cucumber tests by doing the following:  First, you will need of course jRuby. The Culerity gem will start up Celerity in the jRuby environment, and proxy the actual browser through it. Download jRuby and extract it to wherever you want it located. In my case I put it in /opt, and set your PATH accordingly.


export PATH=$HOME/jruby/bin:$PATH

Next install the Celerity gem in jRuby (we are using the github version rather than the ruby forge version, as it provides a later version):

jruby -S gem install jarib-celerity --source=http://gems.github.com

Now install the Culerity gem. This provides the interface between Celerity and your environment without forcing you to run in jRuby

 gem install langalex-culerity --source http://gems.github.com

Place this in your test environment:

# config/environments/test.rb
 
config.gem "langalex-culerity", :lib => false

I call :lib => false here to avoid loading the gem. This is done in the file generated by culerity.  Finally remove features/steps/webrat_steps.rb as it will conflict with Culerity, and run:

script/generate culerity

Enjoy!  Culerity should have very similar syntax to webrat, however keep in mind you may see some differences that you may need to adjust.
]]>
			http://www.pmamediagroup.com/2009/06/culerity-and-celerity-javascript-enabled-testing-in-cucumber/feed/
		0
		
		
		
		http://www.pmamediagroup.com/2009/05/smarter-sequencing-in-factory-girl/
		http://www.pmamediagroup.com/2009/05/smarter-sequencing-in-factory-girl/#comments
		Fri, 29 May 2009 19:56:34 +0000
		Brett Rasmussen
				
		
		
		

		http://www.pmamediagroup.com/?p=803
		
			Hal Shearer and I monkey-patched Factory Girl’s sequencing capabilities to allow for pre-defined enumerations to loop through, instead of just infinitely incrementing numbers.

So instead of doing this:

  Factory.sequence :email do |n|
    "person#{n}@example.com"
  end

you could do something like this:

  Factory.sequence(:email, ['angela', 'brett', 'alec']) do |name|
    "#{name}@example.com"
  end

It will start over at the beginning when it’s gone through all of them:

>> Factory.next :email
=> "angela@example.com"
>> Factory.next :email
=> "brett@example.com"
>> Factory.next :email
=> "alec@example.com"
>> Factory.next :email
=> "angela@example.com"
>> Factory.next :email
=> "brett@example.com"

You can also hand it a range (the internal implementation on this is none too efficient, so don’t give it billions at a time):

Factory.sequence(:email, 50..60) do |n|
  "user_#{n}@example.com"
end
 
>> Factory.next :email
=> "user_50@example.com"
>> Factory.next :email
=> "user_51@example.com"
>> Factory.next :email
=> "user_52@example.com"

The infinitely incrementing counter is still available if you want it:

Factory.sequence(:email, %w[angela brett alec]) do |name,i|
  "#{name}_#{i}@example.com"
end
 
>> Factory.next :email
=> "angela_0@example.com"
>> Factory.next :email
=> "brett_1@example.com"
>> Factory.next :email
=> "alec_2@example.com"
>> Factory.next :email
=> "angela_3@example.com"
>> Factory.next :email
=> "brett_4@example.com"

This sort of thing is useful when you want two different factories to use the same sequence and have some overlap between the two groups.  For example, we need a bunch of email addresses to test on, many of which share the same domain:

Factory.sequence(:name, %w[angela brett alec hal debbie tracey jared]) do |name,i|
  "#{name}_#{i}"
end
 
Factory.sequence(:domain, %w[something.com example.com mydomain.com]) do |domain|
  domain
end
 
Factory.define(:email_address) do |f|
  f.address { "#{Factory.next(:name)}@#{Factory.next(:domain)}" }
end
 
>> 20.times { ea = Factory.build :email_address; puts ea.address }
angela_0@something.com
brett_1@example.com
alec_2@mydomain.com
hal_3@something.com
debbie_4@example.com
tracey_5@mydomain.com
jared_6@something.com
angela_7@example.com
brett_8@mydomain.com
alec_9@something.com
hal_10@example.com
debbie_11@mydomain.com
tracey_12@something.com
jared_13@example.com
angela_14@mydomain.com
brett_15@something.com
alec_16@example.com
hal_17@mydomain.com
debbie_18@something.com
tracey_19@example.com

For our last trick, the reset method returns both the looping index and the infinite counter back to zero:

>> Factory.reset :name
>> Factory.next :name
=> "angela_0"

Here’s the code to make it happen:

class Factory
  def self.sequence(sequence_name, enum = nil, &blk)
    @@sequences ||= {}
 
    enum = enum.to_a
 
    @@sequences[sequence_name] = {
      :enum => enum,
      :index => 0,
      :infinite_counter => 0,
      :template  => blk
    }
  end
 
  def self.next(sequence_name)
    seq = @@sequences[sequence_name]
 
    retval = case seq[:template].arity
      when 1
        seq[:template].call(seq[:enum][seq[:index]])
      when 2
        seq[:template].call(seq[:enum][seq[:index]], seq[:infinite_counter])
    end
 
    seq[:index] = (seq[:index]+1 == seq[:enum].size) ? 0 : seq[:index]+1
    seq[:infinite_counter] += 1
    @@sequences[sequence_name] = seq
    retval
  end
 
  def self.reset(sequence_name)
    @@sequences[sequence_name][:index] = 0
    @@sequences[sequence_name][:infinite_counter] = 0
  end
end

Just put that into some file–perhaps in your rails lib directory–and make sure that file gets required–probably in your rails config/environment.rb.  When doing it by hand like this, you’ll want to make sure your library file is loaded after the factory_girl gem is loaded, or you’ll get weirdness like methods you’ve overridden acting in non-overridden ways and the like; config.after_initialize in your environment.rb’s Rails::Initializer block is your friend.
You can also now use the gem BrettRasmussen-factory_girl from gems.github.com.  I mean to submit it as a patch back to the original factory_girl, which I’m sure I’ll have time to do Any Day Now.
]]>
			http://www.pmamediagroup.com/2009/05/smarter-sequencing-in-factory-girl/feed/
		2
		
		
		
		http://www.pmamediagroup.com/2009/05/ruby-benchmark-howto/
		http://www.pmamediagroup.com/2009/05/ruby-benchmark-howto/#comments
		Thu, 21 May 2009 16:09:01 +0000
		Alan Carl Mitchell
				
		
		
		
		

		http://www.pmamediagroup.com/?p=782
		
			Benchmarking with Ruby is super easy. There is already a built in class–Benchmark–that will do all of the heavy lifting for you.

If you want to do basic benchmarking, Benchmark.bm is the easiest way to go. Take a look below. Here we are going to test three ways to do looping in Ruby and see which one we like best.

require 'benchmark'
 
n = 5000000
 
Benchmark.bm do |x|
  x.report("for loop:")   { for i in 1..n; a = "1"; end }
  x.report("times:")      { n.times do   ; a = "1"; end }
  x.report("upto:")       { 1.upto(n) do ; a = "1"; end }
end

This will produce output something like this:
               user     system      total        real
for loop:  0.727000   0.000000   0.727000 (  0.727030)
times:     0.571000   0.000000   0.571000 (  0.571588)
upto:      0.523000   0.000000   0.523000 (  0.522947)

If we use Benchmark.bmbm, then it will do a ‘rehearsal’ run first in order to better equalize the garbage collection environment of the code inside the block so that hopefully we get more realistic timings.

require 'benchmark'
 
n = 5000000
 
Benchmark.bmbm do |x|
  x.report("for loop:")   { for i in 1..n; a = "1"; end }
  x.report("times:")      { n.times do   ; a = "1"; end }
  x.report("upto:")       { 1.upto(n) do ; a = "1"; end }
end

This will produce output something like this:
Rehearsal ---------------------------------------------
for loop:   0.756000   0.000000   0.756000 (  0.756298)
times:      0.477000   0.000000   0.477000 (  0.476855)
upto:       0.527000   0.000000   0.527000 (  0.526522)
------------------------------------ total: 1.760000sec

                user     system      total        real
for loop:   0.751000   0.000000   0.751000 (  0.751067)
times:      0.516000   0.000000   0.516000 (  0.515874)
upto:       0.581000   0.000000   0.581000 (  0.581254)

Alternately, you can use the Benchmark.realtime method like this:

puts "for loop: #{Benchmark.realtime {for i in 1..n ; a = "1" ; end}}"

and get something like this:
for loop: 0.682438850402832

]]>
			http://www.pmamediagroup.com/2009/05/ruby-benchmark-howto/feed/
		0
		
		
		
		http://www.pmamediagroup.com/2009/04/test-one-cucumber-feature-file-at-a-time/
		http://www.pmamediagroup.com/2009/04/test-one-cucumber-feature-file-at-a-time/#comments
		Fri, 10 Apr 2009 21:20:27 +0000
		Chris Gunnels
				
		
		
		
		

		http://www.pmamediagroup.com/?p=631
		
			To most this may sound commonplace. (definition 2).

So I was banging my head for a hour to find out how to test one feature file at a time. If you don’t know how to do this yet then you’ll want to follow along, if you do, then just read another post and make a good comment!
If this sounds like you:
“I have multiple cucumber feature files in the features folder within my app, I want to test one of those files and not all of them at once, but don’t know how.”
Then you’re in for a treat.

Its so simple you’ll laugh…all you do is type:

cucumber features/<whatever_file.feature>

instead of

cucumber features -n

Comment, Bookmark ↓ , Appreciate!
]]>
			http://www.pmamediagroup.com/2009/04/test-one-cucumber-feature-file-at-a-time/feed/
		1
		
		
		
		http://www.pmamediagroup.com/2009/04/tutorial-how-to-install-setup-cucumber/
		http://www.pmamediagroup.com/2009/04/tutorial-how-to-install-setup-cucumber/#comments
		Thu, 09 Apr 2009 17:32:17 +0000
		Alan Carl Mitchell
				
		
		
		
		

		http://www.pmamediagroup.com/?p=525
		
			This tutorial assumes that you have ruby, rails, and mysql installed on your machine, and doesn’t explain too much about Cucumber and will mostly show you a quick way to get it working. A lot of material is borrowed from this tutorial on setting up RSpec and Factory Girl. It may be useful to look over first, but not necessary.





Create the Rails Project

Go to your projects directory and create a rails project. Just for fun, let’s call it ‘bank’:
user@host:~$ cd projects

user@host:~/projects$ rails -d mysql bank

user@host:~/projects$ cd bank

user@host:~/projects/bank$
Create MySQL Databases

Go into mysql and create the two databases that rails has set up the bank project to use:
user@host:~/projects/bank$ mysql -u root -p

mysql>create database bank_development

mysql>create database bank_test

mysql>exit

Bye

user@host:~/projects/bank$
Put Gems Into Environments

Edit the files
config/environments/development.rb
and
config/environments/test.rb:
and add the following lines:

config.gem "cucumber", :version => '0.1.16'
config.gem "webrat", :version => '0.4.3'

This sets up the test and development environments to use cucumber. Since cucumber uses webrat to do the actual page navigation, we’ll need it too.
Install the Gems

Install the gems referenced in your environments:
user@host:~/projects/bank$ rake gems:install
You’ll see output that says that the gems were installed, if you didn’t have them already.
Bootstrap Cucumber

Do a:
user@host:~/projects/bank$ script/generate cucumber
You will see the following:
user@host:~/projects/bank$ script/generate cucumber

 create  features/step_definitions

 create  features/step_definitions/webrat_steps.rb

 create  features/support

 create  features/support/env.rb

 create  features/support/paths.rb

 exists  lib/tasks

 create  lib/tasks/cucumber.rake

 create  script/cucumber

user@host:~/projects/bank$
This generates some default cucumber files and directories that the project will use.
Generate Basic Files with scaffold

Do a:
user@host:~/projects/bank$ script/generate scaffold BankAccount
You will see the following output:
user@host:~/projects/bank$ script/generate scaffold BankAccount

      exists  app/models/

      exists  app/controllers/

      exists  app/helpers/

      create  app/views/bank_accounts

      exists  app/views/layouts/

      exists  test/functional/

      exists  test/unit/

      create  test/unit/helpers/

      exists  public/stylesheets/

      create  app/views/bank_accounts/index.html.erb

      create  app/views/bank_accounts/show.html.erb

      create  app/views/bank_accounts/new.html.erb

      create  app/views/bank_accounts/edit.html.erb

      create  app/views/layouts/bank_accounts.html.erb

      create  public/stylesheets/scaffold.css

      create  app/controllers/bank_accounts_controller.rb

      create  test/functional/bank_accounts_controller_test.rb

      create  app/helpers/bank_accounts_helper.rb

      create  test/unit/helpers/bank_accounts_helper_test.rb

       route  map.resources :bank_accounts

  dependency  model

      exists    app/models/

      exists    test/unit/

      exists    test/fixtures/

        skip    app/models/bank_account.rb

      create    test/unit/bank_account_test.rb

      create    test/fixtures/bank_accounts.yml

      exists    db/migrate

Another migration is already named create_bank_accounts: db/migrate/20090402160952_create_bank_accounts.rb

user@host:~/projects/bank$
If you haven’t done the tutorial on setting up RSpec and Factory Girl, then your output will look different to reflect the fact that most of the files that scaffold tried to create didn’t already exist.
Create the .feature File

Create 
features/bank_account.feature
and fill it with: 
Feature: Manage bank accounts
  In order to manage bank accounts and retain customers
  Bank Managers
  want to be able to manipulate bank accounts

  Scenario: See all bank accounts
    When I go to bank_accounts
    Then I should see "Listing bank_accounts"
Something you should know is that Cucumber will try to match each line of each scenario to a step definition. In other words, you can’t just put whatever you want in the scenario. If I put “When I go to the page bank_accounts” then that would not work because there is no step definition that matches that pattern. To see the step definitions, go to
features/step_definitions/webrat_steps.rb
and notice the line that says:

When /^I go to (.+)$/ do |page_name|
  visit path_to(page_name)
end

This is what will make my “When I go to bank_accounts” in my scenario work. If what is in my scenario doesn’t match one of the step definitions, it won’t work. You can’t just put whatever you want into the scenario unless you have made a step definition for it.
Note: If you are using Netbeans, check out this post about a plugin that will put color into your .feature files
Run Cucumber (unsuccessfully) and Then Fix

Do a:
user@host:~/projects/bank$ rake features
and you should see
user@host:~/projects/bank$ rake features

(in /home/user/projects/bank)

/usr/bin/ruby1.8 -I “/usr/lib/ruby/gems/1.8/gems/cucumber-0.1.16/lib” “/usr/lib/ruby/gems/1.8/gems/cucumber-0.1.16/bin/cucumber” –format pretty –require features/support/env.rb –require features/support/paths.rb –require features/step_definitions/webrat_steps.rb features/bank_account.feature

Feature: Manage bank accounts  # features/bank_account.feature

  In order to manage bank accounts and retain customers

  Bank Managers

  want to be able to manipulate bank accounts

  Scenario: See all bank accounts                     # features/bank_account.feature:6

    When I go to bank_accounts                          # features/step_definitions/webrat_steps.rb:6

      Can’t find mapping from “bank_accounts” to a path. (RuntimeError)

      /home/osadmin/projects/bank_account/bank/features/support/paths.rb:10:in `path_to’

      ./features/step_definitions/webrat_steps.rb:7:in `When /^I go to (.+)$/’

      features/bank_account.feature:7:in `When I go to bank_accounts’

    Then I should see “Listing bank_accounts“   # features/step_definitions/webrat_steps.rb:89

1 scenario

1 step failed

1 step skipped

rake aborted!

Command failed with status (1): [/usr/bin/ruby1.8 -I "/usr/lib/ruby/gems/1....]
(See full trace by running task with –trace)

user@host:~/projects/bank$
What this is complaining about is in the scenario when it says “When I go to bank_accounts” it doesn’t know where the bank_accounts page is. The paths are defined in the file
features/support/paths.rb
Open it up and change it to:

def path_to(page_name)
  case page_name
 
  when /the homepage/i
    root_path
  when /bank_accounts/i
    bank_accounts_path
  # Add more page name => path mappings here
 
  else
    raise "Can't find mapping from \"#{page_name}\" to a path."
  end
end

Notice that we added another path mapping for bank_accounts. It already had one for the homepage, meaning in our scenario we could have put “When I go to the homepage” and it would have worked on that line of the scenario.
Run Cucumber (successfully)

Do a:
user@host:~/projects/bank$ rake features
and you should see
user@host:~/projects/bank$ rake features

(in /home/user/projects/bank)

/usr/bin/ruby1.8 -I “/usr/lib/ruby/gems/1.8/gems/cucumber-0.1.16/lib” “/usr/lib/ruby/gems/1.8/gems/cucumber-0.1.16/bin/cucumber” –format pretty –require features/support/env.rb –require features/support/paths.rb –require features/step_definitions/webrat_steps.rb features/bank_account.feature

Feature: Manage bank accounts  # features/bank_account.feature

  In order to manage bank accounts and retain customers

  Bank Managers

  want to be able to manipulate bank accounts

  Scenario: See all bank accounts                      # features/bank_account.feature:6

    When I go to bank_accounts                           # features/step_definitions/webrat_steps.rb:6

    Then I should see “Listing bank_accounts“  # features/step_definitions/webrat_steps.rb:89

1 scenario

2 steps passed

user@host:~/projects/bank$
There, you’ve not got Cucumber working and can (hopefully) start writing other tests for it.
]]>
			http://www.pmamediagroup.com/2009/04/tutorial-how-to-install-setup-cucumber/feed/
		4
		
		
		
		http://www.pmamediagroup.com/2009/04/set-up-ruby-on-rails-and-mysql-on-mac-osx-leopard/
		http://www.pmamediagroup.com/2009/04/set-up-ruby-on-rails-and-mysql-on-mac-osx-leopard/#comments
		Tue, 07 Apr 2009 20:07:20 +0000
		Chuck Wood
				
		
		
		
		
		
		
		
		

		http://www.pmamediagroup.com/?p=480
		
			Mac OSX has become extremely popular for Ruby on Rails development. Part of this is the inclusion of Ruby as part of the operating system on Mac OSX Leopard. Here is a quick tutorial on how to get Ruby on Rails and MySQL set up on your Mac OSX Leopard machine. In order to complete this tutorial, you need the Xcode tools installed. You can get them off of the applications disk that came with your mac or from http://developer.apple.com/TOOLS/xcode/. 


Once you have Xcode Tools installed, open your terminal (in Applications > Utilities) and let’s get started!
1. Update RubyGems.

sudo gem update --system

2. Install Ruby on Rails.

sudo gem install rails

3. Download the MySQL (x86) package from this page.
4. When the .dmg file loads, install both packages (.pkg files) and the MySQL.prefPane.
5. Once MySQL is installed, install the mysql gem. (Thanks wonko.com for the tip.)

sudo env ARCHFLAGS="-arch i386" gem install mysql -- \
  --with-mysql-dir=/usr/local/mysql --with-mysql-lib=/usr/local/mysql/lib \
  --with-mysql-include=/usr/local/mysql/include


That’s it! You’re ready to go! Now all you have to do is create a rails application and you’re ready to go.
]]>
			http://www.pmamediagroup.com/2009/04/set-up-ruby-on-rails-and-mysql-on-mac-osx-leopard/feed/
		4