In my controller, I started by adding the ability to respond_to rss:

# GET /search
def search
  @models = Model.search_page params

  respond_to do |format|
    format.html
    format.rss { render :layout => false }
  end
end

Next, in my routes.rb file, I added a specific route for the dynamic search.

map.search_rss  '/search.rss',    :controller => 'models', :action => 'search', :format => 'rss'

This provided me with the method search_rss_path, which I was able to use in my view. I attempted to use the route that I already had:

map.search '/search', :controller => 'search', :action => 'search'

With something along the lines of search_path(params, :format => ‘rss’), and that ended up being a very bad thing. This was a bit ago, and I can’t recall at the moment why that wasn’t working, but I do recall that it just ended up being easier and nicer to just add one more route in my routes.rb file.

Continuing on, in my search.html.haml file, I have both a direct link and the auto_discovery link for the search generated RSS:

= link_to("RSS for this Search", search_rss_path(params))
- content_for(:extra_header) do
  = auto_discovery_link_tag(:rss, {:controller => 'models' , :action => 'search', :format => 'rss', :params => params}, {:title => 'RSS for Search Result Model Listings'})

The content_for :extra header is just an “extra header” area in my application.html.haml file:

= yield(:extra_header)

Finally, don’t forget to include the search.rss.builder file in your view folder:

xml.instruct! :xml, :version=>"1.0"

xml.rss "version" => "2.0" do

  xml.channel do

    xml.title "Search results"

    xml.link search_rss_path(params)

    xml.description("Description here")

    xml.language 'en-us'
    unless @models.empty?
      model = @models.first
      xml.lastBuildDate model.posted_at_rss
    end

    for model in @models

      xml.item do

        xml.title h(model.title)

        xml.description h(model.description)

        xml.pubDate model.posted_at_rss

        xml.author "some author"
        xml.link model_url(model)

        xml.guid model_url(model)

      end

    end

  end

end

All-in-all, it ended up being very easy to implement dynamic, search-based RSS feeds.

config.time_zone = 'Central Time (US & Canada)'

On my form, when editing the model, everything appears fine. But when you check out the difference in these two tags, you’ll see that text_field renders the incorrect time, whereas datetime_select renders the correct time.

= f.datetime_select :posted_at
= f.text_field :posted_at

I put in a defect ticket for this here. Hopefully the Rails team will be able to knock that out quick.

I had a named_scope something like this:

named_scope :not_expired, lambda { {:conditions => ["expiration_date >= ?", Time.now.utc]} }

I was calling it in a chain to another method which just called a Thinking Sphinx search:

@posts = Post.not_expired.search_page(params)

My problem came from what came back in my @posts:

Sphinx Result: [85, 44, 26]
Post Load (0.003232)   SELECT * FROM `posts` WHERE (`posts`.`id` IN (85,44,26)) AND (expiration_date >= '2008-11-14 04:15:08')

All looks fine. But then I would hit a nil object error… huh?

ActionView::TemplateError (You have a nil object when you didn't expect it!
The error occurred while evaluating nil.title) on line #5 of posts.html.haml

Loading up a script/console, I was finally able to see the problem.

>> @posts = Post.not_expired.search_page({:some=>"Param"})
=> some results....
>> @posts.size
=> 3

Somehow combining named_scope with Thinking Sphinx decided to load three posts into my @posts object even though it only found one. So I had something like this:

[< Post id: 1, title: "something">, nil, nil]

And here was my fix (after the query):

@posts = @posts.compact

This throws out the nil results.
Hopefully this will help out those out in Google land.

If I had params[:a] and params[:b], they may both be set, but I wouldn’t know it based off my GET request. So I came up with a simple check_box_tag modification to retain the state of the checkboxes based on an identifier (in my case, I use the params)

In my application_helper.rb:

  def check_box_tag_new(name, value = "1", options = {})
    html_options = { "type" => "checkbox", "name" => name, "id" => name, "value" => value }.update(options.stringify_keys)
    unless html_options["check"].nil?
      html_options["checked"] = "checked" if html_options["check"].to_i == 1
    end
    tag :input, html_options
  end

Usage in a Haml file:

= check_box_tag_new :a, 1, :check => params[:a]
= check_box_tag_new :b, 1, :check => params[:b]

Here’s what I came up with for specs:

  describe "should create a check_box tag with the proper checked based on params:" do
    it "if check is nil, it should not be checked" do
      tag = helper.check_box_tag_new("me", nil, {:check => nil})
      tag.should == "< input id=\"me\" name=\"me\" type=\"checkbox\" \/>"
    end

    it "if check is not 1, it should not be checked" do
      tag = helper.check_box_tag_new("me", nil, {:check => 0})
      tag.should == "< input check=\"0\" id=\"me\" name=\"me\" type=\"checkbox\" \/>"
    end

    it "if check is 1, it should be checked" do
      tag = helper.check_box_tag_new("me", nil, {:check => 1})
      tag.should == "< input check=\"1\" checked=\"checked\" id=\"me\" name=\"me\" type=\"checkbox\" \/>"
    end
  end

Ignore the space between < and input… Wordpress is giving me formatting issues.

If you want to just change the result set and not add to it (with will_paginate), then I suggest checking out Chris’ solution here, otherwise, read on…

Anyway, I went ahead and created a plugin for jQuery based on the wonder Rails plugin will_paginate. Introducing, jquery-bottomless-pagination.

Usage:
You should already be using the will_paginate plugin.
Then, be sure to include the javascript plugin:

= javascript_include_tag 'jquery.bottomlesspagination.js'

Here are the optional settings (displayed below are the defaults):

ajaxLoaderPath:'../images/ajax-loader.gif',
results:'.results',
objName:'',
callback:null

ajaxLoaderPath is the path to your image which will be displayed while the ajax call is being made.
results is the CSS selector that jQuery will use to append the results of the ajax call to.
objName is the name of the object that you would like displayed in the phrase “Show more (objName)…” and “There are no more (objName) to add…”
callback is a function which you can provide to perform extra functions after the objects are appended, such as adding highlight or zebra effects.

All of these settings can be utilized similarly to the following (this would be in your application.js file or something):

$.bottomlessPagination({objName:'rows', callback:function(){
  //highlight current row
  $(".results li").hover(function() {
    $(this).addClass("hover");
  }, function() {
    $(this).removeClass("hover");
  });
}});

You may need to provide something like the following for Rails.

$.ajaxSetup({
  'beforeSend': function(xhr) {
    xhr.setRequestHeader("Accept","text/javascript")}
});

On the rails side of things, in your controller, just return the partial which iterates through your returned objects:

def index
  @objects = Object.paginate :page => params[:page]
  respond_to do |format|
    format.html
    #ajax response
    format.js { render :template => 'objects/_index_objects.html.haml'}
  end
end

and the partial:

- for object in @object
  %li.result_row
    Your stuff here

That’s it. Be sure to check out the plugin in its entirety on Github. Feedback is always welcome. Enjoy!

For the sake of this tutorial I’ll be using a very basic example. Let’s start with the index that is defined for Thinking Sphinx in the model:

define_index do
  indexes city
  indexes state
end

Not too much going on here. The city will provide a textbox for the user to perform basic searches on, and the state will be drop down list, or one of many ‘filters’ in a real world app.

Onto my routes.rb file, I have defined a search path:

map.search '/search', :controller => 'search', :action => 'search'

My haml template looks like so:

%h2 Search
-form_tag search_path, :method => 'get' do
  .refine
    = label_tag :c, "city"
    %br
    = text_field_tag :c, params[:c]
  .refine
    = label_tag :st, "State"
    %br
    = select_tag "st", (options_from_collection_for_select STATE_LIST, "to_s", "to_s", params[:st])
  .refine
    = label_tag :p, "Results Per Page"
    %br
    = select_tag :p, (options_from_collection_for_select PER_PAGE_LIST, "to_s", "to_s", params[:p])
  .refine
    = submit_tag "Search", :name => nil

Nothing out of the ordinary here. For this demonstration, suppose that I have previously defined STATE_LIST and PER_PAGE_LIST to be the list of states and the numbers for results per page that I want to offer my users the ability to select from. In general your application will probably store the information for the drop downs in the database but if you just want to try something really quick, this will do the trick. The PER_PAGE_LIST is only required if you’re using the wonderful will_paginate plugin.

Anyway, onto the controller:

# GET /search
def search
  @models = Model.search_page params
  respond_to do |format|
    format.html
  end
end

Very basic search here. I’ve declared a search_page method in my model and I pass it the params. Then I simply do a respond_to.

Here is the search_page method in the model:

  def self.search_page(params)
    Model.search params[:c], :conditions => {
      :state       => params[:st]
    },
    :per_page => (params[:p].to_i unless params[:p].to_i == 0),
    :page => params[:page]
  end

I use the text field for the city as what I’m actually searching. The state gets assigned to a condition. This allows us to add several drop downs in the future as long as we know what values from which the user can select. Next, you’ll note that we assign the :per_page and :page which are used for will_paginate. If you want to give your users a very easy way to define how many results they want per page, then this is an easy way to do just that.

That’s it! You can now define several drop down select filters!

Required additional reading/watching:

• Pat Allan’s concise guide to Thinking Sphinx.
• Ryan Bate’s Railscastsepisode on Thinking Sphinx.
• Rein’s comparison of UltraSphinx and Thinking Sphinx.

If you’d rather, check out all the files on Github.

announcement.rb

class Announcement < ActiveRecord::Base
  named_scope :active, lambda { { :conditions => ['starts_at <= ? AND ends_at >= ?', Time.now.utc, Time.now.utc] } }
  named_scope :since, lambda { |hide_time| { :conditions => (hide_time ? ['updated_at > ? OR starts_at > ?', hide_time.utc, hide_time.utc] : nil) } }
  def self.current_announcements(hide_time)
    active.since(hide_time)
  end
end

application.html.haml

- unless current_announcements.empty?
  #announcements_box
    -for announcement in current_announcements
      .announcement{:id => 'announcement_' + announcement.id.to_s}
        =h announcement.message
        = link_to "Hide Announcements", hide_announcements_path, :id => 'hideAnn'

routes.rb

map.hide_announcements '/hide_announcements', :controller => 'javascripts', :action => 'hide_announcements'

Here’s the first of the important ones: javascripts_controller.rb. Note that I’m setting the session and a cookie. Also see my TODO. I’d like to set the expiration date of the cookie to the oldest expiring active announcement.

class JavascriptsController < ApplicationController
  def hide_announcements
    time = Time.now.utc
    set_session time
    set_cookies time
    respond_to do |format|
      format.html { redirect_to(root_path) }
      format.js { redirect_to(root_path) }
    end
  end

  private
    def set_session(time)
      session[:announcement_hide_time] = time
    end
    #TODO change expiration time to be the expiration
    #date from the list in current_announcements
    def set_cookies(time)
      cookies[:announcement_hide_time] = {
        :value => time.to_datetime.to_s,
        :expires => time.next_week
      }
    end
end

In the application_helper.rb, we check the session first and set the announcements, otherwise, we check the cookies.

def current_announcements
  unless session[:announcement_hide_time].nil?
    time = session[:announcement_hide_time]
  else
    time = cookies[:announcement_hide_time].to_datetime unless cookies[:announcement_hide_time].nil?
  end
  @current_announcements ||= Announcement.current_announcements(time)
end

Finally, to make it with the cool-kids, we need to add some jQuery. So I decided to use the jGrowl plugin because it’s awesome. This code goes in your application.js file (somewhere in $(function){ //here })

  //jgrowl announcements. ajax GET to hide ann/store cookie
  $.jGrowl.defaults.closer = false;
  $("#announcements_box").css("display","none");
  $("#announcements_box .announcement").each(function(){
    $.jGrowl(this.textContent,{ sticky:true, close:function(e,m,o){hide_announcements();} });
  });

  function hide_announcements(){
    $.get(
      '/hide_announcements'
    );

    $("#announcements_box").fadeOut();
    return false;
  }

Obviously, you’ll need to include jGrowl js and css files.

I like this solution because it provides a great looking way to do site-wide announcements. The solution degrades gracefully if the user does not have javascript enabled. Finally, by saving to a cookie, users can leave, close their browsers, and come back as the please and not see the same announcements over and over again.

I’d like to leave you with a couple of specs that I wrote. I attempted to do TDD/BDD and do the specs first, but it was tough. I didn’t get too far, as I was having some cookie/session problems. They’re in some serious need of help, so if you know cool stuff, help me out in the comments, thanks.
application_helper_spec.rb

  #TODO these are weak/inaccurate specs.  These are more-or-less stubs
  describe "should find the current announcements" do
    it "when the session['announcement_hide_time'] is not nil" do
      session['announcement_hide_time'] = Time.now.utc
      current_announcements.should == Announcement.current_announcements(session['announcement_hide_time'])
    end

    it "when the session['announcement_hide_time'] is nil and cookies['announcement_hide_time'] is not nil" do
      session['announcement_hide_time'] = nil
#      cookies['announcement_hide_time'] = CGI::Cookie.new('announcement_hide_time', Time.now.utc.to_datetime.to_s)
      time = Time.now.utc
      request.cookies['announcement_hide_time'] = {:value   => time.to_datetime.to_s,
                                                   :expires => time.next_week}
#      current_announcements.should == Announcement.current_announcements(cookies['announcement_hide_time'].value.first.to_datetime)
    end

    it "when the session['announcement_hide_time'] and cookies['announcement_hide_time'] are not nil" do
      session['announcement_hide_time'] = nil
      cookies['announcement_hide_time'] = nil
      current_announcements.should == Announcement.current_announcements(nil)
    end
  end

announcement_spec.rb

  #TODO these are weak/inaccurate specs.  These are more-or-less stubs
  describe "the current_announcements" do
    it "should return announcements that are active" do
      time = Time.now.utc
      Announcement.active.should == Announcement.find(:all, :conditions => ['starts_at <= ? AND ends_at >= ?', time, time])
    end

    it "should return announcements since a time provided" do
      time = Time.now.utc
      Announcement.since.should == Announcement.find(
            :all,
            :conditions => (time ? ['updated_at > ? OR starts_at > ?', time.utc, time.utc] : nil))
    end

    it "should return announcements since a time provided (nil)" do
      time = nil
      Announcement.since.should == Announcement.find(
            :all,
            :conditions => (time ? ['updated_at > ? OR starts_at > ?', time.utc, time.utc] : nil))
    end
  end

Any feedback is appreciated.

I wanted an easy way to search rspec documentation. Not wanting to work too hard, I just forked Jack Dempsey’s code (which searched the Ruby documentation) and changed it to handle rspec instead.

CmdUtils.CreateCommand(
{
name: "rspec",
takes: {"function": noun_arb_text},
icon: "http://ruby-doc.org/favicon.ico",
homepage: "http://davidwparker.com",
author: {name: "Jack Dempsey, fork by David Parker", email: "davidwparker@gmail.com"},
license: "MPL,GPL",
description: "Search rspec functions documentation",
help: "Select a rspec function",
execute: function(directObject)
{
var url = "http://apidock.com/rspec/search?query={QUERY}&commit=Search"
var urlString = url.replace("{QUERY}", directObject.text);
Utils.openUrlInBrowser(urlString);
},
preview: function(pblock, directObject)
{
searchText = jQuery.trim(directObject.text);
if(searchText.length <= 0)
{
pblock.innerHTML = "Search rspec function documentation";
return;
}
var previewTemplate = "Search rspec function documentation of ${query}";
var previewData = {query: searchText};
pblock.innerHTML = CmdUtils.renderTemplate(previewTemplate, previewData);
}
});

You can find it here on Github if you want to subscribe to it.

Edit: I also just created a decent one for searching on Colourlovers.com. You can search for colors by colors. And you can search for palettes by colors/hex. Here it is:
var cs_pa = ["colors","palettes"]
var noun_type_cs_pa = new CmdUtils.NounType( “colors or palettes”, cs_pa );
CmdUtils.CreateCommand({
name: “color”,
description: “Find colors and palettes on Colour Lover. Search by colors or search by colors or hex for palettes.”,
help: “Try issuing “color blue” or “color #005F6B” by palettes”,
icon: “http://colourlovers.com.s3.amazonaws.com/favicon.ico”,
takes: {”color or hex”: noun_arb_text},
modifiers: { “by”: noun_type_cs_pa},
execute: function( directObj, modifier) {
var value = directObj.text;
var by = modifier.by.text;
var url = “http://www.colourlovers.com/colors/search?hsv=&sortType=rank&sortBy=asc&query={QUERY}”;
if (value){
if (by){
if (by.indexOf(”palettes”) > -1){
url = url.replace(/colors/g, “palettes”);
url = url + “&hex={HEX}”;
}
}
if (value.indexOf(”#”) > -1){
value = value.replace(”#”,”");
url = url.replace(”{HEX}”, value);
url = url.replace(”{QUERY}”, “”);
}
else{
url = url.replace(”{HEX}”, “”);
url = url.replace(”{QUERY}”, value);
}
url = url.replace(”{QUERY}”, value);
}
Utils.openUrlInBrowser(url);
},
preview: function( pblock, directObj, modifier) {
var value = directObj.text;
var by = modifier.by.text;
var message = “Searches Colour Lover Colors by color and search Palettes by color/hex.”;
if (value.length > 2){
if (by){
if (by.indexOf(”palettes”) > -1){
message = message.replace(”Lover Colors”, “Lover Palettes”);
if (value) {
if (value.indexOf(”#”) > -1){
message = message.replace(”by color and search Palettes by color/hex”, “by the hex value: ” + value);
}
else{
message = message.replace(”by color and search Palettes by color/hex”, “by the color: ” + value);
}
}
}
}
else{
if (value){
if (value.indexOf(”#”) > -1){
message = “Colour Lovers cannot search Colors by hex.”;
}
else {
message = message.replace(”by color and search Palettes by color/hex”, “by the color: ” + value);
}
}
}
}
pblock.innerHTML = message;
}
});

and on here on Github

I’ve decided to not take any classes this semester. For the past three semesters I took five math classes in the thought that I would like to apply for a PhD in Economics. After really looking over my life, programs, and professions, I really just don’t think this is the route that I would like to take. So, that was that. No more classes. These past few semesters have been really busy and I really haven’t had time to work on any of my side projects. Now, I can finally play catch up.

Now it comes to which side project I should be working on… I’m huge into time management, productivity, etc. but I still find myself searching for time and wasting time. It’s a love-hate cycle and I know we all have them. So when I laid out my general interests and side projects, I began to think of which I should work first. The good news is that I don’t have to choose only one.

Anyway, so my interests include Ruby, Rails, Merb, DataMapper, jQuery, Erlang, Fuzed, Hpricot, CouchDB, Amazon EC2, etc… Hmmm, seems like all the cool kids are getting into Erlang these days.

Additionally, I’m going to use some of my free time to begin working out (regularly). I already enjoy working out, but I don’t really do it regularly. So, we’ll see how that goes. Pictures to come (ooh la la).

Wish me luck in actually getting things done ™. Hopefully, this time next year, I’ll have a wealth of knowledge of meaningless stuff, but I’ll be enjoying it full-time.

Don’t Make Me Think by Steve Krug is an excellent book. The second edition was published in 2006, which although may seem ancient by technology standards, is still quite up-to-date on everything critical for a website. Yes, I’m sure there are plenty of things in the book that I should be changing on this site, but at the moment, I rather like this theme (Hemingway). Anyway, on with the book.

First off, I really like the concept of the book. Using the web is not about thinking. It’s about lack of thought and clicking on what sparks my interest, whether I thought about it or not.

Chapter 5: Omit needless words was the first major instruction that I hadn’t heard before. In fact, I’m sure this blog post is full of needless words, but I’m sure it’s going to stay that way. But for a pure business-type/selling something website I can see how important this may be. I love the point Steve makes about removing Happy talk and Instructions must die.

Chapter 6: Street Signs and Breadcrumbs, I never thought about the total various “utility” links that I site may have and I found his list rather helpful. I’ve never driven in LA or in Boston, but I really enjoyed Steve using the street signs in those places as an example of what to do and what not to do.

Chapter 7: The Home Page is Beyond Your Control was rather informative in regards to pull-down/drop-down menus. I’ve worked on and used many applications that utilized drop-down menus and some have worked well and some haven’t. For example, I’m not too fond of the Facebook dropdown for the friends section (more), especially after reading Steve’s book:

Sorry about the crappy picture: first Ubuntu screenshot ever, no photo editing skills with GiMP /excuse

Chapter 9: Usability Testing on 10 Cents A Day was an excellent chapter as well. Over the last couple of years, I’ve really enjoyed Unit testing my code, specifically with BDD-type testing (rSpec is my current favorite in the Rails world), but I haven’t done much with usability testing. Generally, I would just go do the usability testing of “can my wife use it?” If she can, then I generally feel alright. If not, then there’s more work to be done. Anyway, I liked what Steve had to say about testing with just a few people, iteratively.

Chapter 10: Usability as a Common Courtesy introduced several things that can diminish goodwill with the customer. Specifically, a few that I really liked were:

• Punishing me for not doing things your way
• Asking me for information you don’t really need

To me, I can’t stand it when a site kicks back an error message for how I put my phone number into their textfield. Personally, I like to do XXX.XXX.XXXX. Much more common is (XXX) XXX-XXXX. Also common is XXX-XXX-XXXX. I generally use the periods and I think it’s rather amateurish when I website can’t accept any of the common formats. I’ve worked on many business applications where specific instructions were to not accept other formats. Reasoning? None other than, because I’m the boss, or because it’s too much code. It’s really not, but that’s besides the point.
Asking for too much information is another peave of mine. I especially hate when you’re signing up for a website and it’s asking for way too much… generally, for about 90% of the websites out there, all you need to ask for is username, password, and e-mail. Even then, you may only need e-mail to “confirm” the user, or to send them a reset password and it may not be required at all. This was all restated in Chapter 12: Help! My boss wants me to ____.

Overall, I thought the book was excellent and I’d highly recommend to anyone doing anything on the web. Building straight html? E-commerce sites? Business intranets? Social networking sites? Something else? No matter what it is, reading this book will help you to understand the usability a little bit better.