So, I had a poke about in the gem (Oauth (0.3.6)) and wrote a couple of helper methods to allow for testing oauth based requests without mocking too much out, or in the case of integration tests, mocking nothing.

First off add this to your test_helper

include OAuth::Helper

# Functional test helpers
def oauth_helper_for_client(client)
  # gonna do everything but actually create a sig, cause its a pain
  OAuth::Signature::HMAC::SHA1.any_instance.stubs(:==).returns(true)
  OAuth::Client::Helper.new(@request, {:consumer => client})
end

def oauth_helper_for_client_and_user(client, user)
  token = AccessToken.find_or_create_by_user_id_and_client_id(user.id, client.id)
  OAuth::Signature::HMAC::SHA1.any_instance.stubs(:==).returns(true)
  OAuth::Client::Helper.new(@request, {:consumer => client, :token => token})
end

# Integration test helper
def oauth_header_for_method_uri_client_user_and_params(method, uri, client, user, params={})
  token = AccessToken.find_or_create_by_user_id_and_client_id(user.id, client.id)
  request = OAuth::RequestProxy.proxy(
     "method"       => method,
     "uri"               => uri,
     "parameters" => {
       "oauth_consumer_key"       => client.key,
       "oauth_token"                     => token.token,
       "oauth_signature_method" => "HMAC-SHA1",
       "oauth_timestamp"             => generate_timestamp,
       "oauth_nonce"                    => generate_nonce,
       "oauth_version"                  => '1.0'
     }.merge(params).reject { |k,v| v.to_s == "" }
  )

  signature = OAuth::Signature.sign request,
    :consumer_secret => client.secret,
    :token_secret       => token.secret

  request.parameters["oauth_signature"] = signature
  request.oauth_header
end

This gives you 3 new helper methods. The first can be used in functional tests to create a 2-legged oauth request and the second to create a 3-legged oauth as so:

def test_index_xml
  get :index, {:format => 'xml'}.merge(oauth_helper_for_client(clients(:some_consumer)).oauth_parameters)
  assert_response :success
end

The third method (which actually should have a parallel no user version for 2-legged, but that is left as an exercise for the reader..) allows you to simply create a fully signed request as shown below:

[NB. that the parameters are passed as strings not symbols, the Oauth library is not so happy with symbols]

post( url, { :value => value }, {
  'Accept'=> 'application/json', 'Authorization' => oauth_header_for_method_uri_client_user_and_params(
    "POST", URI.parse(url), clients(:uservoice),users(:scott),{"value" => value}
  )
})

Very easy to fix, just open up the ‘internals.rb’ file in the UltraSphinx plugin or include the gem using ‘rake gems:unpack GEM=ultrasphinx’ (need to have config.gem “ultrasphinx” set in envrinoment.rb) and then find that file.

Ok, so found the file? On line 97 is this loop:

Array(opts['filters']).each do |field, value|
  ....
 begin
     case value
     when Integer, Float, BigDecimal, NilClass, Array
       # XXX Hack to force floats to be floats
       value = value.to_f if type == 'float'
       # Just bomb the filter in there
       request.filters << Riddle::Client::Filter.new(field, Array(value), false)
     when Range
     ....
end

The ‘Riddle::Client::Filter.new(field, Array(value), false)’ call is the one we need to change (the ‘false’ is the exclude param).

So what I did was to change that loop to:

        Array(opts['filters']).each do |field, value|

          field = field.to_s
          type = Fields.instance.types[field]

          # Special derived attribute
          if field == 'distance' and options['location']
            field, type = '@geodist', 'float'
          end

          raise UsageError, "field #{field.inspect} is invalid" unless type

# ADDED FROM HERE
          exclude = false
          # check for exclude flag
          if value.is_a? Hash
            exclude = value[:exclude]
            value = value[:value]
          end
# TO HERE

          begin
            case value
              when Integer, Float, BigDecimal, NilClass, Array
                # XXX Hack to force floats to be floats
                value = value.to_f if type == 'float'
                # Just bomb the filter in there

# CHANGE CALL HERE TO PASS THE exclude PARAMETER
                request.filters << Riddle::Client::Filter.new(field, Array(value), exclude)
              when Range
                # Make sure ranges point in the right direction
                min, max = [value.begin, value.end].map {|x| x._to_numeric }
                raise NoMethodError unless min <=> max and max <=> min
                min, max = max, min if min > max
                # XXX Hack to force floats to be floats
                min, max = min.to_f, max.to_f if type == 'float'

# CHANGE CALL HERE TO PASS THE exclude PARAMETER
                request.filters << Riddle::Client::Filter.new(field, min..max, exclude)
              when String
                # XXX Hack to move text filters into the query
                opts['parsed_query'] << " @#{field} #{value}"
              else
                raise NoMethodError
            end
          rescue NoMethodError => e
            raise UsageError, "Filter value #{value.inspect} for field #{field.inspect} is invalid"
          end
        end

Now I can do searches like

    @search = Ultrasphinx::Search.new(
      :query => params[:q],
      :page => page,
      :class_names => ["User"],
      :filters => {:id => {:value => current_user.id, :exclude => true}}
    )

And the current_user gets excluded, cool.

Big advantages are the archive of errors and the ability to mark them as dealt with. Of course I could do that with email folders and the like, but I’m lazy and this appears to do it all. Oh and its free!!!

params =~ /.*: Parameters: (\{.*\})$/
str_hash = JSON.parse(params.gsub('=>',':'))

This provides a hash of the parameters used in the request. Of course the keys here are strings so to convert to symbols we can then use:

def create_symbol_hash(input)
  ret = input
  if input.is_a? Hash
    ret = {}
    input.each do |k, v|
      ret[k.to_sym] = create_symbol_hash(v)
    end
    ret
  else
    ret
  end
end

and simply pass in the output from the JSON library. Seemed quite neat to me anyway.

I released TweetLists last night, well actually this morning (about 3am), the idea being to try and capture a little of the zeitgeist on Twitter by aggregating the links people are talking about. At the moment there are 3 lists, the live feed, a popular feed (the links ordered by the number of times they appeared) and one I have chosen to call Twitterati (quite proud of that!) which is the links ordered by the number of followers people have.

At the moment there is no time aspect to the Twitterati or Popular lists (not relevant on the live one) but I guess I will make them for the last 7 days?

Lesson one form this has been: don’t try and be clever with your scheduling – cron just works. I tried to use the Rufus Scheduler and it had stopped running by the time I got up again this morning.

Anyhoo, I’ve found it to be fun and interesting so far, any ideas for other lists?

Actually just found this post mentioning that the checkboxes might be broken in Rails 2.0.2. Which could be the cause of the issue.

Asset Packager

Key Features

• Merges and compresses javascript and css when running in production.
• Uses uncompressed originals when running in development.
• Handles caching correctly. (No querystring parameters – filename timestamps)
• Uses subversion revision numbers instead of timestamps if within a subversion controlled directory.
• Guarantees new version will get downloaded the next time you deploy.

Thank you Scott Becker

After a couple of months of intense coding Robert Loch and I launched RecommendBox yesterday. Its a site based around requesting and giving recommendations to your friends. There were a few immediate issues!! IE 6 is not yet fully supported, but on the whole it went ok. Now, sleep…….