So I developed a tiny command line client, which allows you to send request easily. It comes as a gem and easily to install:

gem install oauth-cli

After installation, execute oauthc. You either make onetime calls, with giving all required data as parameter, or just go into interactive mode, to get a shell for multiple calls and history. For not stating all connection data over and over again, it comes with multiple profile support, a wizard to create those easily and presets for Twitter and Qype.

See this nifty example call:
oauthc -p twitter get statuses/friends.json

I hope you like it – Bug reports, suggestions, updates go to:

http://github.com/rngtng/oauth-cli/issues

See Readme:

http://github.com/rngtng/oauth-cli/blob/master/README.rdoc

See Source:

http://github.com/rngtng/oauth-cli

For that, I needed Serial communication within ruby. Thanks to ruby-serialport first steps went quite well. I could write OR read from and to Arduino easily. But for some reasons, writing AND reading using the same instance didn’t work out.

I used a simple ‘send-input-back’ sketch on the Arduino side. So every byte I’m sending is returned back. I checked with the Arduino IDE Serialmonitor and a simple Processing script – everything worked alright. But using ruby it was different. Writing to serial port worked okay, but reading from it was just random. Sometimes I read the response, sometime I didn’t – really, really weird. Some headaches and a lot of time testing I finally found the solution: just open two instances of the serial port. One for sending, one for reading – and, surprise, surprise – it works perfect! Who would have guessed that!? Strange..

// To be completed
require 'serialport'
port_write = Serialport.new()
port_read = Serialport.new()

Ok, continuing hacking, more soon…

module Kernel
   private
   def this_method
     caller[0] =~ /`([^']*)'/ and $1
   end
end

for Ruby >= 1.9 you can uses this:

module Kernel
   private
   def this_method
     __method__
   end
end

[see Stack Over Flow as well]

Check this out, here some lists of good techniques to get started and to impove your Ruby and Rails code:

http://nettuts.com/articles/web-roundups/10-awesome-ruby-on-rails-techniques-to-get-you-started/

http://www.rubyinside.com/19-rails-tricks-most-rails-coders-dont-know-131.html

http://www.rubyinside.com/21-ruby-tricks-902.html

[Awsm picture taken from DesignShark]

class Spaceship < ActiveRecord::Base
  include FlagShihTzu

  has_flags 1 => :warpdrive,
            2 => :shields

end

enterprise = Spaceship.new
enterprise.warpdrive = true
enterprise.shields = false
enterprise.save

enterprise.warpdrive? #=> true
enterprise.shields? # => false

Nice, isn’t it?

Unfortunately named scopes where missing for selecting models easily. So another github fork, another fix, and here were are. Now this works as well:

Spaceship.flagged(:warpdrive).not_flagged(:shields).all

Check it out here: http://github.com/rngtng/flag_shih_tzu/tree/master

Update: replaced ‘routes’ with ‘scopes’ – I’m getting confused with that all the time, how come!?

Unfortunately it didn’t provide the possibility to delete or update an image once it’s assigned to an object. Well no problem, another fork of mine, some coding and now it possible. I basically reused to code of the as_file_column_bridge. Check it out here:
http://github.com/rngtng/as_paperclip_bridge/tree/master

Update: changes got merged into trunk, check it out:

http://github.com/mnaglik/as_paperclip_bridge/

I rubyfied the class, did some code cleanup, added (yet a very simple) way to get the original message, and gained some performance by paring message only on demand. A testcase was broken as well the Rakefile, both are fixed. See the update here:
http://github.com/rngtng/bounce-email/tree/master

More to get you started with Arduino and Ruby:
http://www.arduino.cc/playground/Interfacing/Ruby

This method called on a Scope class returns the Hash used for the ActiveRecord .find() call. First it’s a nice way to debug your scopes, second it’s perfect for our need to chain multiple scoped into one. Check this out:

class Fu < ActiveRecord::Base
named_scope :has_moo,  :conditions => { :moo => true }
named_scope :has_foo,  :conditions => { :foo => true }

named_scope :has_moo_and_foo, lambda { has_moo.has_foo.scope(:find) }
end

We chain the two scoped has_moo and has_foo together into a new one called has_moo_and_foo. As the return value can only be a Hash we use the above mentioned scope(:find) to transform it into one.

Now this works:

Fu.has_moo_and_foo.all

Sweet! Imagine how great this would be if we can return a scope object instead of a hash as well??

See my pastie here too.

I did a short eval of projects dealing with re currency in Ruby and Ruby on Rails. Here a short list & rough of interesting projects dealing with repeating time (intervals):

Common used lilbrary: http://runt.rubyforge.org
A better runt(?): http://github.com/nickstenning/recurring_event
Date extension, yahoo dev, rspec like: http://github.com/jhubert/ruby-date-recur

http://recurring.rubyforge.org

http://github.com/EdvardM/recurrence

http://github.com/fnando/recurrence

Check this as well:

http://stackoverflow.com/questions/85699/whats-the-best-way-to-model-recurring-events-in-a-calendar-application