jamesgolick

[Ruby] On Password update code

2008-07-17T13:15:00-07:00

Managing flow with exceptions sucks. Exceptions are heavy, both from a readability point of view, and from a performance point of view. They should be reserved for unexpected situations, and ones that you want to allow to bubble up the stack and catch later.

What if we used validations to handle the problem? It sure simplifies things.

## dj.rb

class Dj < ActiveRecord::Base
  attr_accessor :old_password
  
  validates_length_of         :password,    :minimum => 1
  validates_confirmation_of   :password
  validate_on_update          :validate_old_password

  def reset_password(attrs)
    # I could see plucking out a few specific attributes to update, here, but no matter, if validations are complete
    update_attributes attrs
  end
  
  protected
    def validate_old_password
      errors.add(:old_password, 'does not match') if password_changed? && !authenticated?(old_password)
    end
end

## accounts_controller.rb
class AccountsController < ApplicationController

  layout 'application'
  before_filter :login_required, :except => :show

  # Change password action  
  def update
    if current_dj.reset_password(params[:dj])
      flash[:notice] = "Password successfully updated."
      redirect_to dj_path(current_dj.login) #profile_url(current_dj.login)
    else
      # I don't know if we need this error message anymore, since the validations will take care of it
      flash[:error] = "An error occured, your password was not changed."
      render :action => 'edit'
    end
  end
end

[Ruby] On Template Method

2008-07-01T14:30:30-07:00

Maybe I'm missing what you're trying to do. But, why not just use built-in ERB?

ERB.new(File.read(path_to_template)).result(binding)

[Ruby] On if else if else

2008-06-20T01:08:13-07:00

I prefer how this reads (with the explanation of the helper in the model)

## user.rb

def carrier?
  carrier_id != 0
end

## original submission

@email     = logged_in? ? current_user.email     : ""
@mobile_no = logged_in? ? current_user.mobile_no : ""
@carrier   = logged_in? && current_user.carrier? ? current_user.carrier.name : ""

[JavaScript] On Anti-spam Mailto

2008-01-08T04:34:08-08:00

document.write really sucks. This will work with prototype.js, but should be portable to any other js lib, or raw javascript (but why would you do that?).

Just pass in the id of the element you want updated, and this thing will do it (disclaimer: completely untested :)).

function showEMail(element)
{
   var e = { name: 'myemail',
             domain: 'somedomain',
             extension: 'com' };
   var address = [e.name, '@', e.domain, e.extension].join('');
   $(element).update('<a href="mailto:'+address'">'+address+'</a>');
}

[Ruby] On Challenge: Ugliest Ruby FizzBuzz

2007-12-20T23:55:52-08:00

oh my... I'd like to see somebody beat that.

[Ruby] Challenge: Ugliest Ruby FizzBuzz

2007-12-20T21:54:34-08:00

So, after seeing some ugly fizzbuzzes, instead of trying to create the best fizzbuzz ever (an easy task), we decided the worst fizzbuzz ever would be a bigger challenge.

Oh, and before you ask, it's because spaceships are awesome.

class Fixnum
  def <=>(b)
    self % b
  end
  
  def fizz?
    self % 3 == 0
  end
  
  def buzz?
    self % 5 == 0
  end
end

(1..100).each do |number|
  if number.fizz?
    if number.buzz?
      puts 'FizzBuzz'
    else
      puts 'Fizz'
    end
  else
    puts 'Buzz'
  end
end

[Ruby] On resource_controller: Redesign My API

2007-11-05T22:42:49-08:00

I love those. The *_finder macros are definitely possible. I really like the acts_as_resource_controller too. Currently, that syntax is just resource_controller, which I'm not crazy about.

I agree with you about the respond_to, although, I think for open syntax it should be responds_to, just because it reads like english - update responds to js and html. OTOH, I don't see much of a problem with having all of these names as aliases, and so I think I'll probably do that.

update.failure.responds_to %(js html)

[Ruby] On resource_controller: Redesign My API

2007-11-05T20:28:27-08:00

First refactoring from my blog...

## Alternate Model/Route/Object Naming

class PostsController < ResourceController::Base
  model_name :blog_post
  route_name :article
end

[Ruby] resource_controller: Redesign My API

2007-11-05T20:27:18-08:00

Backstory on my blog: http://jamesgolick.com/2007/11/5/resource_controller-redesign-my-api-at-refactormycode-com

## Before / After / Response

class PostsController < ResourceController::Base

  # block syntax
  create do
    before { @post.user = current_user }
    response do |wants|
      wants.html
      wants.js
    end
  end
  
  # chain syntax
  update.failure.wants.js
  
  # hybrid syntax
  update.failure do
    flash "There was a problem saving your object."
    wants.js
  end

end

## Alternate Model/Route/Object Naming

class PostsController < ResourceController::Base
  private
    def model_name
      'blog_post'
    end
    
    def route_name
      'article'
    end
end

## Alternate find syntax

class PostsController < ResourceController::Base
  private
    def object
      @object ||= end_of_association_chain.find_by_permalink(param)
    end
    
    def collection
      @collection ||= end_of_association_chain.find(:all, :page => {:current => params[:page], :size => 10})
    end
end

## Specific Actions

class PostsController < ResourceController::Base
  actions :all, :except => :edit
end

## Possible Parents

class PostsController < ResourceController::Base
  belongs_to :user, :category
end

[Ruby] On restful_authentication role requirements

2007-09-27T12:06:12-07:00

As an aside, it's helpful to have this in your user model, if you want current_user.send("#{role}?") to work

## user.rb

ROLES = %w( administrator staff )
ROLES.each do |current_role|
  send(:define_method, "#{current_role}?") do
    self.role == current_role
  end
end

[Ruby] On restful_authentication role requirements

2007-09-27T11:59:34-07:00

Marc's suggestion. Which one does everybody like better?

def self.requires_role(role, options={})
  before_filter(options) { |controller| controller.instance_eval { logged_in? && current_user.send("#{role}?") ? true : controller.access_denied } }
end

[Ruby] On restful_authentication role requirements

2007-09-27T11:56:32-07:00

Problem is, that block seems to get called at the class's scope. The controller is passed to it, but all those methods are protected. Send hack to the rescue!

NoMethodError: undefined method `logged_in?' for ProductsController:Class

def self.requires_role(role, options={})
  before_filter(options) { |controller| controller.send(:logged_in?) && controller.send(:current_user).send("#{role}?") ? true : controller.send(:access_denied) }
end

[Ruby] On restful_authentication role requirements

2007-09-27T10:41:28-07:00

So, I added this

## application.rb

def self.requires_role(role)
  before_filter :login_required
  send(:define_method, :authorized?) do
    logged_in? && current_user.send("#{role}?")
  end
end

## controller

requires_role :administrator

[Ruby] restful_authentication role requirements

2007-09-27T10:40:32-07:00

This is a couple of lines that I was writing a lot

## Controller that can only be accessed by an administrator

before_filter :login_required

# ... the controller

private
  def authorized?
    logged_in? && current_user.administrator?
  end

[Ruby] On Knowing mocha

2007-09-20T11:54:03-07:00

After

def test_should_create_image_if_necessary_before_trying_to_give_it_data
  file = mock :content_type => "jpg", :size => 10, :original_filename => "something.jpg", :path => "/home"

  assert_nothing_raised do
    @p.uploaded_data = file
  end
end

[Ruby] Knowing mocha

2007-09-20T11:53:21-07:00

Before

def test_should_create_image_if_necessary_before_trying_to_give_it_data
  file = mock()
  file.expects(:content_type).returns('jpg')
  file.expects(:size).returns(10)
  file.expects(:original_filename).returns('something.jpg')
  file.expects(:path).returns('/root?')
  
  assert_nothing_raised do
    @p.uploaded_data = file
  end
end

[Ruby] Linking that doesn't suck as much

2007-09-20T08:16:49-07:00

Tammer Saleh, creator/maintainer of the awesome shoulda plugin posted this to his blog (http://blog.tammersaleh.com/articles/2007/07/26/its-the-little-things). It's an awesome start, but I can see a lot of ways it could be improved, and become truly awesome. What are your takes?

def link(item, msg = nil)
  msg ||= item.send([:name, :title, :id].detect {|n| item.respond_to? n})
  method = "#{item.class.name.underscore}_path"
  parents = item.parents rescue []
  link_to(msg, self.send(method, *parents, item))
end

[Ruby] On Typical restful scaffold controller

2007-09-19T13:32:52-07:00

Why not use make_resourceful

class PostsController < ApplicationController

  make_resourceful do
    actions :all
  end

end

[Ruby] On How to make time_ago_in_words cachable ?

2007-09-19T13:18:55-07:00

But document.write is still gross, so here's my take

def cachable_time_ago_in_words(from, id_prefix = '')
  id = "#{id_prefix}_#{from.to_i}"
  content_tag :span, "", :id => id
  javascript_tag "$('#{id}').update(DateHelper.timeAgoInWords(#{(from.to_i * 1000).to_json}))"
end

[Ruby] On Ruby simple loop

2007-09-19T13:02:09-07:00

or even shorter

(1..10).each { |i| puts i }