First, I haven’t written in awhile. Like many bloggers that I follow, success in one area diminishes my capacity in other areas. My contracting business is doing very well. More than that however, I don’t like to waste space or mince words on my blog, as you have already noticed. I won’t write unless I have something that I think is worth sharing; I won’t write just to keep a fresh article in the feeds.

I have been doing a lot of debugging – mostly of the needle-in-a-haystack variety. Simultaneously I am working on a new, re-engineered version of the legacy app I am debugging. So I have the opportunity to do some things “right” this time (I didn’t write the legacy app, and the developer who did is AWESOME and a friend. I am not criticizing the code here. What always happens is the problems and business rules become clearer as the project matures, giving rise to an opportunity to craft a better model)

There are of course great plugins to do some of this, and more. I personally have found that in some cases less is more and projects that rely to heavily on 3rd party code may end up paying for at debug time.

Here are some tweaks to errors and whatnot that I use:

1. extend StandardError with a simple to_xml method, for use in ActiveResource and pretty much anywhere:

class StandardError
  def to_xml
    return <<-ENDOFDOC
      <error type='#{self.class.to_s}'>
        <message>#{message}</message>
      </error>
    ENDOFDOC
  end
end

1.5. UPDATE: I also added a status method, since I use resources so heavily.

@status=400 #its never the server's fault
attr_accessor :status

and in the custom errors mentioned below, change as needed:

LocalApplication::SomeParameterIsMissing.new.status # => 406

This works nicely for StandardError and any descendent classes that don’t already have a to_xml method. For ActiveRecord:: and some other error classes, there is a to_xml which will override this one.

2. put a general error handler in ApplicationController

def handle_error(err=nil)
  begin
    if err.nil?
      @error = GenericNilError.new("Oops, something happened...")
    else
      @error = err
    end
    respond_to do |flavah|
      flavah.xml { render :xml => @error.to_xml, status => 500 and return false }
      flavah.html  # a template for error
    end
  rescue StandardError => e
    # some failsafe that hits a static
    render :nothing => true, :status => 500 and return false
  end
end

3. use local errors As in the example above, roll your own errors. Then you respond in customized ways. If you’re not already rescuing different kinds of errors and handling them in unique ways, you may want to explore that.

module LocalApplicationError
  class GenericError < StandardError ; end
  class ShouldNeverHappenError < StandardError ; end
  # etc...
end

4. have an error log So much better than scrolling through #{RAILS_ENV}.log

err_logger = Logger.new #customize how you want it
[ActiveRecord ActiveResource ActionController].each do |mod|
  mod.module_eval <<- ENDOFMONKEY
    include LocalApplicationError #why not throw this in there too, see #3 above
    @err_logger = err_logger
    mattr_reader :err_logger
  ENDOFMONKEY
end

5. Use specs so you don’t raise unknown errors!

I recently created merbdoc.com (a.k.a. merbapi) to help the Merb community out. Let me know how if its useful, or how I can improve it. Its brand new, so it might be down for the next day or so.

Here’s a very easy way to change the default render format. Its not necessarily the best way for you. Consider that rendering HTML is hardcoded in the code and it is probably default in the browser/client’s Accept header.

rails/action_pack/lib/action_view/base.rb

when parameter_format.blank? && accept_format != :js
          @template_format = :html

For my usage, the best way to change was to add a method to application.rb and call it as a before filter (either by default in application.rb or as needed in each controller) (updated to a better way)

protected
def set_request_header
    xml_string = 'application/xml'
    request.instance_eval("@accepts=Mime::Type.lookup('#{xml_string}')")
    request.headers['HTTP_ACCEPT']  = xml_string
    request.env['HTTP_ACCEPT']      = xml_string
end

it’s not really “playing nice” but it works and is easy to debug and undo

Its Spring Break, which means nothing to me other than that my kids are home from school. Work is difficult. This week instead of carelessly crafter semi-digested thoughts on Ruby et al., I bring you a picture from railsblog

If you use a Unix-like development environment, this may be helpful. Here's some snippets from my .bash_profile on Leopard.

function wo {
  cd "/Users/bryan/apps/$1";
}
function devcon {
 eval script/console $1;
}
function testcon {
 eval "script/console test $1";
}
function prodcon {
 eval "script/console production -s $1";
}
function prodcon_live {
 eval "script/console production $1";
}

So I get something to go to a certain project I'm working on and use the console quickly.

bash:~> wo merb-core
bash:/Users/bryan/apps/lazy_developer> devcon
>>

It saves a lot of typing.

Well after joining Github recently to work on Merb I did a few things: submitted my first patch, got rejected, and learned a lot about git and merb. xD

Wycats from merb kindly pointed out that the “bug” I had discovered was actually a feature! Indeed it is. Let’s have a look.

(original Lighthouse ticket)

working_foo.rb

class WorkingFoo < Application
  def index
    redirect 'http://merbivore.com'
  end
end

failing_foo.rb

class FailingFoo < Application
  before :choke

  def choke
    redirect 'http://merbivore.com'
  end
end

So what happens? In retrospect my thoughts were clearly biased by Rails. This application would work in Rails. But that doesn’t mean it is necessarily a smart way to do things. In failing_foo.rb the application is kind of losing control; the filter redirects and the session is abruptly interrupted. The outcome is the same in that the user agent is eventually redirected where they need to go, but it’s not the best way of doing it.

Here is the Merb way

merby_foo.rb

class MerbyFoo < Application
  before :awesomeness

  def awesomeness
    throw :halt, redirect "http://merbivore.com" 
  end
end

I read about 75% of the Merb code over the weekend to write a patch, and what I came up with was almost the same as the above MerbyFoo (suggested by Wycats), but with a subtle difference. I placed my throw :halt in the redirect method of the Controller mixin with a check to see if it was being called in a filter. Tsk on me. Wycats and the merb way is better, and now I understand it. You would normally expect the before filter that calls redirect to “halt” the before filters, but perhaps not always.

Merbs filters (in abstract_controller.rb) are flexible. The throw mechanism in filters allows passing a String, Proc, Symbol or nothing. Perhaps the redirect involves something complex:

before :check_em

def check_em
  throw :halt, :complex_stuff
end

def complex_stuff
 redirect "http://google.com" if user =~ /googler/
 redirect "http://yahoo.com" if user =~ /yahooligan/
end

I built the gem on my local machine like this:

git clone git://github.com/wycats/merb-core.git
git clone git://github.com/wycats/merb-more.git
cd merb-core
rake install
cd ../merb-more
rake install
gem list --local merb

*** LOCAL GEMS ***

merb (0.9.0)
merb-action-args (0.9.0)
merb-assets (0.9.0)
merb-builder (0.9.0)
merb-core (0.9.0)
merb-gen (0.9.0)
merb-haml (0.9.0)
merb-mailer (0.9.0)
merb-more (0.9.0)
merb-parts (0.9.0)
merb-test (0.9.0)

excellent

I decided to upgrade my installation of merb from the older merb-0.5.x to the new "merb-next" which is re-numbered 0.9.x and available on github.

I knew something was going to finally push me to getting and learning git; so there it is. First thing is to dl and compile of course.
As I found out after a halt in the compile, Leopard needs a SYS V type utility called msgfmt. After a lot of googling and messing around, I found this article by Sean Santry which I found to be most helpful.

I truly was going to install the GNU gettext utilities as well, but I was unable to compile them easily as well. Since I was already 3 or 4 tangents removed from upgrading merb, I decided to use Sean's workaround.

NO_MSGFMT=yes make prefix=/usr/local all

I was going to write something in Applescript (after learning Applescript) to open a Safari page in Firefox. I found a somewhat dated example here which I updated slightly, and it works for me YMMV.

tell application "Safari"
	activate
	set my_URL to the URL in document 1
end tell
-- Convert Unicode Text of my_URL to Plain text
set my_URL to «class ktxt» of ((my_URL as string) as record)

tell application "Firefox"
	activate
	Get URL my_URL
end tell

quit

I wrote this to facilitate doing things faster in the console. Pretty mindless, but fun to get involved more at rubyforge.
install like your usual plugin (I recommend piston)

svn checkout http://lazy-developer.rubyforge.org/svn/
or
svn checkout svn://rubyforge.org/var/svn/lazy-developer

and you get:

Foo.ff          find the first foo
Foo.fl          find the last foo
Foo.fa         find all foos
Foo.f1(arg)  find a foo with this condition
Foo.f(arg)    find all foos with this condition

let me know how it goes for you

I saw no visible means of contacting the authors of the micro-tabbed theme, and their svn was down. I consider this to be a pretty crappy bug: they hardcoded their own url into the liquid so links generated map to them. Unintentional or otherwise, its pretty bad. I checked around some other site that use this theme, and they have the same issue. To fix, edit _entry.liquid and replace the default with this:

http://{{ site.host }}{{ article.url }}