Ruby and Rails Snippets

POST an XML request through the REST API

Thu, 02 Jul 2009 08:58 GMT

This script demonstrates how to post an XML request through the REST API, and retrieve a short URL from rubyurl.com.



require 'net/http'



url = "rubyurl.com" # for testing

path = "/api/links"

headers = {"Content-Type" => "text/xml"}



h = Net::HTTP.new(url, 80)

h.use_ssl = false



xmlrequest = "

  http://github.com/robbyrussell

"

resp, data = h.post(path, xmlrequest, headers)

output:

    

=> [#, "http://github.com/robbyrussellhttp://rubyurl.com/PNsF"]

rcscript usage:

rcscript //job:rubyurl http://rorbuilder.info/r/short_url.rsf http://www.wired.com/

#=> http://rubyurl.com/b20P

Resources:
- UPS Shipping Tools XML Integration - Ruby on Rails: Talk | Google Groups [google.com]
- Best way to parse XML data - Ruby on Rails: Talk | Google Groups [google.com]
- constructing an (xml) request properly for http post to an api - Ruby Forum [ruby-forum.com]
- net/http: Ruby Standard Library Documentation [ruby-doc.org]
- RubyURL » Keep it short (and sweet) [rubyurl.com]
- short_url.xml [rorbuilder.info]

Use a stronger password with a crib sheet

Thu, 02 Jul 2009 04:51 GMT

This script accepts a simple user password, and translates each character to a 2 or 3 digit code to make up a new stronger encrypted password. If the user forgets their strong password they can re-enter their simple password to retrieve it.



require 'open-uri'

require 'rexml/document'



class PwLookup

  include REXML



  def lookup(s)

    d = Document.new(open('http://rorbuilder.info/pl/codes', "UserAgent" => "rcscript").read)

    s.split(//).map {|c| d.root.elements["code[@index='#{c}']/attribute::value"]}.join

  end

end



if ARGV[0][/\w+/] then

  s = ARGV[0]

  pl = PwLookup.new

  pw = pl.lookup(s)

  puts 'your password is ' + pw

else

  puts 'supply a simple keyword to convert to a password'

end

#=> apple translates to 4h55QfuJ

rcscript usage:

rcscript //job:password_lookup http://rorbuilder.info/r/utility.rsf apple

Resources:
- Encode simple passwords [dzone.com]
- utility.xml [rorbuilder.info]

Use Ruby Scripting File (RSF) to manage your files

Wed, 01 Jul 2009 15:46 GMT

This script is intended to be a lightweight utility for managing your Ruby scripts using XML.



#!/usr/bin/ruby

#file: rcscript.rb



# created: 1-Jul-2009



# description:

#  - This script executes Ruby script contained within an XML file.

#  - The XML file can be stored locally or on a website.

#  - The 'require' statement for foreign scripts has been replaced 

#      with the script tag (e.g. 

    

  

  

    

    

  

  

    

  







file: fun.rb


#!/usr/bin/ruby



puts 'juice'



Example:


james@dovellia:~/learning/ruby$ rcscript welcome.rsf //job:hello

juice

hello me





To run the utility similar to an executable file I sym linked the rcscript.rb file to /usr/bin



Resources:

 - The Scripting Guys' First Blog : How Come You Guys Don't Use .WSF Files? [msdn.com]

 - WSF - Windows Script File XML Format [herongyang.com]



Find out what's on Radio 4 now
Wed, 01 Jul 2009 07:31 GMT


require 'open-uri'



base_url = 'http://www.bbc.co.uk'

buffer = open(base_url + '/radio4', "UserAgent" => "Ruby-reader").read

e = %Q(id="js-rotate-title">([^<]+)<\/a>)

href, title = buffer.match(/#{e}/).captures

puts title + ' is on Radio 4 now - ' + base_url + href



#=> The Archers is on Radio 4 now - http://www.bbc.co.uk/programmes/b00l9r7d





Here's a service that simply returns what's on Radio 4 as XML [rorbuilder.info].



output:




  Afternoon Play

  http://www.bbc.co.uk/programmes/b00lg4c7

  Afternoon Play is on Radio 4 now - http://www.bbc.co.uk/programmes/b00lg4c7






Increment a string with succ
Wed, 01 Jul 2009 06:50 GMT


u = '2'

u.succ!

puts u

#=> "3"





Resources:

 - Class: String

Use tmail and IMAP to save attachments
Wed, 01 Jul 2009 05:52 GMT
Hope somebody finds this useful





#! /usr/bin/ruby



require 'net/imap'

  # This is a convenience monkey patch

  class Net::IMAP

    def uid_move(uid, mailbox)

      uid_copy(uid, mailbox)

      uid_store(uid, "+FLAGS", [:Deleted])

    end

  end

require 'rubygems'

require 'tmail'



imap = Net::IMAP.new('mail.example.com')

imap.login("user", "password")

imap.select('Inbox')



imap.uid_search(["SUBJECT", "order mail"]).each do |uid|

  # save_attachment

  mail = TMail::Mail.parse( imap.uid_fetch(uid, 'RFC822').first.attr['RFC822'] )

  if ! mail.attachments.blank?

    File.open(mail.attachments.first.original_filename,"w+") { |local_file|

      local_file << mail.attachments.first.gets(nil)

    }

  end



  # archive mail to mailbox

  imap.uid_move(uid, 'Inbox.archived')

end



imap.expunge

imap.logout




Use a hash as a parameter list
Wed, 01 Jul 2009 02:55 GMT
Source: Optional Method Parameters with Hashes [about.com]







    def my_method(opts={})

      o = {

        :a => 'Testing',

        :b => 'this',

        :c => 'feature'

      }.merge(opts)

      

      puts "#{o[:a]} #{o[:b]} #{o[:c]}"

    end



    my_method

    my_method( :b => 'this great' )



While it is a bit more verbose to access the parameters, it is much more flexible.





output:

Testing this great feature



What is special about this snippet is not just that it uses a hash but it uses default values for parameters (in a hash) which are then overridden by the actual parameters (in a hash) using 'merge'.



*update @ 10:13 1-Jul-09

How I actually intended to use this was to first of all use XML as the parameter list e.g.



  def params_to_h(params)

    h = {}

    doc = Document.new(params).root.elements.each("param[@var]") do |param|

      var = param.attribute('var').to_s.to_sym

      h[var] = param.children.to_s 

    end

    h

  end



  def start(params)

    h = params_to_h(params)

    o = {:ready => 'false', :status => 'do not move', :conditions => 'good'}.merge h

    puts o.inspect

  end



  start("truego")





output:


{:ready => 'true', :status => 'go', :conditions => 'good'}





Note: merge must be affixed to the end of the newly created hash otherwise the defaults will not be overwritten unless you use merge!.


Use lambda for strict argument checking
Tue, 30 Jun 2009 11:56 GMT
Source: Mr. Neighborly's Humble Little Ruby Book [humblelittlerubybook.com]





 First of all, Proc objects created with lambda have stricter argument checking than those created with Proc.new.





lproc = lambda {|a,b| puts "#{a + b} <- the sum"}

nproc = Proc.new {|a,b| puts "#{a + b} <- the sum"}



nproc.call(1, 2, 3)

#→ 3



lproc.call(1, 2, 3)

#→ !ArgumentError (wrong number of arguments (3 for 2))








Use alias to give a method a different name
Tue, 30 Jun 2009 09:26 GMT
Source: File: ruby_1.9_keywords.rb [RDoc Documentation] [ruby-doc.org]



I've copied this example here because 'alias' is a helpful method for perhaps polishing your code. It makes calling a method from a programmer's perspective less of a surprise depending on their style of coding i.e. I prefer using array#map instead of array#collect even though they are the same method.





  alias()



Creates an alias or duplicate method name for a given method. The original method continues to be accessible via the alias, even if it is overriden. Takes two method-name arguments (which can be represented by strings or symbols but can also be the bare names themselves).







  class Person

    def name=(name)

      puts "Naming your person #{name}!"

      @name = name

    end



    alias full_name= name=

  end



  p = Person.new

  p.name = "David"        # Naming your person David!



  class Person

    def name=(name)

      puts "Please use full_name="

    end

  end



  p.full_name = "David"   # Please use fullname=










Use thread.join to ensure proper thread execution
Tue, 30 Jun 2009 07:39 GMT
Source: Programming Ruby: The Pragmatic Programmer's Guide [rubycentral.com]



Prior to using thread.join I had observed threads being executed and then terminated early as a result of the main script finishing. The main script does not wait on threads to finish unless threads use something like the following: 


threads.each { |aThread|  aThread.join }





e.g.





require 'net/http'





pages = %w( www.rubycentral.com

            www.awl.com

            www.pragmaticprogrammer.com

           )





threads = []





for page in pages

  threads << Thread.new(page) { |myPage|





    h = Net::HTTP.new(myPage, 80)

    puts "Fetching: #{myPage}"

    resp, data = h.get('/', nil )

    puts "Got #{myPage}:  #{resp.message}"

  }

end





threads.each { |aThread|  aThread.join }





produces:


Fetching: www.rubycentral.com

Fetching: www.awl.com

Fetching: www.pragmaticprogrammer.com

Got www.rubycentral.com:  OK

Got www.pragmaticprogrammer.com:  OK

Got www.awl.com:  OK



... Why do we call join on each of the threads we created?



When a Ruby program terminates, all running threads are killed, regardless of their states. However, you can wait for a particular thread to finish by calling that thread's Thread#join method. The calling thread will block until the given thread is finished. By calling join on each of the requestor threads, you can make sure that all three requests have completed before you terminate the main program.





Resources:

 - Derived class for Ruby Thread? - Stack Overflow [stackoverflow.com] - this post helped my interest in finding out more on thread.join

 - Class: Thread [ruby-doc.org]



*update @ 15:00 30-Jun-09*

While looking through the thread docmentation I found the following snippet to be helpful



  y = Thread.new { 4.times { sleep 0.1; puts 'tick... ' }}

  puts "Waiting" until y.join(0.15)





output


tick... 

Waiting

tick... 

Waiting

tick... 

tick... 





It demonstrates that the statement following the thread can be influenced by the thread's timer event.