The word public/ is perfectly descriptive, and acts as a cognitive warning when serving content. Anything in the public/ directory is free and open for users to download.

It’s a great idea to use this same idea in PHP applications. PHP should interpret files with certain file extensions (such as files ending in .php), but mistakes happen. When you name the web accessible directory of your applications public/, it is immediately obvious as to the accessibility of the content. This raises a red flag when you’re uploading sensitive documents or information into a publicly accessible directory.

Most of the PHP frameworks follow this idea, and keep their application logic in a directory that is not publicly accessible from the web.

When you’re starting out with Ruby and Rails, often times you’ll know how to do something in PHP and need a way to map that knowledge into the Ruby world. For example, you might ask yourself, “What’s the equivalent of fopen in Ruby?”

Now, you can get the answer just like you would on php.net — http://railsforphp.com/fopen

You can also enter a PHP function name into the search box at the top of every page. If we have a reference page for that function, you’ll be taken directly there.

PHP and Ruby are great complementary tools. You might find that you like Ruby for other tasks like command line scripts. With this in mind, our reference differentiates between Ruby and Rails. Solutions that only work in Rails, such as the one for http_build_query, are clearly marked as such.

To start out, we’ve seeded the reference with many of the more common functions for working with strings, regular expressions, and the filesystem. In the coming weeks, we’ll continue to expand it.

Like most utility functions, generating these hashes is not part of the core Ruby objects. Instead, the Ruby Standard Library includes the Digest library. Let’s take a look at the equivalents to PHP’s common cryptographic hash functions in the Ruby universe.

Comparing Functions/Methods

md5 vs. Digest::MD5

In PHP, we use the md5 function to calculate an MD5 hash. In Ruby, we use Digest::MD5.

PHP

print md5("my string");
// => 2ba81a47c5512d9e23c435c1f29373cb

Ruby

require "digest"
 
print Digest::MD5.hexdigest("my string")
# => 2ba81a47c5512d9e23c435c1f29373cb

Above, we first required the Digest library using require "digest". This is similar to using require_once to include a class in PHP. To get the equivalent of the hash we’d generate using md5(), we use the hexdigest method.

md5_file vs. Digest::MD5

There are generally two different ways in Ruby to generate a cryptographic hash of a file. The first and easiest way is to use File.read to read the entire file contents into memory. We can then use the same MD5.hexdigest method on the contents to generate the hash.

PHP

print md5_file("my_file.jpg");
// => 14b6a00b1a4eb40542cfecdc4d64940d

Ruby

require "digest"
 
print Digest::MD5.hexdigest(File.read("my_file.jpg"))
# => 14b6a00b1a4eb40542cfecdc4d64940d

The code above works for many cases but for larger files, there’s a risk of consuming large amounts of memory. For these cases, we can initialize a new digest with Digest::MD5.new and then read the file in smaller chunks, incrementally building the digest with MD5#update.

Ruby

require "digest"
 
digest = Digest::MD5.new
File.open("my_file.jpg", "r") do |f|
  digest.update f.read(8192) until f.eof
end
 
print digest.hexdigest
# => 14b6a00b1a4eb40542cfecdc4d64940d

sha1 vs. Digest::SHA1

We use the Digest::SHA1 class to build the equivalent cryptographic hash to PHP’s sha1 function. This works the same as the Digest::MD5 class mentioned above, and needs to require the Digest library using require "digest".

PHP

print sha1("my string");
// => e19343e6c6c76f8f634a685eba7c0880648b1389

Ruby

require "digest"
 
print Digest::SHA1.hexdigest("my string")
# => e19343e6c6c76f8f634a685eba7c0880648b1389

sha1_file vs. Digest::SHA1

Just like with MD5, we can generate the SHA1 hash of a file in a couple different ways. We can generate the hash of the entire entire file with File.read

PHP

print sha1_file("my_file.jpg");
// => 5de1a26c24b0d176c6cafd11bf1f03017bcc767b

Ruby

require "digest"
 
print Digest::SHA1.hexdigest(File.read("my_file.jpg"))
# => 5de1a26c24b0d176c6cafd11bf1f03017bcc767b

We can take the same chunked approach we used for MD5 to generate a hash for larger files.

Ruby

require "digest"
 
digest = Digest::SHA1.new
File.open("my_file.jpg", "r") do |f|
  digest.update f.read(8192) until f.eof
end
 
print digest.hexdigest
# => 5de1a26c24b0d176c6cafd11bf1f03017bcc767b

crypt vs. String#crypt

Finally we have PHP’s crypt function, which returns an encrypted string using a standard Unix DES-based encryption or an alternate based on the system. This operation has very similar usage in PHP and Ruby. Ruby uses the String#crypt method with a single salt parameter to get the same result.

PHP

print crypt("my string", "salt");
// => saGMxKJ.nmUhU

Ruby

print "my string".crypt("salt")
# => saGMxKJ.nmUhU

In this example, we have an array of fruit. We want to iterate through the array and print the name of each fruit. At the end, we want to print the name of the last fruit again.

PHP

$fruit = array('apple', 'banana', 'orange');
foreach ($fruit as $f) { print "$f, "; }
 
print $f;

As you probably expected, here’s the output of the above program:

apple, banana, orange, orange

This works because PHP has simple scoping rules. Within a function, any variables that get defined are available any time later in the function. Variables defined before constructs like foreach() and while() are available inside those constructs. Variables defined inside those constructs are defined in the same scope and are available outside of those constructs, like $f above.

When you first start writing programs in Ruby, you’ll probably start out by converting bits of your PHP programs over before you get into the swing.

With that in mind, let’s now try directly converting our PHP program to Ruby:

Ruby

fruit = %w[apple banana orange]
fruit.each { |f| print "#{f}, " }
 
print f

If you’re wondering about the %w, that’s a word array (see Useful Perlisms in Ruby for this and other tricks). Otherwise, this looks very similar to the PHP version.

However, you might find the results to be unexpected:

apple, banana, orange, 
NameError: undefined local variable or method 'f'

In Ruby, scoping is lexical. There can be many levels of scope and scope can even be manipulated. When a block is called in Ruby, it is bound to the scope of its caller. This means that within the same method, variables defined above the block are available inside the block. However, variables defined within the block are not normally available outside the block. In the example above, Ruby raised a NameError because f was only defined within the block, not above it.

If you really needed to do the example in Ruby, you could define a variable above the block to store the last value through the iteration.

Ruby

fruit = %w[apple banana orange]
last_fruit = nil
 
fruit.each do |f| 
  print "#{f}, " 
  last_fruit = f
end
 
print last_fruit

Since the last_fruit variable is defined above the block, it is available both inside and below the block. The program now works as you might expect.

While that helps us begin to understand Ruby’s scoping and gets the job done, a much simpler and more idiomatic Ruby solution for this particular problem would be this:

Ruby

fruit = %w[apple banana orange]
fruit.each { |f| print "#{f}, " }
 
print fruit.last

The Array#last method is the equivalent of PHP’s end(). By just using it instead, our code is both more concise and readable.

An an example, we can specify a variable number of attributes when we perform model validation. Take a look at how we validate the presence of both the name and age attributes for a model along with a custom error message as the final argument.

Ruby

class User < ActiveRecord::Base
  validates_presence_of :name, :age, :message => "Can't be empty!"
end

We also see this pattern used in various built-in view helper methods. When we want to include multiple stylesheets in our application, we can specify multiple sources using stylesheet_link_tag.

Ruby

<head>
  <%= stylesheet_link_tag :layout, :colors, :media => "screen" %>
</head>

Using variable arguments is often more convenient than calling a function multiple times, and it is a little nicer than passing an array. This trick can be adapted to PHP development pretty easily. The above example looks quite different from PHP when using the common Ruby style.

However, it does map faithfully to PHP if we add back the syntactic noise that we purposely left out. We also talk about this transliteration in the Beginning Ruby Code chapter of the book.

Ruby

<%= stylesheet_link_tag(:layout, :color, {:media => "screen"}) %>

PHP

<?= stylesheetLinkTag('layout', 'color', array('media' => 'screen')) ?>

In PHP we implement variable arguments using using the func_get_args() function:

PHP

function stylesheetLinkTag($sources)
{
    $sources = func_get_args();
 
    foreach ($sources as $source) {
      // ...
    }
}

Since the $sources come from func_get_args(), no arguments in the function definition are necessary. However, if the function definition has no arguments, PHP will not raise a notice if the function is called with no arguments. Since our function requires at least one argument, it’s useful to have it in the function definition for that reason. It will also get picked up by code documentation tools.

Let’s not forget about the optional list of options that we pass in as the final argument. We can extract this data in our PHP function implementation by simply checking if the last value of the variable arguments is an array.

PHP

function stylesheetLinkTag($sources)
{
  $sources = func_get_args();
  $last    = end($sources);
  $options = is_array($last) ? array_pop($sources) : array();
 
  // find the stylesheet media attribute
  $media = isset($options['media']) ? $options['media'] : '';
 
  foreach ($sources as $source) {
    // ...
  }
}

Ruby uses Perl-compatible regular expressions, so if you’re familiar with the preg_* functions in PHP, you’re already well on your way to learning regular expressions in Ruby. Regular expressions are a complex topic, so we won’t be covering regular expression basics, but will instead focus on translating existing knowledge of Perl-compatible PHP functions to Ruby.

Regular Expressions in Ruby

We use regular expression patterns in PHP by passing a string argument to various functions. Ruby treats regular expressions differently. Instead of specifying the pattern within a string, they are objects just like everything else in Ruby.

PHP

$myRegexp = '/[a-z0-9]+\s/mi';
print gettype($myRegexp); 
// => string

Ruby

my_regexp = /[a-z0-9]+\s/mi
p my_regexp.class
# => Regexp

We can create regular expressions in Ruby using two different literal syntaxes.
The most common is by enclosing the pattern in forward-slashes, but we can also use an alternate %r{} syntax. We usually use %r{} when the pattern contains a lot of forward-slashes (such as a filepath). Regular expressions can also be explicitly instantiated using the Regexp class.

Ruby

/[a-z0-9]+\s/mi
%r{/path/to/gif\.gif}mi
Regexp.new("[a-z0-9]+\s", Regexp::IGNORECASE | Regexp::MULTILINE)

Comparing Functions/Methods

Now that we’ve seen some basic syntax for regular expression objects in Ruby, let’s take a look at PHP’s PCRE functions, and their closest equivalents in Ruby.

preg_match vs. String#match

We match a pattern in Ruby strings using the match method. Ruby’s match method works differently than preg_match in how it returns matches. We usually want to know two different things when we match data: If the pattern matched, and what specific strings sections were matched.

PHP returns an integer to tell us if the data matched (either 0 or 1) and populates a matches array by reference. Ruby returns a MatchData object when the pattern matches, and nil when something doesn’t. We can inspect the MatchData object to find the actual string matches.

In this example, we try to match the different components of a list of email addresses. Both preg_match and String#match only match the first occurrence of the pattern.

PHP

$string = 'joe@example.com; walter@example.org';
$result = preg_match('/([a-z0-9_.-]+)@([a-z0-9-]+)\.([a-z.]+)/i', 
          $string, $matches);
var_export($result); 
// => 1
 
var_export($matches); 
// => array('joe@example.com', 'joe', 'example', 'com')

Ruby

string = 'joe@example.com; walter@example.org'
matches = string.match(/([a-z0-9_.-]+)@([a-z0-9-]+)\.([a-z.]+)/i)
p !matches.nil?
# => true
 
p matches
# => #<MatchData:0x1ed138>
 
p matches[1]
# => "joe"
 
p matches.to_a
# ["joe@example.com", "joe", "example", "com"]

preg_match_all vs. String#scan

PHP returns an integer with the number of matches for preg_match_all and populates a matches array by reference. Ruby performs multiple matches for a string using the scan method. This method returns a nested array of matches or an empty array when no matches are found. Be aware that the nesting of values in this array is different than how preg_match_all orders matches.

In this example, we match components of the email address, and both preg_match_all and String#scan give us an array of matches that are found.

PHP

$string = 'joe@example.com; walter@example.org';
$result = preg_match_all('/([a-z0-9_.-]+)@([a-z0-9-]+)\.[a-z.]+/i', 
          $string, $matches);
var_export($result);
// => 2
 
var_export($matches);
// => array(array('joe@example.com', 'walter@example.org'),
//          array('joe',             'walter'),
//          array('example',         'example'),

Ruby

string = 'joe@example.com; walter@example.org'
result = string.scan(/([a-z0-9_.-]+)@([a-z0-9-]+)\.[a-z.]+/i)
p result.size
# => 2
 
p result
# => [["joe", "example"], ["walter", "example"]]

preg_replace vs. String#gsub

We perform pattern based substitution in Ruby using gsub, which is equivalent to PHP’s preg_replace function. A notable difference is that the gsub method is also used for string substitution in Ruby. We do this by simply providing a string instead of the regular expression pattern. This would be like using the str_replace function in PHP.

In this example, we want to replace the domain in all emails with foo.

PHP

$string = 'joe@example.com; walter@example.org';
$result = preg_replace('/@([a-z0-9-]+)/', '@foo', $string);
 
var_export($result);
// => 'joe@foo.com; walter@foo.org'

Ruby

string = 'joe@example.com; walter@example.org'
result = string.gsub(/@([a-z0-9-]+)/, '@foo')
 
p result
# => "joe@foo.com; walter@foo.org"

We can use backreferences in our gsub replacements just as we would with preg_replace by using \1, \2, etc in our replacement string.

In this example, we prefix the existing domain with mail.. Remember to escape backslashes used for the backreference.

PHP

// Replace domain with mail.domain
$string = 'joe@example.com; walter@example.org';
$result = preg_replace('/@([a-z0-9-]+)/', '@mail.\\1', $string);
 
var_export($result);
// => 'joe@mail.example.com; walter@mail.example.org'

Ruby

string = 'joe@example.com; walter@example.org'
result = string.gsub(/@([a-z0-9-]+)/, '@mail.\\1')
 
p result
# => "joe@mail.example.com; walter@mail.example.org"

preg_split vs. String#split

We split strings by a pattern in Ruby using the split method. This is pretty much the same as the preg_split function in PHP. As with gsub, we can also use this same method to split using a string instead of a regular expression. This means that split also performs the equivalent of the explode function in PHP.

In this example, we create an array of the list of emails by splitting the string using the semi-colon and space as the delimiter.

PHP

  $string = 'joe@example.com; walter@example.org';
  $result = preg_split('/;\s?/', $string);
 
  var_export($result);
  // array('joe@example.com', 'walter@example.org')

Ruby

  string = 'joe@example.com; walter@example.org'
  result = string.split(/;\s?/)
 
  p result
  # => ["joe@example.com", "walter@example.org"]

preg_grep vs. Array#grep

The preg_grep function in PHP is a useful function to find entries in an array that match a given pattern. Ruby does this same operation with the grep method.

In this example, we’ll build a new array that only consists of email addresses that end in .com.

PHP

$myArray = array('joe@example.com', 'walter@example.org');
$result = preg_grep('/\.com$/', $myArray);
 
var_export($result);
// => array('joe@example.com')

Ruby

my_array = ['joe@example.com', 'walter@example.org']
result = my_array.grep(/\.com$/)
 
p result
# => ["joe@example.com"]

preg_quote vs. Regexp.quote

When we use a string as a regular expression, we want to escape the characters that could be interpreted as regexp special characters. PHP does this using preg_quote, and Ruby has an equivalent Regexp.escape method.

In this example, we’ll escape any regular expression special character in the given string.

PHP

$string = '[my_file.gif]';
$result = preg_quote($string);
 
var_export($result);
// => '\\[my_file\\.gif\\]'

Ruby

string = '[my_file.gif]'
result = Regexp.escape(string)
 
p result
# => "\\[my_file\\.gif\\]"

Regular Expressions in Rails

Rails uses regular expressions in various places to specify patterns. When we are matching a route in Rails, we can use them to assign a requirement that a route component must match:

Ruby

ActionController::Routing::Routes.draw do |map|
  map.connect 'teams/:team_id/players/:action/:id, :team_id => /\d+/
end

We can also use regular expressions in our models when we validate the format of data. We pass a regexp to the :with option of validates_format_of:

Ruby

class Image < ActiveRecord::Base
  validates_format_of :url, :with => /\.(gif|jpg)/i, 
                      :message => "must be a GIF or JPG" 
end

When we are testing controller code, the assert_select method will accept a regular expression to match response data according to the given pattern.

Ruby

class HomepageControllerTest < ActionController::TestCase
  def test_greeting
    get :index
    assert_select 'div.greeting', /Welcome [a-z0-9-_]+/
  end
end

However, while PHP is convenient for us as developers, it’s often inconvenient for others. For example, we often leave the task of deploying and configuring our applications with system administrators. For those sysadmins without PHP knowledge, it’s easy to become frustrated by a missing quote, parenthesis, or semicolon in a PHP file.

Introducing YAML

Besides PHP itself, the most popular config file formats for PHP applications are INI and XML files. More people understand these formats, but these have problems of their own. The INI format is easy-to-use but not great at representing hierarchical data. XML improves on hierarchical data but is not nearly as easy-to-use as INI.

YAML is a relatively new format that has been pioneered by the Ruby and Rails communities. It blends the best aspects of XML and INI, giving us a format with the flexibility of XML and the ease-of-use of INI.

Here’s what a snippet of YAML looks like:

development:
  adapter:  mysql
  socket:   /tmp/mysql.sock
  encoding: utf8
  database: newsletter_development
  username: the-username
  password: the-password

The YAML site has a more complex example showing what’s possible.

All Rails applications use the same config/database.yml file to configure the database connection. The snippet above was taken from Chapter 1 in the book, where we developed a simple newsletter application using Rails.

Let’s explore Ruby’s built-in YAML support and then look at it from a PHP perspective.

Ruby’s YAML Support

One of the strengths of Rails is that it is built on a foundation of solid Ruby tools. Rails got the ability to read YAML files for free because YAML support is bundled with Ruby. Fire up IRB and try it yourself:

Ruby

irb> require "yaml"
=> true
irb> h = YAML.load("foo: bar\nbaz: qux")
=> {"foo"=>"bar", "baz"=>"qux"}
irb> h["foo"]
=> "bar"

Above, we put a YAML document into a string. The YAML.load method then parses it into a Ruby hash, which is simple to use.

If you have a Rails application handy, such as the newsletter or user group apps from the book, change to the application’s base directory and try this from IRB:

Ruby

irb> require "yaml"
=> true
irb> h = YAML.load_file("config/database.yml")
=> {"development"=>{"adapter"=>"mysql", "encoding"=>"utf8" ... }
irb> h['development']['database']
=> "newsletter_development"

You can see it’s relatively painless for Rails to read the config/database.yml file just with the YAML support included with Ruby.

PHP and YAML

PHP 5 includes built-in support for reading many different formats including INI, XML, and JSON. Unfortunately, YAML support is not yet bundled with PHP like it is with Ruby.

A few different solutions have appeared to fill this gap. One is Spyc, a pure-PHP library originally for PHP 4 that now includes a PHP 5 version. Another is pecl/syck, a fast PHP extension that provides bindings to the Syck library written in C.

Perhaps the best at this time is Horde/Yaml. This library is PHP 5 E_STRICT complaint, uses the familiar PEAR coding standards, and is based on Spyc. Horde/Yaml includes a number of bug fixes, cleanup, and will transparently use pecl/syck if it is available.

Now, we’ll do the same exercises from above but with PHP and Horde/Yaml.

Installing Horde/Yaml

The Horde/Yaml library is distributed as a PEAR package, the analog of RubyGems.

To install it, run these commands from your shell. If you’re on a Unix-like machine, you will probably have to add sudo before these commands.

shell> pear channel-discover pear.horde.org
shell> pear install horde/yaml

If installation is successful, you should see install ok.

Using Horde/Yaml

Horde/Yaml, like many newer PHP 5 libraries, does not explicitly use require to load its files. Instead, it uses autoloading. If you’re unfamiliar with this or don’t yet have an autoloader set up, adding something like this to the top of your script will get it working:

Ruby

function sample_autoloader($class) {
    require str_replace('_', '/', $class) . '.php';
}
spl_autoload_register('sample_autoloader');

With that out of the way, Horde/Yaml is ready to go.

Let’s look at the equivalent of the first Ruby example, where a string containing YAML is loaded into a PHP associative array:

Ruby

$a = Horde_Yaml::load("foo: bar\nbaz: qux");
 
var_export($a);

The Horde_Yaml::load() method parses YAML into a variable, just like its Ruby counterpart. The output of var_export() is:

array (
  'foo' => 'bar',
  'baz' => 'qux',
)

Horde/Yaml can also read from a file with loadFile() or an open stream with loadStream().

That’s all you need to start reading YAML in PHP.

Notes

Be careful in your PHP applications that sensitive YAML files are not web-accessible. Keep them outside of the document root or use an .htaccess file if that’s not an option. If you don’t, your web server will give them to anyone who requests.

This article focuses on reading YAML, but both Horde/Yaml and Ruby’s built-in YAML support can dump data structures into YAML. Just pass a hash (associative array) to the dump() method of either to get the equivalent YAML string.

Ruby has quite a few interesting syntax features, some inspired by Perl and some not, that are sometimes lumped together as the “Perlisms” in Ruby. Let’s explore a few of the more useful ones you’ll likely encounter in Rails applications.

Word Arrays

Most of us need arrays all the time in our applications.

PHP

$days = array('Mon', 'Tue', 'Wed', 'Thu', 'Fri');

We learned early in the book that Ruby has a very convenient syntax for arrays:

Ruby

days = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri']

However, if your array elements are words (no spaces), you can do one better.

Ruby

days = %w[Mon Tue Wed Thu Fri]

The %w array modifier allows you to write more readable arrays of words by omitting the noise of the quotes and commas.

Regular Expression Matches

In PHP, regular expressions are written inside strings. These strings are passed to functions like preg_match() that perform the matching:

PHP

$text = 'You have 12 new messages';
 
if (preg_match('/(\d+) new/', $text, $matches)) {
  print "Found {$matches[1]} messages";
}

Ruby’s regular expressions aren’t written inside strings because they have a native syntax supported by the language. We can write the above example as:

Ruby

text = 'You have 12 new messages'
 
if matches = /(\d+) new/.match(text)
  puts "Found #{matches[1]} messages"
end

Since /(\d+) new/ is itself an object, we can call the match method on it. The snippet otherwise looks similar to the PHP version.

However, there’s another way:

Ruby

text = 'You have 12 new messages'
 
puts "Found #{$1} messages" if text =~ /(\d+) new/

You can use the =~ operator to test if a regexp matches and !~ to test if it doesn’t. Also, Ruby automatically assigns the regexp matches to special variables. $1 is the first match, $2 is the second match, and so on.

Finally, we reversed the conditional to shorten the snippet a bit.

Grouping Thousands

Have you ever needed a fairly large numeric literal?

Ruby

$bytes = 1048576;

You might appreciate that Ruby allows you to use underscores in numbers.

Ruby

bytes = 1_048_576   # Ruby's Grouping
 
bytes = 1.megabyte  # Rails' ActiveSupport

You can use the underscore to group thousands or whatever you like, and Ruby will just filter it out. For common numbers like byte multiples, Rails takes it to another level of readability with special methods like megabyte shown above.

Parting Thoughts

There’s quite a few other so-called Perlisms in Ruby. Some are great, and some aren’t so great. For example, you can access Ruby’s load path (analogous to PHP’s include_path) with the readable $LOAD_PATH variable or the cryptic $: variable. This post from Nick Seiger has some really obscure features of Ruby.

Ruby’s language design makes programming very convenient, but it’s power is that its allows us to write intuitive programs that often read like natural language. When you abuse the syntax features, you only make code harder to read.

Experienced PHP developers learn that there are some aspects of the PHP language, deprecated or not, that you might want to avoid for cleaner code. This is sometimes true of Ruby also, as with most programming languages.

While the features demonstrated above are useful and popular, some features of Ruby aren’t popular in the Rails community at all. Most of the pre-defined variables that aren’t words fall into this category. In general, Rails developers always strive to write programs that are easier to understand and maintain.

Becoming an effective Rails developer is not only learning the features of the Ruby language, but developing a sense of good taste for how to use those features.

Accessing Attributes

We can directly assign and access public data members in PHP, but Ruby objects have no public data members. We can simulate a similar behavior in Ruby using the attr_accessor method.

PHP

class Book
{
    public $author;
}
 
$book = new Book;
$book->author = 'jim';
print $book->author;
// => jim

Ruby

class Book
  attr_accessor :author
end
 
book = Book.new
book.author = 'jim'
print book.author
# => jim

While it appears that Ruby is using a public attribute, this is simply because parentheses are optional in Ruby. We can call the same methods like this:

Ruby

book.author=('jim')
print book.author()

Taking a look at the class definition, one might infer that Ruby’s attr_accessor class method is creating a public attribute. It is actually doing something quite different. When we invoke this method, we dynamically create the author() and author=() instance methods which access and assign the @author instance variable in our object. This gives us some flexibility to change the implementation of these methods later on if we choose.

The Problem with Public

Imagine we want our class to capitalize the author name when we assign it. In Ruby, we could implement this pretty easily without breaking the existing API. We can explicitly define the accessor method ourselves.

Ruby

class Book
  attr_accessor :author
 
  def author=(author)
    @author = author.capitalize
  end
end
 
book = Book.new
book.author = 'jim'
print book.author
# => Jim

If we were to try and do the same thing in PHP with public data members, we immediately see a problem. We can’t change the implementation of author assignment. We are assigning the value directly, and have no encapsulation within the object.

Getter and Setters

There is a point where you basically give up on public attributes for all but the most basic data structures. They’re just too inflexible, with the preferred alternative being protected or private members with getter and setter methods:

PHP

class Book
{
    protected $_author;
 
    public function setAuthor($author) 
    {
        $this->_author = ucfirst($author);
    }
 
    public function getAuthor()
    {
        return $this->_author;
    }
}
 
$book = new Book;
$book->setAuthor('jim');
print $book->getAuthor();
// => Jim

This class definition accomplishes the same thing as the above Ruby class definition. By using methods to access the author, we can easily abstract any details within our class without any need to change the class API in the future.

Better Access using Magic

The PHP example is a bit more verbose than the Ruby, and would become even more so for each attribute that we add. Using Ruby as an example, we can actually come up with a reasonably elegant solution to the repetitive getter/setter methods using PHP’s __get and __set magic methods. Let’s say that we also want a title and page count for our class. The Ruby definition would look like this:

Ruby

class Book
  attr_accessor :author, :title, :pages
 
  def author=(author)
    @author = author.capitalize
  end
end
 
book = Book.new
book.author = 'jim'
book.title  = 'Wandering in the Desert'
 
print "#{book.author} : #{book.title}"
# => Jim : Wandering in the Desert

Wouldn’t it be nice if if we could do something like this in PHP?

PHP

class Book extends AttrObject
{
    protected $_author;
    protected $_title;
    protected $_pages;
 
    public function __construct()
    {
        $this->attrAccessor('author', 'title', 'pages');
    }
 
    public function setAuthor($author)
    {
        $this->_author = ucfirst($author);
    }
}
 
$book = new Book;
$book->author = 'jim';
$book->title  = 'Wandering in the Desert'
 
print "$book->author : $book->title";
// => Jim : Wandering in the Desert

This syntax simplifies our class by eliminating redundant getter and setter methods. The custom AttrObject class defines three methods. The attrAccessor() method creates an attribute on the instance that can be both read and written. Two other variations exist: attrReader() creates attributes that can only be read, and attrWriter() creates attributes that can only be written.

Overriding Attributes

While it may appear that we’re calling public attributes, these attributes remain protected. AttrObject works by using the missing property handlers __get() and __set(). When one of our attributes is accessed, it first scans for a method like getAuthor() or setAuthor() on the object. If not found, it looks for a protected property like $_author. If that is also not found, it searches for a method called _get() or _set(). Finally, an error is found if nothing is available to satisfy the conditions.

You can download the class source code here:
attr-code.tgz for Unix
attr-code.zip for Windows

The advantages of the example are clear when the implementation of these attributes need to change. The attributes promote encapsulation by allowing the implementation to change while the interface remains the same.

The biggest change is that the beta now includes the rest of the chapters for Part 1, “From PHP to Rails”. These include many new pages from “Beginning Ruby Code” to “Embracing the Ruby Philosophy”.

We’ve also been tracking the changes in the Rails 2.0 pre-release closely. You’ll find we’ve made many adjustments to the book for new features and changes in Rails.

You might also notice that we’ve made many other small corrections and additions since the first beta. Thanks for all of your praise and the tremendous amount of great feedback you’ve sent!