Permalinks in Rails 3

2010-04-11T00:00:00-07:00

Permalinks in Rails 3

How To Easily Create Pretty URLs

After reading a bunch of methods for creating nice URLs in Rails:

The following is a combination of Emilien Taque’s technique and Henrik’s method. Note that url_for’s :overwrite_params was deprecated in 2.3.6.

# app/models/page.rb
class Page < ActiveRecord::Base
  
  before_save do |page|
    page.permalink ||= page.title.parameterize
  end
  
  def to_param
    [id, title.parameterize].join("-")
  end

end

# app/controllers/application_controller.rb
class ApplicationController < ActionController::Base
  protect_from_forgery
  
  protected

  def redirect_if_moved(record, param_key = :id)
    redirect_to record, :status => 301 if record.to_param != params[param_key]
  end
end

# app/controllers/pages_controller.rb
class PagesController < ApplicationController
  respond_to :html, :xml
  
  # methods ...

  def show
    @page = Page.find(params[:id])

    redirect_if_moved @page and return
    respond_with @page
  end

  # methods ...

end

Book notes – Design Patterns in Ruby

2010-04-04T00:00:00-07:00

Book notes – Design Patterns in Ruby

Chapter 2: Getting Started with Ruby
Chapter 3: Varying the Algorithm with the Template Method
Chapter 4: Replacing the Algorithm with the Strategy
Chapter 5: Keeping Up with the Times with the Observer
Chapter 6: Assembling the Whole from the Parts with the Composite
Chapter 7: Reaching into a Collection with the Iterator

Chapter 2

break – Break out of a loop.

next – Carry on to the next iteration of a loop.

Symbols – Serve as immutable strings.

Hashes – Hash index is typically a symbol because it’s not supposed to change, but it can be anything.

Class initialize method – Executed when a class is instantiated e.g., Post.new() to create a new object.

attr_writer – Creates a writer method for attributes. Replaces the need to define

def title=(string)
  @title = string
end

attr_reader – Creates a reader method for attributes. Replaces the need to define

def title
  @title
end

attr_accessor – Combines attr_reader and attr_writer. Creates reader and writer methods for attributes.

self – Return the current object. Still unclear on how and when to use class methods.

super – Calls the method of the same name in the current class’s superclass.

Modules – Set of methods to be included in another class. Cannot create and instance of a module.

Chapter 3

Template Method – Use when the process to carry out two or more tasks have overlapping functionality. Create a parent (abstract) class that contains the template (abstract) method that defines the entire process. The parent class also optionally contains default methods for each step of the process. The subclasses contain methods that overwrite the defaults defined in the parent class.

Do not start by using the template method. Write the processes individually first, identify the overlap, then break out a template if needed.

Unit Tests – Write them for each method.

Hook method – A method defined by a parent class that optionally contains default functionality. To be redefined in a subclass.

Chapter 4

Context–Strategy Method – In contrast to the Template Method, instead of calling the variations the Strategy Method passes the variations to the context method as either a class or Proc object. The context method returns either itself (as self) or parameters. The flow is

Pass the strategy to the context as an object e.g., report = Report.new(HTMLFormatter.new)
The context class’s initialize method sets instance variables for the common (context) data as well as an instance variable for the strategy
Call an output method in the context class e.g., report.output_report
The context class’s output method calls an output method on the strategy object and passes either itself or parameters
Now that the strategy has the common (context) data from the context class either as an object of the entire context class or as parameters, run the strategy.

Procs – A way to turn a piece of code into an object. Can be executed by running call on it. Parameters can be passed into call. For example:

sum = lambda {|x, y| x + y}
sum.call(10, 20)

Procs can also be appended to method calls. The output of the Proc is passed to the method using the keyword yield. Further, the method itself can pass parameters to the Proc. Ex.

def water_plant
  yield(4)
end

water_plant do |n|
  puts "Pour #{n} cups of water onto the plant's soil."
end

An alternative to calling yield is passing the Proc into the method as a parameter:

def ruby_meister(&block)
  block.call('heister')
end

ruby_meister {|s| "I'm Ruby Meister, the #{s}."}

And last but not least, instead of appending the Proc to the method call, define it, then pass it to the method. I like this best.

meister = lambda {|s| "I'm the Ruby Meister, not a #{s}."}
ruby_meister(&meister)

Zeus! There’s a lot you can do with Procs!

Chapter 5

First of all, observers – the subject of this chapter – are pretty exciting. Here’s the situation: You have an object that changes and you want to notify other objects of the change. There are several solutions for this:

1) Mix Ruby’s built-in Observer module into the class that’s going to be notifying other objects:

# The observer class
class Payroll
  def update(updated_employee)
    puts "#{updated_employee.name}'s salary is now $#{updated_employee.salary} per year."
  end
end

# The subject class – notifies the observer
require 'observer'

class Employee
  include Observable

  attr_reader :name, :title, :salary

  def initialize(name, title, salary)
    @name = name
    @title = title
    @salary = salary
  end

  def salary=(new_salary)
    @salary = new_salary
    changed
    notify_observers(self)
  end
end

fred = Employee.new('Fred', 'Crane Operator', 30000.0)
payroll = Payroll.new
fred.add_observer(payroll)

fred.salary = 35000.0

2) In place of an observer class (Payroll in the previous example), just pass a block to add_observer:

fred.add_observer do |changed_employee|
  puts("#{changed_employee.name}'s salary is now $#{updated_employee.salary} per year.")
end

3) Write a module that contains the functionality for observing:

# Custom observer module
module Subject
  def initialize
    @observers=[]
  end

  def add_observers(observer)
    @observers << observer
  end

  def delete_observer(observer)
    @observers.delete(observer)
  end

  def notify_observers
    @observers.each do |observer|
      observer.updated(self)
    end
  end
end

# Employee class includes observer functionality as a module
# The subject class – notifies the observer
require 'observer'

class Employee
  include Subject

  attr_reader :name, :title, :salary

  def initialize(name, title, salary)
    super() # This initializes the module
    @name = name
    @title = title
    @salary = salary
  end

  def salary=(new_salary)
    @salary = new_salary
    changed
    notify_observers(self)
  end
end

I’m not too excited about the third option because Ruby’s module seems lightweight and but is probably all most observer pattern need. It contains the following methods:

add_observer
changed
changed?
count_observers
delete_observer
delete_observers
notify_observers

Chapter 6

Composite Method – This method is used when a hierarchical structure is present and all the nodes have the same functionality but different content. When using the composite patter to write a program, three distinct sections of code need to be written.

Component – abstract base class. Initialize attributes, setter methods for things present in all nodes.
Composite – any node that has subcomponents. Contains logic for recursively gleaning info from its subcomponents.
Leaf – nodes at the bottom level of the hierarchy, indivisible, do not have subcomponents. Inherits from the abstract component class.

The author starts by writing the abstract base component class which defines the attributes and setters that are true for all nodes in the hierarchy.

Component Class

class WorkUnit
  attr_reader :name, :parent

  def initialize(name)
    @name = name
    @parent = nil
  end

  def get_cost_to_company_per_year
    0.0
  end
end

He then defines a few leaf classes. (The example I’m creating is pretty unrealistic because probably wouldn’t want to have a class for each employee, but you get the idea. :)

Leaf Classes

class FRSalesEmployee < WorkUnit
  def initialize
    super('Voeckler')
  end

  def get_cost_to_company_per_year
    60000.0
  end
end

class FRMarketingEmployee < WorkUnit
  def initialize
    super('Charteau')
  end

  def get_cost_to_company_per_year
    100000.0
  end
end

And finally the composite class with the redundant methods abstracted out in to a generic CompositeWorkUnit class.

Composite Class

class CompositeWorkUnit < WorkUnit
  def initialize(name)
    super(name)
    @sub_work_units = []
  end

  def add_sub_work_unit(work_unit)
    @sub_work_units << work_unit
    work_unit.parent = self
  end

  def remove_sub_work_unit(work_unit)
    @sub_work_units.delete(work_unit)
    work_unit.parent = nil
  end

  def get_cost_to_company_per_year
    cost = 0.0
    @sub_work_units.each {|work_unit| cost += work_unit.get_cost_to_company_per_year}
    cost
  end
end

class FRMarketingDivision < CompositeWorkUnit
  def initialize
    super('France Sales and Marketing Division')
    add_sub_work_unit(FRSalesEmployee.new)
    add_sub_work_unit(FRMarketingEmployee.new)
  end
end

Next we can overwrite the << and [] methods in the CompositeWorkUnit class so we can treat each composite node as an array. Here’s the updated CompositeWorkUnit class.

class CompositeWorkUnit < WorkUnit
  def initialize(name)
    super(name)
    @sub_work_units = []
  end

  # Getter and setter for values in @sub_work_units array
  def [](index)
    @sub_work_units[index]
  end

  def []=(index, new_value)
    @sub_work_units[index]
  end

  # Rename add_sub_work_unit method to overwrite the << method
  def <<(work_unit)
    @sub_work_units << work_unit
    work_unit.parent = self
  end

  def remove_sub_work_unit(work_unit)
    @sub_work_units.delete(work_unit)
    work_unit.parent = nil
  end

  def get_cost_to_company_per_year
    cost = 0.0
    @sub_work_units.each {|work_unit| cost += work_unit.get_cost_to_company_per_year}
    cost
  end
end

This seems like a pattern that’s useful for pretty specific situations where you have a tree of nodes, each of which has identical functionality to all others. If you do have that, the real benefit of using the composite pattern is being able to recursively gather information about a node and all of its children in a single place, the composite class.

Chapter 7

The Iterator – There are two types of iterators, internal and external. External iterators begin with a container object such as an array or hash, loop through and pull out the sub-objects one at a time, use some logic on each sub-object, and return information about that sub-object. It works from the outside in.

class ExternalIterator
  def initialize(aggregate)
    @aggregate = aggregate
    @index = 0
  end

  def has_next?
    @index < @aggregate.length
  end

  def item
    @aggregate[@index]
  end

  def next_item
    value = @aggregate[@index]
    @index += 1
    value
  end
end

aggregate = ['banana', 'cherry', 'pizza']

iterator = ExternalIterator.new(aggregate)
while iterator.has_next?
  puts("item: #{iterator.next_item}")
end

By contrast, internal iterators call a method on the aggregate object that can handle collections (e.g., each, each_key, each_value) and accept a block of logic to be done on each sub-object. It works by passing the logic down to each sub-object.

aggregate = ['tourmaline', 'opal', 'emerald']

aggregate.each { |stone| puts("Gemstone: #{stone}") }

One advantage of using an external iterator is you can control when the next sub-object is processed.

If you write your own internal iterator you may want to include the Enumerable mixin. Two requirements for this are:

Each of the objects to be iterated over must implement the <=> comparison operator.
The name of your internal iterator method must be each.

Enumerable gives you the methods all?, any?, collect, find, grep, include?, and many others.

class Account
  attr_accessor :name, :balance

  def initialize(name, balance)
    @name = name
    @balance = balance
  end

  # Required operator for each object if you want include Enumerable mixin
  def <=>(other)
    balance <=> other.balance
  end
end

class Portfolio
  include Enumerable

  def initialize
    @accounts = []
  end

  # Iterator method must be name each to include Enumerable mixin
  def each(&block)
    @accounts.each(&block)
  end

  def add_account(account)
    @accounts << account
  end
end

my_portfolio.include? {|account| account.name == "Google"}

Last but not least, if your collection might change while you’re iterating over it, make a copy of the collection.

copy = Array.new(aggregate)

Patrick Berkeley

Permalinks in Rails 3

Permalinks in Rails 3

How To Easily Create Pretty URLs

Book notes – Design Patterns in Ruby

Book notes – Design Patterns in Ruby

Contents

Chapter 2

Chapter 3

Chapter 4

Chapter 5

Chapter 6

Chapter 7