Gem Ystock

A new side project I have been working on is in the financial industry. This project needs to pull stock information such as; price, change, and volume of a any stock. The source i will be getting this information from is Yahoo! Finance. Yahoo produces a cvs file with just the information i need, so it’s good news! The next task is to build something i can use over and over, something portable i can take from this project and implement on the next. In rails 3 plugins seem to be old news so i decided on creating a gem named ‘ystock’ for Yahoo Stock information. (NOTE: I have no affiliation with Yahoo, this gem simply uses their service)

The project is hosted with github: https://github.com/gregwinn/ystock, and the gem is hosted at RubyGems.org: http://rubygems.org/gems/ystock. Below is how to install and use my new gem!

Install

sudo gem install ystock

After installation you can now include this into your Gemfile

gem 'ystock'

Usage

http://github.com/gregwinn/ystock/wiki/Usage

After you have installed the gem and included it into your Gemfile you can now start to use ystock.

1. In a controller you can do the following:

class SomeController < ApplicationController
   def index
      @stock = Ystock.get_stock('appl')
   end
end

2. In your view you may display the results:

<p>The price of Apple stock is: $<%=@stock[:price]%></p>

Available data

<%=@stock[:price]%>
<%=@stock[:change]%>
<%=@stock[:volume]%>

Thanks for reading, i hope this gem is of use to you in any future projects!

A WordPress MU API on Rails

I have been working a WordPress MU API for the company I work for and came across a use for converting an array into a hash. The API is in Ruby on Rails, and the client that is making the request is PHP. The php script is posting an array to the API witch then needs to be turned into a hash. Below is how I accomplished this.

The sudo php client request.

$data = array('key' => 'value');
$class->Get_some_data('string', $data);
// This is posted to the API...

Now the Ruby

data = Hash[*params[:string].flatten]
# I can then call
puts data.key
#=> value

You can do this to any array.

Have an array in ruby that needs to be a hash?

a = ['apple', 1, 'banana', 2]
h = Hash[*a.flatten]
puts "h: #{h1.inspect}"
 
# -----
 
a = [['apple', 1], ['banana', 2]]
h = Hash[*a.flatten]
puts "h: #{h.inspect}"

Delegation is a quite common practice in Ruby projects, if you consider proxies, mix ins and composition as the ingredient of the Delegation Pattern. The Delegation Design Pattern is a technique where an object exposes certain behavior but it actually delegates responsibility for implementing that behavior to an associated object.

A really common technique is to use method_missing to intercepts the calls to undefined method, then forward the call to the right handler. However, this isn’t always a good idea. There are better ways to implement the delegation pattern in Ruby.

The Ruby standard library contains a Delegate module that aims to provide support for the Delegation pattern. Sadly, I found it to be way more complex than the traditional approach and I never really used it.

ActiveSupport Delegate module

If your project includes ActiveSupport, and every Rails project does, you have a more clean and easy way to implement the delegation pattern: the Module#delegate extension. It provides a delegate module you can use in your class or in your modules to delegate a specific method to an associate object.

For instance, consider a standard Post model which belongs to an User.

class Post
  belongs_to :user
end
 
class User
  has_many :posts
end

You might want a call to post.author to return the name of the user associated to the given post. Normally, you would create a new author method as follows

class Post
  belongs_to :user
 
  def author
    # let's use try to bypass nil-check
    user.try(:name)
  end
end

The same code expressed using the delegate method.

class Post
  belongs_to :user
  delegate :author, :to => user, :allow_nil => true
end

The delegate method can be used in any context, it’s not limited to ActiveRecord models. For example, your custom queue wrapper can delegate to the internal queue implementation some specific methods.

class QueueManager
 
  attr_accessor :queue
 
  # Delegates some methods to the internal queue
  delegate :size, :clear, :to => :queue
 
  def intialize
    self.queue = []
  end
 
end
 
m = QueueManager.new
m.size
# => 0
m.clear
# => []

Methods can be delegated to instance variables, class variables, or constants by providing them as a symbols. At least one method and the :to option are required.

Options

The delegate method understand some additional options, useful to customize the behavior.

This is my favorite option. The :prefix can be set to true to prefix the delegate method with the name of the object being delegated to. You can also provide a custom prefix.

class Post
  belongs_to :user
 
  delegate :name, :to => :user, :prefix => true
  # post.user_name
 
  delegate :name, :to => :user, :prefix => "author"
  # post.author_name
end

The :allow_nil option allows the class to delegate the method to an object that might be nil. In this case, a call to the delegated method will return nil. The default behavior is to raise a NoMethodError.

class Post
  belongs_to :user
  delegate :name, :to => :user, :prefix => true
end
 
Post.new.user_name
# raise NoMethodError
 
class Post
  belongs_to :user
  delegate :name, :to => :user, :prefix => true, :allow_nil => true
end
 
Post.new.user_name
# => nil

The :to it a non-option, because it’s mandatory. Check out the documentation.

These symbols are not purely internal to the interpreter; they can also be used by Ruby programs. A Symbol object refers to a symbol. A symbol literal is written by prefixing an identifier or string with a colon.

One

:symbol #A Symbol literal

Two

:"symbol" #The Same literal

Three

:'a very long symbol' #Quotes are best used for symbols with spaces

Four

s = "string"
:"#{s}" # The symbol :string

Amazon SimpleDB is a web service for storing, maintaining, and querying structured data sets in real time. All data is stored in Amazon’s web service cloud, making SimpleDB very reliable, scalable, and flexible. I am going to go over all you need to start using Simple DB with Ruby on Rails.

The Rails web application framework, apart from generally being a wonderful tool, offers out-of-the-box support for web service-based data stores with its ActiveResource sub-framework. Only a very thin adapter layer is necessary to bridge the ActiveResource API to SimpleDB. Rails gives you the unique opportunity to utilize SimpleDB just as any other RESTful resource provided by a Rails application.

Getting Setup

1. Sign up for an Amazon AWS Account.
2. Install the aws-sdb Ruby Gem providing a basic Ruby API for SimpleDB:

   sudo gem install aws-sdb

3. Install the AWS SDB Proxy Plugin for Rails:

   script/plugin install http://rug-b.rubyforge.org/svn/aws_sdb_proxy

4. Enter your Amazon Web Service credentials in the config/aws_sdb_proxy.yml file (optionally configure server ports and an individual salt used to generate primary keys with a hash function). Do this at least for the development environment.
5. Either use an existing SimpleDB domain in your account (you can list your domains with rake aws_sdb:list_domains), or create a new one with rake aws_sdb:create_domain DOMAIN=my_new_domain
6. Start the AWS SDB Proxy server: rake aws_sdb:start_proxy_in_foreground proving debug output on stdout (once you are confident with the configuration you can use rake aws_sdb:start_proxy to start the server as a background daemon)

NOTE: You may have an error:

wrong number of arguments (3 for 1) 

. The AWS plugin needs a little help so lets edit one of the files. Locate “vendor/plugins/aws_sdb_proxy/lib/aws_sdb_proxy/server.rb” now look for:

SDB_SERVICE = AwsSdb::Service.new(Logger.new(nil),
                                           CONFIG['aws_access_key_id'],
                                           CONFIG['aws_secret_access_key'])

and replace it with:

SDB_SERVICE = AwsSdb::Service.new(
                  {:access_key_id=>CONFIG['aws_access_key_id'],
                  :secret_access_key=>CONFIG['aws_secret_access_key']})

Once you fix this issue you can now start the server/create your domain without error.

Using Simple DB

To make a Rails model access SimpleDB, it must inherit from ActiveResource::Base. For the following examples we will use a Logging model, thus create the following models/logging.rb file:

class Logging < ActiveResource::Base
  self.site   = "http://localhost:8888" # Proxy host + port
  self.prefix = "/my_new_domain/"       # SDB domain
end

Now we can create new records by simply:

Logging.create(:user_id => @user.id, :action => "Some action")

Now query for the records

log = Logging.find(:all, :attributes => {:user_id => @user.id})

Update the record

log = Logging.find(log.id)
log.action = "Update this action"
log.save

You can read more about this on the Amazon site at http://aws.amazon.com/articles/1242.

Passenger makes deploying rails apps as easy as putting the file on the server and starting Apache. I have been using passenger for about 4 years and have used it for some very high scale projects. Passenger makes deployments very php like, what i mean by that is you can just drop the files and go. From my experience using Passenger the only time Apache need to be recycled is when adding a new controller or model. Adding actions inside an already existing controller Apache will not need to be restarted, you can simply start using that action.

The next big seller for me is the documentation on this product it’s been around for some time so there is a large community around “mod_rails / Passenger”. Passenger works on any POSIX-compliant operating system. In other words: practically any operating system on earth, except Microsoft Windows.

Passenger was super quick and easy to install and get a rails application running. Below i have detailed my installation on Mac OSX 10.6.4.

1) First I opened a terminal window and ran the command:

sudo gem install passenger

(Important note just remember to sudo).

2) Now lets install the apache2 module:

sudo passenger-install-apache2-module

After running the apache2-module command it will tell you what you can expect from the install process, just hit “Return”.

3) Now lets setup your Apache, the install will provide you with three lines that need to go into your Apache config document:

LoadModule passenger_module /Library/Ruby/Gems/1.8/gems/passenger-3.0.0/ext/apache2/mod_passenger.so
PassengerRoot /Library/Ruby/Gems/1.8/gems/passenger-3.0.0
PassengerRuby /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby

NOTE: Don’t copy and paste mine, be sure to copy the output from the module install in your terminal window.

After restarting Apache you want to check and make sure AllowOverrides are set to all. Now create your rails project or use an existing one.

4) Now we need to setup a VirtualHost in apache, open the httpd-vhosts.conf file and add this:

<VirtualHost *:80>
	DocumentRoot "/var/www/path/to/your/rails/app"
	ServerName local.YourTestDomain.com
	RailsEnv development # <- important to set this here.
</VirtualHost>

Now restart apache once again and then edit your hosts file adding the local domain, once this has been done you can visit your local domain in a browser and you should now see your rail application running. No need to visit “localhost:3000” any more. Any time you create a new controller or model just restart Apache and reload the page.

I hope this has helped someone install this great product, i think you will find it very useful in the future for production rails app’s and just at home development. Read more about mod_rails / Passenger here.

First, lets make a checkbox called finish; this link will send the id of the item to the database to be updated. The item will be a todo and we will be using the list.html.erb and the todo_controller.rb.

In the view named: list.html.erb

remote_function(:url => {:action => 'finish', :controller => 'todo',
:id => todo.id})

Now once the checkbox is clicked it will them make the Ajax call to the todo_controller.rb with the method finish.

In the controller: todo_controller.rb

def finish
	@todo = Todo.update(params[:id], :status => '1')
	if @todo.save
		render :update do |page|
		page.replace_html 'thedivID' + params[:id], 'Finished!'
		end
	end
end

The above code will first update the database setting the status from 0 to 1 (1 = finished and 0 = unfinished). Next we check if the update was successful, after that we render the update to the page. By using render :update, we can replace the html in side of the div or other element with the text ‘Finished’.

Note you can use remote_function in any way you see fit, ie: onclick, onload and others.

Passing another var with remote_function. lets say i want to pass the user id, list id and, the todo id. How would we do this with the remote function?

We know know the link should look like this: /todo/finish/17?todoid=72&userid=100, but how do we do this with rails? Below is how to do just that;

remote_function(:url => {:action => 'finish', :controller => 'todo',
:id => list.id, :todoid => todo.id, :userid => @user.id})

# Added V1.7b
textlink_do_fade
textlink_do_puff
textlink_do_blindup
textlink_do_dropout

You can build any of the above calls with:

textlink_do_fade('Link Text','divYouWantToUpdate',{***},{****})

Visit the project for more info on how to use the latest methods and more. Winn Scriptatype project home page. at Ruby On Rails Railway.

[ruby]
# New calls in 1.7b
textlink_do_fade
textlink_do_puff
textlink_do_blindup
textlink_do_dropout
[/ruby]

I expect i will be making the same update to the PHP version soon so keep an eye out for that!

Take a look at the WinnScriptatype:Rails RubyForge project page and download the latest!

I had been working on this plugin for a few weeks in making a new application. I kept writing the “input, Ajax.Request and, Effect.Fade”, so i needed a way to make that fast and do what i need. And out came this handy plugin!

[ruby]
# Lets use this new plugin
checkbox_do_fade(‘theDiv’, ‘CheckboxID’, {:controller => ‘todo’, :action => ‘finish’, :id => todo.id}, {:userid => user.id})

[/ruby]

Here is an over view of the options:

[ruby]
checkbox_do_fade(‘*’, ‘**’, {***}, {****})

[Element ID]* This is the name of the element you want to effect such as a div or table (tr,td)…

[Checkbox ID]** This is the id of the checkbox it self

[URL/path]*** this is the url for the update to take place NOTE: always use controller,
action, and id DO NOT place other variables in this block that is for the next block.

[URL/path options]**** This block is used for url options like so: (/path/to/1?userid=1) as you see
userid is 1, this is done by using the url options block. You may send an unlimited number of
url options with this.

# Below are the ONLY supported calls
checkbox_do_fade # This will fade the element
checkbox_do_puff # This will puff the element
checkbox_do_blindup # and so on…
checkbox_do_dropout # again…
[/ruby]

Ready to start using it? Download WinnScriptatype

You will also need help installing this plugin so take a look at Ruby on Rails Railway : WinnScriptatype.