Prototyping Intertwingly on Rails
It is said that Rails is opinionated software. I’ve been exploring to see how it stacks up on a subject area where I have opinions: weblogging software. So far, it has measured up pretty well.
database.yml is used to configure the databases used. Now lets look at the software. I feel compelled to note that this is a work in progress, and very much incomplete. This being said, even these initial results produces something recognizable as a weblog.
URIs are definitely something I have an opinion on. I don’t cotton to the idea of putting the action in the URI as I feel that URIs are intended to uniformly identify, well, resources. I also have amassed a legacy of different URI conventions, all of which I wish to continue to support.
In Rails, when requests come in, the first thing that happens in that the request gets routed based on the URI. URIs are composed of segments separated by slashes. routes.rb enables you to name the segments, match segments against requirements you specify, and to do a first order partitioning of requests into actions. Segments at the end of URIs can be defaulted, something that is defeated by my need to access the path component at the end. This does, however, work for my archive URIs.
While I need to do additional parsing in the controller to distinguish index.html from index.atom for example, this initial partitioning is useful.
The next piece involved is blog_controller.rb, which serves as the nerve center of the weblogging application. Its first responsibility is to field all the routed actions. Each of these methods tend to be small.
Following this, I have a number of methods are specific to my
weblog, which I have chosen to mark as private, even though this is
not strictly necessary.
parse_date is a method
to convert a date — or portions thereof — into an SQL
paginate_with_path will further parse the URI
as mentioned above, and this method also serves as the branching
off point for handling post requests.
filters the query with a full text search and limits the results to
a page (of typically 10) entries.
previews and posts.
Finally, there are two small pieces of bookkeeping.
determine_layout determines the overall layout of the
results. This is useful for sites that generate mostly HTML
with a common theme. My site is borderline as has three
classes of pages with a common theme, one with a different theme,
and the rest of the responses (feeds, trackback, pingback, etc) are
not HTML so don’t need any layout at all. Ultimately, I
may simply go with a set of partial templates (described below) and
default_template_name completes the
controller by utilizing the parsed flavour to determine the
template name (as opposed to the rails tradition of using the
The controller makes use of
author.rb for persistence. Entry we have
though I have now added an indication that an entry
belongs_to an author, and unabashedly added code that
David Heinemeier Hansson refers to as “muddling the
model” by associating an entry with its resource
identification. Rails' approach of dealing with URIs as
a collection of named segments is helpful here.
Views start out with a blog.rhtml (and archive.rhtml) layouts which determine the overall look and feel of the HTML results. Like JSP, ASP, and PHP, these pages are mostly HTML with a little bit of presentational logic mixed in. While not strictly necessary, I’ve placed my sidebar into a separate partial as I tend to edit it with a different frequency than my layout.
html.rhtml contains the HTML flavor of my index page, search results , and the like. Again, this is very much like JSP, ASP, and PHP; where blog_helper.rb effectively implements the equivalent of tag libraries.
atom.rxml provides support for Atom feeds for each of these pages, and utilizes a very different approach to building xml. As my HTML pages are actually XHTML, I could productively use this approach for those pages too.
post.rhtml and preview.rhtml are two other rhtml files to support a individual post (with comments) and preview pages. Both of these make use of a the partial commentform.
Finally, archive.rhtml produces my “month at a glance” page.
entries.yml and authors.yml provide test data for entry_test.rb and author_test.rb.
Much more significant is the blog_controller_test.rb which issues mock HTTP requests against the various actions and verified the results - even to the point of parsing the resulting HTML for specific content or a given number of tags that match a specified criteria. While this test suite only covers the basics at the moment, it has already proven quite helpful in flushing out a number of bugs.
confidence builder with
'config/environment' replacing the calls to
ActiveRecord::establish_connection and the definition of the
model. Additionally, support for parsing authors and slugs
(used in muddling the model) have been added.
If you would like to try this out yourself, make sure that you have rails and libxml-parser-ruby1.8 installed, download rails.tgz and atom.tgz, and run the following commands:
rails weblog cd weblog ruby script/generate model entry ruby script/generate model author ruby script/generate controller blog tar xzf rails.tgz tar xzf atom.tgz ruby db/load.rb atom/*.atom rake ruby script/server
You should now be able to access a local copy of
reasonable facsimile of my weblog at
I still have much to explore: localization, logging, redcloth or equivalent, caching, spell checking, trackbacks, automated excerpts, Atom publishing protocol, comment throttles, etc., etc., etc.; however at this time I see nothing that will likely get in my way — to the contrary, I see quite a bit of things that I can build upon in Ruby on Rails.
And all with very few lines of code.
stats helpfully produces the following statistics:
+----------------------+-------+-------+---------+---------+-----+-------+ | Name | Lines | LOC | Classes | Methods | M/C | LOC/M | +----------------------+-------+-------+---------+---------+-----+-------+ | Helpers | 75 | 58 | 0 | 5 | 0 | 9 | | Controllers | 179 | 133 | 2 | 11 | 5 | 10 | | APIs | 0 | 0 | 0 | 0 | 0 | 0 | | Components | 0 | 0 | 0 | 0 | 0 | 0 | | Functionals | 196 | 141 | 2 | 21 | 10 | 4 | | Models | 75 | 56 | 2 | 3 | 1 | 16 | | Units | 49 | 38 | 2 | 6 | 3 | 4 | +----------------------+-------+-------+---------+---------+-----+-------+ | Total | 574 | 426 | 8 | 46 | 5 | 7 | +----------------------+-------+-------+---------+---------+-----+-------+ Code LOC: 247 Test LOC: 179 Code to Test Ratio: 1:0.7