jason's rails blog

Start/Stop Mysql on Leopard

2008-12-03T07:07:00.000-08:00

sudo /usr/local/mysql/support-files/mysql.server start

sudo /usr/local/mysql/support-files/mysql.server stop

Rspec installation

2008-11-13T13:56:00.000-08:00

>sudo gem install ZenTest
>sudo gem install rspec-rails

in application root:
>ruby script/generate rspec

autotest         (if it hangs use >RSPEC=true autotest)

rake spec
rake spec:app
rake spec:models
rake spec:controllers
rake spec:views
rake spec:helpers
rake spec:plugins
rake --tasks:plugins

Compare time

2008-11-07T06:22:00.000-08:00

module ApplicationHelper
..SOMETIME_FORMAT = "%a %b %d %H:%M:%S %z %Y"
..SOMETIME_FORMAT_DB = '%Y-%m-%d %H:%M:%S'

..def sometime_this_month(time, format='user')
....return time.beginning_of_month.strftime(SOMETIME_FORMAT) if format == 'user'
....return time.beginning_of_month.strftime(SOMETIME_FORMAT_DB) if format == 'db'
..end

..def sometime_today(time, format='user')
....return time.beginning_of_day.strftime(SOMETIME_FORMAT) if format == 'user'
....return time.beginning_of_day.strftime(SOMETIME_FORMAT_DB) if format == 'db'
..end

end

Time based finds.

created_at time from the database is: "2008-10-24 22:06:18 +0200"
However retrieving the Time.now results in the format as follows: "Fri Nov 07 15:31:56 +0100 2008"

end

Named scope with variables

2008-11-07T06:14:00.000-08:00

in model *.rb (in this case weight_meassurements.rb)

named_scope :user_weight_meassurements, lambda { |user_id| { :order => 'created_at DESC', :conditions => ["user_id == ?", user_id] } }

named_scope :today, lambda { |today| { :conditions => ["created_at > ?", today] } }

Calling from the controllers or helpers @user.weight_meassurements.today('2008-11-07 00:00:00') wil retrieve all weight_meassurement record belonging to the user created after midnight of the passed date.

You can also call WeightMeassurements.user_weight_meassurements(@user.id) for all this user weight meassurement records.

Mysql import

2008-10-27T22:06:00.000-07:00

mysql -p -u{Benutzername} {DB-Name} < filename

Converting database time to human time

2008-10-27T02:53:00.000-07:00

model.created_at.begining_of_day.strftime(%B, %Y)
>October, 2008
model.creted_at.strftime("%d").to_i.ordinalize
>25th

%a weekday name.
%A weekday name (full).
%b month name.
%B month name (full).
%c date and time (locale)
%d day of month [01,31].
%H hour [00,23].
%I hour [01,12].
%j day of year [001,366].
%m month [01,12].
%M minute [00,59].
%p AM or PM
%S Second [00,61]
%U week of year (Sunday)[00,53].
w weekday [0(Sunday),6].
W week of year (Monday)[00,53].
x date (locale).
%X time (locale).
%y year [00,99].
%Y year [2000].
%Z timezone name.

Memcache Rails

2008-10-16T03:07:00.000-07:00

>sudo port install memcached
>/opt/local/bin/memcached -d -m 64 -u www -l -p 11211

see also
/Library/LaunchDaemons/org.macports.memcached.plist
memcached -h
man memcached

Session Cookies and Application Strategy

2008-10-13T22:40:00.000-07:00

- Do you need protection_forgery? Yes!
- Does a browser need cookies turned on? Yes!
- Is there no otherway around it? No!
Passing infomation in the url is neiter restful, nor safe!
- What about people that have their cookies turned off?
We have to give let them know that cookies are safe in the contect of our application, and they hold no personal information and they are encrypted.
- What about mobile phone browsers that mostly have no cookie capabilities?
Same as cookies turned off, may adding somthing about mobile phones too.
OR
The user can set up his account as "Mobile Phone Enabled" from a web browser and tell them about the cookie problem, but give them the solution to have the application use IP as the cooke key - with the small problem that if thier provider issues them with a new IP during the session, they will have to relogin.

Better Cookie Detect

2008-10-13T22:29:00.000-07:00

In some cases, you might really really want to know it the visiting browser has thier cookies on or off. One reason that I an think off is that you are using some ajax stuff on your the landing page that lets unregistered users edit a list or somthing.

This is a way of doing it.

1. Check to see if a cookie has been set for the session,
2. if not then check to see if this ip is in the middle of cookie detection
3. if not then redirect to a method and check again - if no cookies are on now, then be sure they are off.

Now you can either ask them to put them on to gain full functionallity of the application, or let the application blend out functions that cause UPDATE, PUT or DESTROY requests and instead show a flash error message that informs them of the reduced functionality.

This means that you will force a redirect on each request for browsers that have thier cookies off.

In the application.rb add the following:

before_filter :cookies_required, :except => [:check_for_cookies]

protected

def cookies_on?
..!request.cookies["_yourapp_session"].to_s.blank?
end

def cookies_required
..return unless request.cookies["_yourapp_session"].to_s.blank?
..if DetectCookie.find_and_destroy_or_create_by_remote_ip(request.remote_ip, request.request_uri) then return end
..session[:return_to] = request.request_uri
..redirect_to detect_cookies_path
end

>ruby script/generate model DetectCookie remote_ip:string request_uri:string
>rake db:migrate

Create a controller: dectect_cookies.rb
add the following:

class DetectCookiesController < ApplicationController
..before_filter :cookies_required, :except => :show

..def show
....if request.cookies["_hausursel_session"].to_s.blank? #change to your cookie session name
......detect_cookie=DetectCookie.find_by_remote_ip(request.remote_ip)
......detect_cookie ? redirect_to(detect_cookie.request_uri) : redirect_to(cookie_path)
....else
......redirect_back_or_default(:controller => 'apartments')
....end
..end
end

Add the following to the detect_cokkie.rb file in the models folder:

class DetectCookie < ActiveRecord::Base

..def DetectCookie.find_and_destroy_or_create_by_remote_ip(remote_ip, request_uri)
....if detect_cookie=DetectCookie.find_by_remote_ip(remote_ip)
......DetectCookie.destroy(detect_cookie.id)
......true
....else
......DetectCookie.create(:remote_ip=> remote_ip, :request_uri => request_uri)
......false
....end
..end

end

Simple Cookie Detect

2008-10-11T14:27:00.000-07:00

All PUT, UPDATE and DESTROY methods require the session cookie with protect_from_forgery or the application will break if a browser has cookies turned off when one of these methods are used.

Unfortunately, when a browser calls the application for the first time, the session cookie wil be written, but it wont be read untill the next page request. This makes it impossible to know if cookies are off, or of in the browser so anyone visiting the application first time and lets say, posts a form will be disapointed.

This is a simple solution to the problem. All controllers will call a cookies_required method when PUT, UPDATE or DESTROY methods are used. The cookies_required method looks to see it if the session cookie is empty - if it is, it will catch the http-referrer and redirect to the method check_for_cookies - if the session cookie is still empty, then we can be certain that cookies are off in the browser and refrain the user from using the PUT, UPDATE or DESTROY methods. Instead we show a message about cookies being off and the application having limited functionality untill they are turned on.

Add the following to application.rb

..before_filter :cookies_required, :except => [:show, :check_for_cookies]

..def check_for_cookies
....if request.cookies["_cookie_detect_session"].to_s.blank?
......render :text => 'You absolutly Need Cookies on to use this function'
....else
......redirect_back_or_default(:controller => 'home')
....end
..end

protected

..def cookies_required?
....return unless request.cookies["_cookie_detect_session"].to_s.blank?
....session[:return_to] = request.request_uri
....redirect_to(:controller => 'home',:action => 'check_for_cookies')
..end

..def redirect_back_or_default(default)
....session[:return_to] ? redirect_to(session[:return_to]) : redirect_to(default)
....session[:return_to] = nil
..end

Rails Security

2008-10-10T10:37:00.000-07:00

Great security guide

Javascript and RJS

2008-10-06T05:00:00.000-07:00

To descide how to handle javascript in ruby you should seperate between.

1. Effects (hide, show, highlight, fade ect), and
2. Interactive data (with or without visual effects)
3. Embedding Javascript the good old way.

1. Effects
Visual effects being anything that just tells the client side javascript engine to do somthing with one or more its DOM's.

2. Interactive Data
Interactive data, would be somthing like a calculating user input and diplaying the resulting sum in realtime.

3. Embedding Javascript the good old ways
If you like cluttering every things up javascript, you probably should not being using rails. Apart from needing a lot more programming time, and lines of code and making everything a millon times more dificult to test there is no reason what so ever to fall back to embedding javascript in the views as it used to be.

The difference between the 1 and 2 is that in the first case, you don't need to use an RJS file, whereas in the second case you will need and observer and an RJS file to handle the resulting data update when the observer registers user data changes in one or more input fields on a page.

Rails Javascript Engine.
==============
This engine can only do one thing. Wack out javascript to the client side browsers java engine for rendering. The Rails engine has no concept of the state of the page being manipulated by the client side browser java engine.

This means conditionals are not directly possible. i.e.
if page[:input_field_name] == 'red'
page[:input_field_name] = 'blue'

What you can do is this:
page << "if $(('input_field_name').value == 'red' {" # this is a straight javascript string which does not get interpreted page[:input_field_name]=='blue' # this get turned into a java script statement and sent to the client page << "}" # this is a straight javascript string which does not get interpreted and finishes the conditional

Note the conditional has nothing to do with rails - the engine in the browser interprests the code output by page.

Renanaming URL routes

2008-10-06T04:42:00.000-07:00

Renaming the URL'S defaults generated with the controllers.

i.e you have a resource you address in your code:

<% link_to("award", certificate_path(1)%>

This might be because you actually only have one certificate. You have the link on the page showing Awards, but when the user clicks on the link the URL will show:

/certificates/show/1

To change this you need to edit the routes.rb

map.resources :certificates

to the following:

map.the_certificate 'award', :controller => certificates, :action => 'show', id => 1
map.resources :certificates

Now you can change:

<% link_to("award", certificate_path(1)%> to <% link_to("award", the_certificate_path %>

NOTE 1:

doing this does not work properly:


map.certificate 'award', :controller => certificates, :action => 'show', id => 1
map.resources :certificates

i.e. trying to overwrite mapped resource with the same name to point to the proxy url.
It messes up when you render a form with somthing like
<% form for @certificate %>

NOTE:

Whenever you make any changes to the routes.rb file you will need to restart your server!!!!

Loading Tables with Defauls Application Data in Migrations

2008-10-06T03:10:00.000-07:00

1. Rake a migration to make the table
2. Make a new directory 'development_data' in app/db/migrate/
3. Make a YML file with the "tablename.yml" (check pural!) containing the default data for the table you need for the application (don't mix wiht test data)
4. Run rake db:migrate to create the tables and load them with the default data from the YML

==== Table Create Migration example

> ruby script/generate migration Certificates title:string description:text

==== YML example


certificate:
..id: 1
..title: "All About This Certificate"
..description: "Blah Blah."

..id: 2
..title: "All About This Certificate"
..description: "More Blah Blah."

==== Create Load Migration example
 
> ruby script/generate migration Certificates title:string description:text  
 
==== Load Data example


class LoadCertificatesData <>
..def self.up
....down
....directory=File.join(File.dirname(__FILE__),"development_data")
....Fixtures.create_fixtures(directory,"certificates")
..end

..def self.down
....Certificate.delete(:all)
..end
end


==== Load Data example

This strategy might fail over time if you are adding and deleting existing colums in migrations, so you might have to end up doing all your load migrations after all the structural migrations have finished. 
  
However, this might fail to if table relations ships are complex - so then you might have to fall back to an administration interface in the application where you build the tables from the YML file with your own programming.



Sessions and, or Cookies
2008-09-30T06:14:00.000-07:00
Rails 2.0 + uses a cookie on the client bowser to store session data. Sesion data is used to protect against misuse and data theft.

If the client browser has cookies disabled the application with throw an exception for any and all PUT, UPDATE and DESTROY requests.

To safeguard this you should diable any code that results in PUT, UPDATE and DESTROY requests if cookies are disabled in the browser client.

Just add a protected method in the application controller.

helper_method :cookies_on?
protected

def cookies_on?
..request.cookies["_appname_session"].to_s.include?('_appname_session')
end     

The "_appname_session" defalts to the name for your application and is defined in the app/config/environment.rb

config.action_controller.session = {
  :session_key => '_appname_session',
  :secret      => 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
}

In your controllers and views you can now write:

<% if cookies_on? %>
     # show the form with the submit button
<% else %>
     # show the form without the submit button and display a message telling the user that this site protects the identiy of users with coded cookies and they cannot sumbit the form without cookies enabled in the browser.
<% end %>

As the session cookie won't be avilable until the user has loaded at least two pages of your application, until then your application will be in a state of "cookies disabled".

This is all a bit of a pain, especially in the light of mobile browsers, most of which do not support cookies. However in the light of data protection, there is a real need to come up with practices to deal with this. And rails does a great job - so lets not get pissed off with rails, but more with the twits that seem to think the web is some sort of data free for all.

BTW: Setting your own cookie is as easy as
cookies [:my_name_of_cookie]="hello this string will now be in a cookie in the users browser"

The next time the user views somthing you can read the cookie:
value=cookies[:my_name_of_cookie]
puts value -> "hello this string will now be in a cookie in the users browser"




Rake migrations effecting exisitng tables
2008-09-30T00:01:00.000-07:00
Things that can done:

Adding a new table, Removing a table, Adding a column to an existing table, Removing a column, Renaming a column, Renaming a table, Adding an index, Adding a primary key.

>ruby script/generate migrtion add_price

This creates a new migration file in db/migrations

class AddPrice
...def self.up
.....add_column :products, :price, decimal, :precision => 8, :scale => 2, :default => 0
...end

...def self.down
  ......remove_column :products, :price
...end
end




error_messages_on
2008-09-20T10:34:00.001-07:00
BIG GOTCHA!

1. don't use redirect_to in the controller otherwise the view wont get, i.e. display the error message. user ender instead. 

2. error_messages_on wants the name of the instance variable used in the controller, ie if you use, 

error_messages_on 'instance_variable'

then make sure you use
@instance_variable in your controller code. Its this vairable that has the method @instance_vaiable.errors which error_on_messages uses.




Capistrano Deployment.
2008-09-19T00:52:00.000-07:00
Capistrano gets the latest version of the application from a given reposity and puts it online under a specific web domain.

Install Capistrano
1. install gem >gem install capistrano
2. check that worked out >cap -h

Setup app for Capistrano
1. in root directory of the application>capify

Configure Capistrano
(don't use cap deploy:cold - which is suposed to workout the configuration - you have to do the following once)
1. in app/config - edit the deploy.rb file

set :application, "nameofapp"
#Note: This will also be the name of the directory created for the app files
set :repository, "git@git.whateverthedomainis:whateverthenameis.git
#Note: This is the location of the repository of the application
set :deploy_to, "/full/path/from/server/root/directory/to/app/directory/on/server/#{application}
#Note: This is absolute location on the server where the application root directoy will be placed after being fetched from the repository
set :scm, :git
#Note: This is the resposity type (in this case a git)
set :scm_user, "name"
#Note: This is the user_name that is needed to access the repository. note: the need for a password is normally replaced by a ssh public key

set :user, "name"
#Note: This is the ssh username for the domain i.e. >ssh username@yourdomain.com

set :use_sudo, false
#Note: Capistrano will want to make some directorys on the server, it this is set to true it will use sudo before making them. I suggest to keep this false - capistrano does not need it and less things can go wrong, especially the first time.

set :branch, "whateverbranch"
#Note: The deal here is that after capistrano has cloned the repository on the server is will checkout this branch. I could not get this to work - and so expect the last version of the master branch to be checked out (at least with git and v2.5 of capistrano)

role :app, "yourdomain" # i.e. www.whatever.com
#Note: This is the address of the server that hosts the application server (i.e. mongrel, mod_rails etc)
role :web, "yourdomain" # i.e. www.whatever.com
#Note: This is the address of the server that hosts the webserver server (i.e. apache, etc)
role :db, "yourdomain" , :primary => true # i.e. www.whatever.com
#Note: This is the address of the server that hosts the database (i.e. mysql, postresql)
#Note: The :primary tells capistrano which server to run any migrations against.

Setup publickey of your server to access the application repository. 
1. Login to server with a ssh shell session (i.e. >ssh name@dominnameofserver (i.e. ssh me@happy.com)) - If you are not working with public keys, then you should be asked for the password to access - after entering it you should be it.

2. cd to home on the server >cd

3. cd to the .ssh directory > cd .ssh
#Note: check for a file id_rsa.pub if its not there, then run ssh-keygen (just enter return at prompts)

3. enter on command line >more id_rsa.pub

4. Copy the key and add it to your existing repository key
Note: github.com and assembla.com have a web interface for your to do that if your repository is hosted there.
 
5. Check that that works by cloning the application repository by hand on the server

Freeze Rails. 

>rake rails:freeze:gems

Vendorize gems #TODO.
If you are using gems but cannot install them on a sharehost then you have the option to vendorize them.

>rake gems:install
>rake gems:unpack:dependencies
>rake gems:build

Make Spin Script. 
This is a small script in app/script/ called spin.rb
This script is called by capistrano after the app has been deployed to start the app and web server

#!/bin/sh

#{deploy_to}/current/script/process/spawner \
  mongrel \
  --environment=production \
  --instances=1 \
  --address=127.0.0.1 \
  --port=#{port}

(#TODO Check the above)

Update Git repository. 

git add .
git commit -m 'ready to deploy'
git push origin master

Deploy Setup. 

git add .
git commit -m 'ready to deploy'
git push origin master

cap deploy:setup

Check Dependencies. 

cap deploy:check

Deploy the Update. 
 
cap deploy:update

Server stuff. 
  open a shh session on the server

>shh name@domin.xx
>cd to your app root directy
>rake RAILS_ENV=production db:schema:load
note: If this does not work - then obviously you will have to find out why and fix it before continuing.
>script/console production
note: The production environment should load up without any errors.
>>app.get("/")
note: This should return a status code of 200, 302 or similar.

Deploy Start. 
   On the local machine:

>cap deploy:start
note: This should return a status code of 200, 302 or similar.

Now everthing should have fired up and be working. 


Developing Rails Plugins with RSpec
2008-09-02T13:08:00.000-07:00
To use RSpec while developing plugins install this rspec generator plugin as follows.

Install RSpec Plugin
script/plugin install git://github.com/pat-maddox/rspec-plugin-generator.git

Create Plugin Framework
script/generate rspec_plugin new_fu

Setup Autotesting
create a file: discover.rb to vendor/plugins/new_fu/lib/autotest/

insert the following at the top of the discover.rb file:
  $:.push(File.join(File.dirname(__FILE__), %w[.. .. rspec]))
  Autotest.add_discovery do
    rspec
  end

create a spec.opts file in the plugin/new_fu/spec folder and add the following:
--colour
--format progress
--loadby mtime
--reverse

Set Plugin Location
This avoids naming conflicts with other plugins.
create a directory structure within nuw_fu/lib somthing like this.
your_name/name_or_your_company

Now move the new_fu.rb file into the directory name_of_your_company.

Your new_fu.rb file should now be in
app/vendors/plugins/new_fu/your_name/name_of_your_company/new_fu.rb

Start Autotest for Apllication
Open a terminal window and go to the root of your apllication
first type: rake spec
It should run through and sync the app with your rspec environment
Then type: autotest
The autostest should start and re-run everytime you change a file in your application

Set test environment
open a terminal window - locate the base of your app and type:
export RAILS_ENV=test 

Start Autotest for Plugin
Open a terminal window and go to the root of your plugin directory
app/vendor/plugins/new_fu/
and type in autotest
The autostest should start and re-run everytime you change a file in your plugin

Set up Plugin init.rb file. 
Locate the init.rb file in vendor/plugins/new_fu
add: include 'your_name/name_of_your_company/new_fu'

Set up Plugin as a module 
Open your plugin file
vendor/plugins/new_fu/your_name/name_of_your_company/new_fu.rb
add the following.

.module YourName
....module NameOfYourCompany
.......module NewFu
.
...........def hello_world
..............puts "Hello World"
...........end
.
......end
...end
.end

Then in the new_fu_spec.rb file - located in vendor/plugins/new_fu/spec/ - add the following:

.require File.dirname(__FILE__) + '/spec_helper'
.
.describe YourName::NameOfYourCompany::NewFu, "" do
......include YourName::NameOfYourCompany::NewFu
.
......before do
......end
.
......it "should should say hello world" do
........hello_world
.....end
.
.end

The autotest should have passed on the tests and you should see "hello world" somewhere in the output.

######## To Be Continued.....
Further documentation.
Understanding and building plugins - Part I
Understanding and building plugins - Part II
Creating Plugins Manual
Autotesting while writing Rails Plugins



Rspec Helper Extention
2008-09-01T07:45:00.000-07:00
Additional Helper Methods (except, with, only) in spec_helper.rb file in project_folder/spec/

class Hash

 # filter key out of a hash
 # {:a=>1, :b=> 2, :c=> 3}.except(:a)
 # results of hash after call {:b=> 2, :c=> 3 }

 def except(*keys)
   self.reject { |k,v| keys.include?(k || k.to_sym) }
 end

 # override some keys with a new value
 # {:a=>1, :b=> 2, :c=> 3}.with(:a => 4)
 # results of hash after call {:a => 4, :b=> 2, c: => 3 }
 def with(overrides = {})
   self.merge overrides
 end

 # return a hash with only the pairs identified by the +keys+
 # { :a=>1, :b=>2, :c=>3}.only(:a)
 # results of hash after call {:a=>1}
 def only(*keys)
   self.reject { |k,v| !keys.include?(k || k.to_sym ) }
 end

end




Setting the Test, Production, Development Environment
2008-08-30T11:27:00.000-07:00
>export RAILS_ENV=test    
>export RAILS_ENV=development
>export RAILS_ENV=production





RSpec CheatSheet
2008-08-30T10:11:00.000-07:00


















>rake -T spec (output of the available rake tasks for rspec)
>ruby script/spec -h (output availble plugin rspec options)
>ruby script/generate (shows the rspec generators that replace the normal rails generators)
(i.e. ruby script/generate rspec_scaffold will show the available options)
>rake doc:plugins (generate the rspec documentation in doc/plugins/rspec-rails/index.html)
>rake spec (sync the development environement with the test environment before running autotest)
>autotest (starts the background testing)

IMPORTANT: Set the test rspec it set up to work in the test environment, so make sure it has been set
Also see extention spec helper methods post



Git CheatSheet
2008-08-30T06:35:00.000-07:00














.gitignore contains the ignore files (add *.log, .DS_Store, config/database.yml)
>git init
>git add .
>git add "file name"
>git status
>git --global user.name "name"
>git --global user.email "email"
>git --global apply.whitespace nowarn
>git commit -m "message describing this commit" or git commit -v (shows you the diffs done and lets you write your commit mesage)
>git commit -a (commit all files that have been changed)
>git commit -a -v (commit all files and show diffs that have been changed)
>git log (give ascii log with messages)
>git log --stat (ascii output graph of the file changes with + and -)
>git log --p (see the diffs of the files)
>gitk (launch a visual tool of the git log). >gitk & to run in the background
>gitk -all (all local and remote branches)
>git branch (show the current branches)
>git branch --color (shows local and remote branches in color)
>git branch "name of branch" (creates a new branch)
>git branch -a (shows all local and remote branches)
>git checkout "name of branch" (to work on the named branch)
>git rebase "name of another branch" (get current changes from another branch into my working branch)
>git diff "branch 1" "branch2" (show the diffs of 2 branches) or pipe to TextMate with git diff "branch1" "branch2" | mate
>git merge branch (merges branch into current branch)
>git reset --hard ORIG_HEAD (revert the merge)
>git stash "message" (save current status of work to a "clipboard")
>git stash list (show the contents of the clipboard)
>git stash apply (bring the status in the clipboard)
>git branch -d branchname (delete a previously merged branch)
>git branch -D branchname (delete a non merged branch)
>git stash clear (clearsout the stach clipboard)

Repositories
copy project to another machine (cp -r or scp -r)
>git clone remotemachineurl (gets a copy of the remote repository from the remote machine)
>git fetch (get a copy of all objects from the remote machine - don't merge with local machine)
>git pull (syncronizes fetches changes from the remote machine with the local machine with the branch I am currently in)
>git push  (syncronize local changes back to the remote machine)
>git merge (local merging of 2 branches)
>git remote show name_of_repository (shows some info on the branches in the remote repository)




Setup New Rails Project
2008-08-30T05:40:00.000-07:00
Create a new project with: >rails name_of_project, then: >cd name_of_project
Optionally if using other database than Sqlite: > rake db:create:all
Install RSpec Plugin & Framework. Refer to the latest instructions. 
Run the RSpec generator to create framework: >ruby script/generate rspec
Create latest plugin documents on local drive with: rake doc:plugins. Location of documentation is "name_of_project/doc/plugins/respec-rails/index.html. Open directly in browser with: open -a Firefox doc/plugins/rspec_on_rails/index.html. Or open index.html
Install and run RSpec plugin framework if needed
Create the git repository with a cd to the "name_of_project" directory and then: 
          >git config --global user.name "your name"
          >git config --global user.email "your mail@provider"
          >git config --global apply.whitespace nowarn

         to check the settings see .gitconfig or: >git config --list

         >git init     (creates local repository and the .git directory)

         create a .gitignore file and add file to ignore 
         *.log
         database.yml
         db/schema.*
         .DS_Store

        >git add .    (add all file and contents to firstime checkin)
        >git commit -m "first commit"
        >git status (check the repos)

see git cheatsheet for more



Setup Rails 2.1 on Mac Leopard
2008-08-30T04:19:00.000-07:00
A version of rails and gem is already installed on the mac so we will update and expand on this installation as follows
Get and Install TextMate
Get and Download MacPorts - Leopard (universal). After the download and installation, edit or add to .bash_profile file the following: export PATH="/opt/local/bin:/opt/local/sbin:$PATH" (see here for more details) 
Update macports from the command line terminal with: >sudo port selfupdate. NOTE: I had a problem with awk not being found during the installation. This was solved by running the installation again. 
Install Git and Svn integration as follows: >sudo port install git-core +doc +svn
Update gems with: >sudo gem update
Install Rspec gem with: > sudo gem install rspec
Install Zentest with: >sudi gem install ZenTest. You don't need to install the gem if you are only using rails. Zentest enables autotesting in the background.
Install Rspec TextMate bundle specifically for rails supporting development: cd to the TextMate Bundles directory, i.e. > cd ~/Library/Appliction\Support/TextMate/Bundles. Then: > git git clone git://github.com/dchelimsky/rspec-tmbundle.git RSpec.tmbundle



composed_of
2008-07-12T02:05:00.000-07:00
class CurrencyRate < ActiveRecord::Base
  composed_of :country_rate,  :mapping => [%w(rate c_rate) , %w(currency c_currency)]
end

composed_of :value_object_name, :mapping =>
[%w(db_column_name_1 @instance_var_name_1) %w(db_column_name_2 @instance_var_name_2)]

important: composed_of gives the class object CurrencyRate 2 new methods,
country_rate and country_rate=
the order of the mapping determines the order  in which  country_rate=  receives its values and how the values will be mapped to the database table.


class CountryRate                              #this is the value object aggregated by CurrencyRate
       attr_accessor :c_rate, :c_currency

        def initialize(rate,currency="USD")
        @c_rate, @c_currency=rate,currency
      end
end

class CreateCurrencyRates < ActiveRecord::Migration   #This is the table
  def self.up
    create_table :currency_rates do |t|
      t.string :base_currency
      t.string :currency
      t.float :rate

      t.timestamps
    end
  end

  def self.down
    drop_table :currency_rates
  end
end

######### How it is used

cur=CurrencyRate.new(:base_currency =>"DKK")
cur.country_rate=CountryRate.new(12.4 , "YPN")
cur.save

######## What happens

cur=CurrencyRate.find(:first)       # lets find a CurrencyRate object to change
                                                               #  direct access methods have been stripped
cur.rate=123                                       # <- undefined method
cur.country_rate.rate=123              # <- no method error
cur.country_rate.c_rate=123          # <- can' modify frozen object

####The correct way to access is as follows

cur.base_currency="YPN"
cur.country_rate=CountryRate.new(345,"PLN") 
cur.save                                                # now the

#####before, the database looks like this

id                    base_currency                 rate                        currency
1                      DKK                                  12.4                       YPN

####after, it looks like this

id                   base_currency                rate                         currency
1                     YPN                                  345.0                       PLN


Just for claritys sake.

CurrencyRate is a class with one instance var base_currency
CountryRate is a class with  two instance vars  c_rate and c_currency

with the composed_of method CountryRate has become a value object.
Value Objects: equality is determined by value - (represented by their  value)
Entity Objects: equality is determined by identity - (represented by their primary keys)


Modeling Rails
2008-07-10T05:43:00.000-07:00
Modeling Rails.

Basically, objects can connect to other objects in 3 different ways.
1. By relationship (i.e. person has one favorite book # person belongs_to favorite_book)
2. By inheritance  (i.e. author is a person # class Author < Person
3. By Aggregation  (i.e Invoice contains a list of items(objects) that have been aggrigated from other objects. composed_of :item :model => "Book"

When writing in rails model the application first.

1. map out the objects & their attributes for the application (i.e)
   Customers   : first_name, last_name, address
   Books       : author, title, price, EAN number
   Invoice      : customer, invoice_number, book

2. then map out the model connections
   Customers (1---------n) Invoices
   Customer  (1---------1) Favorite_book
   Invoice   (1---------.) Books (invoice aggregates and copies the attributes of a book when added to an order).

3. Then think about how the objects and relationships can be mapped to the database (through active record).
   i.e. which tables have which columns and how the models relate to each other - belongs_to, has_many, has_many_and_belongs_to, composed_of


Rails Mapping Routes
2008-07-09T02:11:00.002-07:00

Mapping Routes Examples



Mapping Objects on Rails
2008-07-09T02:11:00.001-07:00
Mapping Objects Examples


Model Code Snippets
2008-07-09T01:28:00.000-07:00
def Order < ActiveRecord::Base
 has_many :line_items
 belongs_to :customer   # there's a column "customer_id" in the db table
end

def LineItem < ActiveRecord::Base
 belongs_to :order # there's a column "order_id" in the db table
end

def Customer < ActiveRecord::Base
 has_many :orders
 has_one :address
end

def Address < ActiveRecord::Base
 belongs_to :customer
end

belongs_to  :some_model,
       :class_name  => 'MyClass',      # specifies other class name
       :foreign_key => 'my_real_id',   # and primary key
       :conditions  => 'column = 0'    # only finds when this condition met

has_one :some_model,
       # as belongs_to and additionally:
       :dependent   => :destroy        # deletes associated object
       :order       => 'name ASC'      # SQL fragment for sorting

has_many :some_model
       # as has_one and additionally:
       :dependent => :destroy          # deletes all dependent data
                                       # calling each objects destroy
       :dependent => :delete_all       # deletes all dependent data
                                       # without calling the destroy methods
       :dependent => :nullify          # set association to null, not
                                       # destroying objects
       :group => 'name'                # adds GROUP BY fragment
       :finder_sql => 'select ....'    # instead of the Rails finders
       :counter_sql => 'select ...'    # instead of the Rails counters


validates_presence_of :firstname, :lastname     # must be filled out

validates_length_of :password,
                   :minimum => 8           # more than 8 characters
                   :maximum => 16          # shorter than 16 characters
                   :in => 8..16            # between 8 and 16 characters
                   :too_short => 'way too short'   
                   :too_long => 'way to long'

validates_acceptance_of :eula               # Must accept a condition
                       :accept => 'Y'      # default: 1 (ideal for a checkbox)

validates_confirmation_of :password    
# the fields password and password_confirmation must match

validates_uniqueness_of :user_name              # user_name has to be unique
                       :scope => 'account_id'  # Condition:
                                               # account_id = user.account_id

validates_format_of :email          # field must match a regular expression
                   :with => /^(+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i

validates_numericality_of   :value                  # value is numeric
                           :only_integer => true  
                           :allow_nil => true     

validates_inclusion_of  :gender,    # value is in enumeration
                       :in => %w( m, f )

validates_exclusion_of  :age            # value is not in Enumeration
                       :in => 13..19   # don't want any teenagers

validates_associated :relation 
# validates that the associated object is valid

Options for all validations above:
:message => 'my own errormessage'   # eigene Fehlermeldung
:on      => :create                 # or :update (validates only then)
:if      => ...                     # call method oder Proc



ActiveRecord::Base
2008-07-08T13:20:00.000-07:00
These are the public instance methods available for the model classes.
Model Methods
<
<=
<=>
==
===
=~
>
>=
__id__
__send__
`
abstract_class
abstract_class=
abstract_class?
accessible_attributes
active_connection_name
active_connections
acts_like?
add_observer
after_create
after_create_callback_chain
after_destroy
after_destroy_callback_chain
after_find
after_find_callback_chain
after_initialize
after_initialize_callback_chain
after_save
after_save_callback_chain
after_update
after_update_callback_chain
after_validation
after_validation_callback_chain
after_validation_on_create
after_validation_on_create_callback_chain
after_validation_on_update
after_validation_on_update_callback_chain
aggregate_mapping
alias_attribute
alias_method_chain
all
allocate
allow_concurrency
allow_concurrency=
ancestors
as_load_path
attr_accessible
attr_accessor_with_default
attr_internal
attr_internal_accessor
attr_internal_naming_format
attr_internal_naming_format=
attr_internal_reader
attr_internal_writer
attr_protected
attr_readonly
attribute_method_suffix
attribute_types_cached_by_default
attribute_types_cached_by_default=
autoload
autoload?
average
b64encode
base_class
before_create
before_create_callback_chain
before_destroy
before_destroy_callback_chain
before_save
before_save_callback_chain
before_update
before_update_callback_chain
before_validation
before_validation_callback_chain
before_validation_on_create
before_validation_on_create_callback_chain
before_validation_on_update
before_validation_on_update_callback_chain
belongs_to
benchmark
blank?
breakpoint
cache
cache_attribute?
cache_attributes
cached_attributes
calculate
cattr_accessor
cattr_reader
cattr_writer
changed
changed?
class
class_eval
class_inheritable_accessor
class_inheritable_array
class_inheritable_array_writer
class_inheritable_hash
class_inheritable_hash_writer
class_inheritable_reader
class_inheritable_writer
class_name
class_name_of_active_record_descendant
class_of_active_record_descendant
class_variable_defined?
class_variables
clear_active_connection_name
clear_active_connections!
clear_reloadable_connections!
clone
colorize_logging
colorize_logging=
column_methods_hash
column_names
columns
columns_hash
composed_of
compute_type
configurations
configurations=
connected?
connection
connection=
const_defined?
const_get
const_missing
const_set
constants
construct_calculation_sql
construct_count_options_from_args
content_columns
copy_instance_variables_from
count
count_by_sql
count_observers
create
create!
create_reflection
current_scoped_methods
daemonize
dclone
debugger
decode64
decode_b
decrement_counter
default_timezone
default_timezone=
define_attribute_methods
define_callbacks
define_read_methods
delegate
delete
delete_all
delete_observer
delete_observers
deprecate
deprecated_method_warning
deprecation_horizon
descends_from_active_record?
destroy
destroy_all
display
dup
duplicable?
enable_warnings
encode64
encode_quoted_value
enum_for
eql?
equal?
establish_connection
execute_grouped_calculation
execute_simple_calculation
exists?
expand_hash_conditions_for_aggregates
expand_range_bind_variables
extend
extend_with_included_modules_from
extended_by
find
find_by_sql
find_hidden_method
finder_needs_type_condition?
first
freeze
frozen?
gem
generated_methods
generated_methods?
get_primary_key
has_and_belongs_to_many
has_many
has_one
hash
human_attribute_name
id
include?
include_root_in_json
include_root_in_json=
included_in_classes
included_modules
increment_counter
inheritable_attributes
inheritance_column
inheritance_column=
inherited
inspect
instance_eval
instance_exec
instance_method
instance_method_already_implemented?
instance_methods
instance_of?
instance_values
instance_variable_defined?
instance_variable_get
instance_variable_names
instance_variable_set
instance_variables
instantiate_observers
is_a?
json_class_name
kind_of?
last
load
local_constant_names
local_constants
lock_optimistically
lock_optimistically=
locking_column
locking_column=
locking_enabled?
log_connections
logger
logger=
match_attribute_method?
mattr_accessor
mattr_reader
mattr_writer
maximum
method
method_added
method_defined?
methods
minimum
module_eval
mysql_connection
name
named_scope
new
nil?
notify_observers
object_id
observers
observers=
parent
parents
partial_updates
partial_updates=
partial_updates?
pluralize_table_names
pluralize_table_names=
preload_associations
primary_key
primary_key=
primary_key_prefix_type
primary_key_prefix_type=
private_class_method
private_instance_methods
private_method_defined?
private_methods
protected_attributes
protected_instance_methods
protected_method_defined?
protected_methods
public_class_method
public_instance_methods
public_method_defined?
public_methods
quote_bound_value
quote_value
quoted_locking_column
quoted_table_name
rails_original_const_missing
raise_if_bind_arity_mismatch
read_inheritable_attribute
readonly_attributes
record_timestamps
record_timestamps=
reflect_on_aggregation
reflect_on_all_aggregations
reflect_on_all_associations
reflect_on_association
reflections
remove_class
remove_connection
remove_subclasses
remove_subclasses_of
replace_bind_variables
replace_named_bind_variables
require
require_association
require_dependency
require_library_or_gem
require_mysql
require_or_load
reset_column_information
reset_column_information_and_inheritable_attributes_for_all_subclasses
reset_inheritable_attributes
reset_locking_column
reset_primary_key
reset_sequence_name
reset_subclasses
reset_table_name
respond_to?
retrieve_connection
returning
sanitize
sanitize_conditions
sanitize_sql
sanitize_sql_array
sanitize_sql_for_assignment
sanitize_sql_for_conditions
sanitize_sql_hash
sanitize_sql_hash_for_assignment
sanitize_sql_hash_for_conditions
schema_format
schema_format=
scope
scoped
scoped?
scoped_methods
scopes
send
send!
sequence_name
sequence_name=
serialize
serialized_attributes
set_inheritance_column
set_locking_column
set_primary_key
set_readonly_option!
set_sequence_name
set_table_name
silence
silence_stderr
silence_stream
silence_warnings
single_threaded_active_connections
single_threaded_scoped_methods
singleton_methods
skip_time_zone_conversion_for_attributes
skip_time_zone_conversion_for_attributes=
sti_name
store_full_sti_class
store_full_sti_class=
store_full_sti_class?
subclasses
subclasses_of
sum
superclass
superclass_delegating_accessor
superclass_delegating_reader
superclass_delegating_writer
suppress
table_exists?
table_name
table_name=
table_name_prefix
table_name_prefix=
table_name_suffix
table_name_suffix=
taguri
taguri=
taint
tainted?
thread_safe_active_connections
thread_safe_scoped_methods
time_zone_aware_attributes
time_zone_aware_attributes=
to_a
to_enum
to_json
to_param
to_query
to_s
to_yaml
to_yaml_properties
to_yaml_style
transaction
type
uncached
unloadable
untaint
update
update_all
update_counters
update_counters_with_lock
update_counters_without_lock
validate
validate_callback_chain
validate_find_options
validate_on_create
validate_on_create_callback_chain
validate_on_update
validate_on_update_callback_chain
validates_acceptance_of
validates_associated
validates_confirmation_of
validates_each
validates_exclusion_of
validates_format_of
validates_inclusion_of
validates_length_of
validates_numericality_of
validates_presence_of
validates_size_of
validates_uniqueness_of
verification_timeout
verification_timeout=
verify_active_connections!
with_exclusive_scope
with_options
with_scope
write_inheritable_array
write_inheritable_attribute
write_inheritable_hash
yaml_as
yaml_tag_class_name
yaml_tag_read_class
yaml_tag_subclasses?


ActionView Base
2008-07-08T13:12:00.000-07:00
These are the public instance methods available for view (i.e. when templates are being rendered).
View Methods
<
<=
<=>
==
===
=~
>
>=
__id__
__send__
`
acts_like?
alias_attribute
alias_method_chain
allocate
ancestors
as_load_path
attr_accessor_with_default
attr_internal
attr_internal_accessor
attr_internal_naming_format
attr_internal_naming_format=
attr_internal_reader
attr_internal_writer
autoload
autoload?
b64encode
blank?
breakpoint
cache_template_extensions=
cache_template_loading
cache_template_loading=
cattr_accessor
cattr_reader
cattr_writer
class
class_eval
class_inheritable_accessor
class_inheritable_array
class_inheritable_array_writer
class_inheritable_hash
class_inheritable_hash_writer
class_inheritable_reader
class_inheritable_writer
class_variable_defined?
class_variables
clone
computed_public_paths
const_defined?
const_get
const_missing
const_set
constants
copy_instance_variables_from
daemonize
dclone
debug_rjs
debug_rjs=
debugger
decode64
decode_b
default_form_builder
default_form_builder=
delegate
deprecate
deprecated_method_warning
deprecation_horizon
display
dup
duplicable?
enable_warnings
encode64
enum_for
eql?
equal?
erb_trim_mode
erb_trim_mode=
erb_variable
erb_variable=
extend
extend_with_included_modules_from
extended_by
field_error_proc
field_error_proc=
find_hidden_method
freeze
frozen?
full_sanitizer
full_sanitizer=
gem
hash
helper_modules
id
include?
included_in_classes
included_modules
inheritable_attributes
inspect
instance_eval
instance_exec
instance_method
instance_methods
instance_of?
instance_values
instance_variable_defined?
instance_variable_get
instance_variable_names
instance_variable_set
instance_variables
is_a?
kind_of?
link_sanitizer
link_sanitizer=
load
local_constant_names
local_constants
mattr_accessor
mattr_reader
mattr_writer
method
method_added
method_defined?
method_names
method_names=
methods
module_eval
name
new
nil?
object_id
parent
parents
private_class_method
private_instance_methods
private_method_defined?
private_methods
protected_instance_methods
protected_method_defined?
protected_methods
public_class_method
public_instance_methods
public_method_defined?
public_methods
rails_original_const_missing
read_inheritable_attribute
remove_class
remove_subclasses
remove_subclasses_of
require
require_association
require_dependency
require_library_or_gem
require_or_load
reset_inheritable_attributes
respond_to?
returning
sanitized_allowed_attributes
sanitized_allowed_attributes=
sanitized_allowed_css_keywords
sanitized_allowed_css_keywords=
sanitized_allowed_css_properties
sanitized_allowed_css_properties=
sanitized_allowed_protocols
sanitized_allowed_protocols=
sanitized_allowed_tags
sanitized_allowed_tags=
sanitized_bad_tags
sanitized_bad_tags=
sanitized_protocol_separator
sanitized_protocol_separator=
sanitized_shorthand_css_properties
sanitized_shorthand_css_properties=
sanitized_uri_attributes
sanitized_uri_attributes=
send
send!
silence_stderr
silence_stream
silence_warnings
singleton_methods
subclasses
subclasses_of
superclass
superclass_delegating_accessor
superclass_delegating_reader
superclass_delegating_writer
suppress
taguri
taguri=
taint
tainted?
to_a
to_enum
to_json
to_param
to_query
to_s
to_yaml
to_yaml_properties
to_yaml_style
type
unloadable
untaint
white_list_sanitizer
white_list_sanitizer=
with_options
write_inheritable_array
write_inheritable_attribute
write_inheritable_hash
yaml_as
yaml_tag_class_name
yaml_tag_read_class
yaml_tag_subclasses?


ApplicationController
2008-07-08T12:32:00.000-07:00
These are the ancestors of the ApplicationController (i.e rails controller classes) and the available public instance methods. This as least helps me to understand the range of methods available which makes the API much more understandable.

Controller Methods
<
<=
<=>
==
===
=~
>
>=
__id__
__send__
`
action_methods
acts_like?
add_template_helper
after_filter
after_filters
alias_attribute
alias_method_chain
allocate
allow_concurrency
allow_concurrency=
allow_forgery_protection
allow_forgery_protection=
ancestors
append_after_filter
append_around_filter
append_before_filter
append_view_path
around_filter
as_load_path
asset_host
asset_host=
attr_accessor_with_default
attr_internal
attr_internal_accessor
attr_internal_naming_format
attr_internal_naming_format=
attr_internal_reader
attr_internal_writer
autoload
autoload?
b64encode
before_filter
before_filters
benchmark
blank?
breakpoint
cache_configured?
cache_page
cache_store
cache_store=
cache_sweeper
cached_session_options
caches_action
caches_page
cattr_accessor
cattr_reader
cattr_writer
class
class_eval
class_inheritable_accessor
class_inheritable_array
class_inheritable_array_writer
class_inheritable_hash
class_inheritable_hash_writer
class_inheritable_reader
class_inheritable_writer
class_variable_defined?
class_variables
clone
consider_all_requests_local
consider_all_requests_local=
const_defined?
const_get
const_missing
const_set
constants
controller_class_name
controller_name
controller_path
copy_instance_variables_from
daemonize
dclone
debug_routes
debug_routes=
debugger
decode64
decode_b
default_charset
default_charset=
default_layout
delegate
deprecate
deprecated_method_warning
deprecation_horizon
display
dup
duplicable?
enable_warnings
encode64
enum_for
eql?
equal?
exempt_from_layout
expire_page
extend
extend_with_included_modules_from
extended_by
filter_chain
filter_parameter_logging
find_hidden_method
fragment_cache_store
fragment_cache_store=
freeze
frozen?
gem
hash
helper
helper_attr
helper_method
helpers
hidden_actions
hide_action
id
include?
included_in_classes
included_modules
inheritable_attributes
inspect
instance_eval
instance_exec
instance_method
instance_methods
instance_of?
instance_values
instance_variable_defined?
instance_variable_get
instance_variable_names
instance_variable_set
instance_variables
is_a?
kind_of?
layout
layout_conditions
layout_list
load
local_constant_names
local_constants
logger
logger=
master_helper_module
master_helper_module=
mattr_accessor
mattr_reader
mattr_writer
method
method_added
method_defined?
methods
module_eval
name
new
nil?
object_id
optimise_named_routes
optimise_named_routes=
page_cache_directory
page_cache_directory=
page_cache_extension
page_cache_extension=
param_parsers
param_parsers=
parent
parents
perform_caching
perform_caching=
prepend_after_filter
prepend_around_filter
prepend_before_filter
prepend_view_path
private_class_method
private_instance_methods
private_method_defined?
private_methods
process
process_cgi
process_with_components
process_with_exception
protect_from_forgery
protected_instance_methods
protected_method_defined?
protected_methods
public_class_method
public_instance_methods
public_method_defined?
public_methods
rails_original_const_missing
read_inheritable_attribute
remove_class
remove_subclasses
remove_subclasses_of
request_forgery_protection_options
request_forgery_protection_options=
request_forgery_protection_token
request_forgery_protection_token=
require
require_association
require_dependency
require_library_or_gem
require_or_load
rescue_from
rescue_handlers
rescue_handlers=
rescue_responses
rescue_responses=
rescue_templates
rescue_templates=
reset_inheritable_attributes
resource_action_separator
resource_action_separator=
resources_path_names
resources_path_names=
respond_to?
returning
send
send!
session
session=
session_options
session_options_for
session_store
session_store=
silence
silence_stderr
silence_stream
silence_warnings
singleton_methods
skip_after_filter
skip_before_filter
skip_filter
subclasses
subclasses_of
superclass
superclass_delegating_accessor
superclass_delegating_reader
superclass_delegating_writer
suppress
taguri
taguri=
taint
tainted?
to_a
to_enum
to_json
to_param
to_query
to_s
to_yaml
to_yaml_properties
to_yaml_style
type
unloadable
untaint
verify
view_paths
view_paths=
with_options
write_inheritable_array
write_inheritable_attribute
write_inheritable_hash
yaml_as
yaml_tag_class_name
yaml_tag_read_class
yaml_tag_subclasses?


named_scope
2008-06-26T22:47:00.000-07:00
in the *.rb models

Class Profile << ActiveRecord::Base
  belongs_to: user
  belongs_to: team
  named_scope :captain, :conditions => { :role => "captain" }
  named_scope :liverpool, :include :team, :conditions => { 'teams.name' => 'liverpool' }
end

This allows following:

user.profile.liverpool #-> finds all user profiles that are in the team liverpool
user.profile.captain #-> finds all user profiles that have the role of captain.


Methods, Calls, Blocks, Closures & Lambda
2008-06-26T22:39:00.000-07:00
Excellent excellent article!!

http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Method_Calls


STUCK things
2008-06-24T07:25:00.000-07:00
Associations.
==========

What i want to do....

current_user.following_users.messages

This should deliver a bunch of messages from all the users that the current user is following (a la twitter).

I can't get it to work for the life of me.

################################Here the migrations.

User

create_table "users", :force => true do |t|
   t.column :login,                     :string
   t.column :email,                     :string
   t.column :crypted_password,          :string, :limit => 40
   t.column :salt,                      :string, :limit => 40
   t.column :created_at,                :datetime
   t.column :updated_at,                :datetime
   t.column :remember_token,            :string
   t.column :remember_token_expires_at, :datetime
   t.column :activation_code, :string, :limit => 40
   t.column :activated_at, :datetime  
 end

Message

   create_table :messages do |t|
   t.string :message
   t.integer :user_id
   t.integer :movie_id
   t.timestamps
 end

Following

 create_table :followings do |t|
   t.integer :follower_user_id
   t.integer :following_user_id

   t.timestamps
 end

#############################Here the Models

User

class User < foreign_key =""> :following_user_id,   :class_name => "Following"
has_many :follower_users,:foreign_key => :follower_user_id, :class_name => "Following"
has_many :messages
has_many :messages, :through => :follower_users,:foreign_key => :follower_user_id, :class_name => "Following"
has_many :movies, :through => :messages

Message

class Message < foreign_key =""> :following_user_id,   :class_name => "Following"
#  has_many :follower_users,:foreign_key => :follower_user_id, :class_name => "Following"
end

Following

class Following < foreign_key =""> :follower_user_id, :class_name => "User"   #id of the user that is following
belongs_to :following_user,  :foreign_key => :following_user_id, :class_name => "User"  #id of the user that is being followed
end


+++++++++++++++++++++ my solution so far

 @user=User.find_by_id(params[:user_id])
@following_users=@user.followings.each { |follow| follow.user_id }
@messages=Message.find_all_by_user_id(@following_users)

Refactoring
=========

 def get_page_count
            results =  @doc.search("//td[@class='resultCount']/").first.to_s.gsub(/\./,"")
            tmp_array=results.scan(/(\d+)-(\d+).*?(\d+)/)
            myarray=tmp_array[0]
            @max_pages_in_category = 1
             if !myarray.nil?
                  @max_pages_in_category= (myarray[2].to_i / 12)    # total number of items / itmes on a page
                  if (myarray[2].to_i % 12) != 0 then @max_pages_in_category+=1 end
                  @total_articles_in_category=myarray[2];
             end
      end

   def render_products
          titles =  @doc.search("//span[@class='srTitle']/")
          titles.each do |title|
              print "."
               string=title.to_s
               string.gsub!(/\(.+?\)/,"")
               string.gsub!(/\[.+?\]/,"")
               if @data_file!=0 : @data_file.puts @tags+":"+string end
           end
       end





Form_for nested
2008-06-23T05:12:00.000-07:00
when using nested controllers where forms in the views need to call a nested controller too:

 <% form_for([@user, @movie]) do |f| %>
  ...
 <% end %>

This will call the :controller => :movie with the :action => post with the :user_id => @user.id


Model Relationships - has_many belongs_to
2008-06-20T12:05:00.000-07:00
ModelOne
has_many :model_twos
has_many :model_threes, :through :model_two

ModelTwo
belongs_to :model_one
belongs_to :model_three

ModelThree
has_many :model_twos
has_many :model_ones, :through :model_two


Rake Scaffold
2008-06-20T12:03:00.000-07:00
ruby script/generate scaffold SingularModelName data_field_name:type -c

The -c adds the file generated to the svn repository.


Auto Complete Related Models
2008-06-20T11:28:00.000-07:00
Here is an auto_complete example that works accross 2 related models:

movie
has_many :messages

messages
belongs_to :movie

This went in the messages new view.
============================
 <%= text_field_with_auto_complete :movie, :movie_name, {:size => 50}, {:url => formatted_movies_path(:js), :method => :get, :param_name => 'search'} %>

as you cannot use the regular auto_complete_for helper for auto complete across models the text_filed_with_auto_complete needs to  have a few more things added to it.

:movie is the model name for the auto complete
:movie_name will contain the input from the user
The first {} contains the options for the input field
The second {} contains the options for the java script

in the first {} the field size is set to 50 with :size=>50
in the second {} the
  :url tells the auto complete where to go to get its information to give back to the client. In this case its the path to the index function of the movie controller. (:js) means java script is the format to pass around
 :method make rails get information rather then post information (which normally happens with the information from an input field)
 :param_name set the name of the params hash key with the information being typed into the field.

This was how the messages controller handled the create
===========================================
def create
@message = Message.new(params[:message])
@message.movie=Movie.find_or_create_by_title(:title=> params[:movie][:movie_name])
@message.save
end

This is what happened on the movie index method
======================================
  def index
  @movies = Movie.find(:all, :limit => 20, :conditions => ['title LIKE?', "%#{params[:search]}%"])

  respond_to do |format|
    format.html # index.html.erb
    format.js #{ render :html => @movies }
    format.xml  { render :xml => @movies }
  end
end

as you can see in the above the index.js.erb file will be rendered when java script is calling this controller method.

This is what the index.js.erb file looks like
================================

<%= auto_complete_result @movies, :title %>

This is a help method from auto complete which renders back the title value for the objects contained in the @movies instance.

!!!!DONT FORGET to add the java script librarys in the layout.
<%= javascript_include_tag :defaults %>

One last thing: Here is the CSS for the auto_complete to add the CSS being used for model so that the defaults can be overridden.

.auto_complete {
     position:absolute;
     /*width:250; */
     overflow: hidden;
     white-space: nowrap;
     background-color:white;
     border:1px solid #888;
     margin:0px;
     padding:0px;
     color: black;
}

.auto_complete ul {
     list-style-type: none;
     margin:0px;
     padding:0px;
     color: black;
}

.auto_complete ul li.selected
{
       background-color: #fff; /* #bbf; */
       color: black;
}

.auto_complete ul li {
     list-style-type: none;
     display:block;
     margin:0;
     padding:2px;
     height:16px;
     color: black;
}  


file upload
2008-06-20T11:20:00.000-07:00
This file upload form was made to upload a , delimited text file.


<% form_for(@category_movie,  :html => { :multipart => true }) do |f| -%>
               Upload DVD DataFiles:

              <%= file_field_tag :dvd_data %>                  
<%= submit_tag 'Create' %>
 <% end -%>


From file to DB through Controller
2008-06-20T11:13:00.000-07:00
This method reads data from an uploaded file in a , delimited file and stores it in the database in the movies, categories and category_movies(join table).

category name 1, category name 2, ...., category name x: movie title

def create

  while (line=params[:dvd_data].gets)
            title=line.scan(/ROOT:.*/).to_s.gsub(/ROOT:/,"")
     categories=line.gsub(/ROOT:.*/,"").scan(/.+?,/)
     categories.each do |category|
                  category.gsub!(/,/,"")
                  the_category = Category.find_or_create_by_name(:name => category)
                  the_movie= Movie.find_or_create_by_title(:title => title.to_s)
                 CategoryMovie.find_or_create_by_category_id_and_movie_id(:category_id =>the_category.id, :movie_id=> the_movie.id)
           end
  end            

  respond_to do |format|
     flash[:notice] = 'DataBase Updated With DVD titles and Categories'
     format.html { redirect_to(category_movies_path) }
     format.xml  { render :xml => @category_movie, :status => :created, :location => @category_movie }
  end
 end


Traps falls installing things, addons and packages
2008-05-22T01:24:00.000-07:00
It turns out that using preconfigured binaries and packages are waste of time.
For example. i install ruby using:

useraccount> pfexec pkg install ruby-dev

The package was compiled on the SUN cc compiler - which is fine, but.....
the setup.rb file of the ruby system has all the environment variables set from the machine it was compiled on - and not mine. Editing that file by hand to adapt the environment to my machine is a night mare.

The RMagick gem and for that matter the source code both look at the environment in the setup.rb file and because nothing in there is relevant to my machine the install fails.

useraccount> pfexec uninstall ruby-dev
useraccount> su
superuseraccount> pfexec rm -r /ruby

So the only way to do this properly is uninstall the ruby pkg, get rid of the installation from my file system, down load the source and compile it again.

useraccount> cd /export/home/tmp
useraccount>pfexec wget ftp://ftp.ruby-lang.org/pub/ruby/1.8/ruby-1.8.6-p110.tar.bz2
useraccount>pfexec bunzip2 -dc ruby-1.8.6-p110.tar.bz2 | tar xf -


Using ruby setup.rb
2008-05-22T01:23:00.000-07:00
This is a great place to read about it


Setting up sendmail
2008-05-21T23:53:00.000-07:00
according to the man pages sendmail does not let you send mails outside your domain unless you allow it to.

useraccount> svccfg -s svc:/network/smtp:sendmail setprop config/local_only = false
useraccount> svcadm refresh svc:/network/smtp:sendmail
useraccount> svcadm restart svc:/network/smtp:sendmail

testit

useraccount> sendmail someone@domain.com


Installing RMagick and ImageMagick
2008-05-20T13:52:00.000-07:00
OK this took a day to find out.
RMagick wraps around ImageMagick so you need both of them.
To install ImageMagic you need perl - which is fine but you won't be able to install (configure and make) if perl has been compiled with a c compiler from sun. It throws out -KPIC for gcc and it should send gcc a -fPIC when compiling.

So move rename perl link in the /usr/bin and the the perl root directory wherever that might be forexample /perl

get the stable perl source code from perl.com and download it
useraccount> pfexec tar xvf perl_download
useraccount> pfexec perl_download
useraccount> pfexec ./Configure
useraccount> pfexec make
useraccount> pfexec make test
useraccount> pfexec make install

perl should now be in /opt/bin/perl with a link to it from /usr/bin

Once you have done that download ImageMagick source files
useraccount> pfexec tar xvf ImageMagick
useraccount> cd ImageMagick
useraccount> pfexec ./configure --disable-static --with-modules --without-perl --without-magick-plus-plus --with-quantum-depth=8 CC=gcc
useraccount> pfexec make
useraccount> pfexec make install

ImageMagick should now be in /usr/local/bin

Then test it with
useraccount> /usr/local/bin/convert logo: logo.gif

I did most of the above based on the info here and here


Installing will_pagenate
2008-05-20T13:26:00.000-07:00
useraccount> pfexec gem install mislav-will_paginate --source http://gems.github.com/

manual


install plugin acts_as_taggable_on_steroids
2008-05-20T11:53:00.000-07:00
ruby script/plugin install http://svn.viney.net.nz/things/rails/plugins/acts_as_taggable_on_steroids

== Instructions

This plugin is based on acts_as_taggable by DHH but includes extras
such as tests, smarter tag assignment, and tag cloud calculations.

== Installation

  ruby script/plugin install http://svn.viney.net.nz/things/rails/plugins/acts_as_taggable_on_steroids

== Usage

=== Prepare database

Generate and apply the migration:

  ruby script/generate acts_as_taggable_migration
  rake db:migrate

=== Basic tagging

Let's suppose users have many posts and we want those posts to have tags.
The first step is to add +acts_as_taggable+ to the Post class:

  class Post < ActiveRecord::Base
    acts_as_taggable
   
    belongs_to :user
  end
 
We can now use the tagging methods provided by acts_as_taggable, #tag_list and #tag_list=. Both these
methods work like regular attribute accessors.

  p = Post.find(:first)
  p.tag_list # []
  p.tag_list = "Funny, Silly"
  p.save
  p.tag_list # ["Funny", "Silly"]
 
You can also add or remove arrays of tags.

  p.tag_list.add("Great", "Awful")
  p.tag_list.remove("Funny")

=== Finding tagged objects

To retrieve objects tagged with a certain tag, use find_tagged_with.

  Post.find_tagged_with('Funny, Silly')
 
By default, find_tagged_with will find objects that have any of the given tags. To
find only objects that are tagged with all the given tags, use match_all.

  Post.find_tagged_with('Funny, Silly', :match_all => true)
 
See ActiveRecord::Acts::Taggable::InstanceMethods for more methods and options.

=== Tag cloud calculations

To construct tag clouds, the frequency of each tag needs to be calculated.
Because we specified +acts_as_taggable+ on the Post class, we can
get a calculation of all the tag counts by using Post.tag_counts. But what if we wanted a tag count for
an single user's posts? To achieve this we call tag_counts on the association:

  User.find(:first).posts.tag_counts
 
A helper is included to assist with generating tag clouds. Include it in your helper file:

  module ApplicationHelper
    include TagsHelper
  end
 
You can also use the counts method on Tag to get the counts for all tags in the database.

  Tag.counts

Here is an example that generates a tag cloud.

Controller:

  class PostController < ApplicationController
    def tag_cloud
      @tags = Post.tag_counts
    end
  end
 
View:
  <% tag_cloud @tags, %w(css1 css2 css3 css4) do |tag, css_class| %>
    <%= link_to tag.name, { :action => :tag, :id => tag.name }, :class => css_class %>
  <% end %>
 
CSS:

  .css1 { font-size: 1.0em; }
  .css2 { font-size: 1.2em; }
  .css3 { font-size: 1.4em; }
  .css4 { font-size: 1.6em; }

=== Caching

It is useful to cache the list of tags to reduce the number of queries executed. To do this,
add a column named cached_tag_list to the model which is being tagged. The column should be long enough to hold
the full tag list and must have a default value of null, not an empty string.

  class CachePostTagList < ActiveRecord::Migration
    def self.up
      add_column :posts, :cached_tag_list, :string
    end
  end

  class Post < ActiveRecord::Base
    acts_as_taggable
   
    # The caching column defaults to cached_tag_list, but can be changed:
    #
    # set_cached_tag_list_column_name "my_caching_column_name"
  end

The details of the caching are handled for you. Just continue to use the tag_list accessor as you normally would.
Note that the cached tag list will not be updated if you directly create Tagging objects or manually append to the
tags or taggings associations. To update the cached tag list you should call save_cached_tag_list manually.

=== Delimiter

If you want to change the delimiter used to parse and present tags, set TagList.delimiter.
For example, to use spaces instead of commas, add the following to config/environment.rb:

  TagList.delimiter = " "

=== Unused tags

Set Tag.destroy_unused to remove tags when they are no longer being
used to tag any objects. Defaults to false.

  Tag.destroy_unused = true

#######################################

IMPORTANT: If you are using join table habtm then you can add

:conditions => {} for example to somthing like p = Post.find(:first)

i.e.

p = Post.find(:first) :conditions => {user.id => current_user }

this will allow you to set or access only the tags for a specific user is a situation where you might have a habtm user picture relationship where a user can add tags to thier pictures.


Install plugin attachement_fu
2008-05-20T11:46:00.000-07:00
ruby script/plugin install attachment_fu

create a scaffold
=============
ruby script/generate scaffold Photo parent_id:integer content_type:string filename:string size:integer width:integer height:integer

photo migration
=============

class CreatePhotos < default =""> ""
     t.string :content_type, :default => ""
     t.string :filename, :default => ""
     t.integer :size, :default => 0
     t.integer :width, :default => 0
     t.integer :height, :default => 0

     t.timestamps
   end
   photo=Photo.new(:content_type=>" image/jpeg", :filename=>"default_avatar_1.jpg", :size => 4.kilobytes, :width=>114, :height=>150)
   photo.save
   photo=Photo.new(:parent_id => photo.id, :content_type=>" image/jpeg", :filename=>"default_avatar_1_thumb.jpg", :thumbnail => "thumb", :size => 4.kilobytes, :width=>24, :height=>32)
   photo.save  
 end

 def self.down
   drop_table :photos
 end
end

photo.rb
=======

class Photo < ActiveRecord::Base
 has_one :profile

  has_attachment :content_type => :image,
  :storage => :file_system,
  :size => 1.kilobyte..20.kilobytes,
  :resize_to => '150x150'
#  :thumbnails => { :thumb => '32x32' }

#  validates_numericality_of :size, :only_integer => true, :greater_than => 1.kilobyte, :less_than => 20.kilobytes, :message => "File size out of range"
  #TODO get the regex for content type
  #validates_format_of :content_type, :with => :image, :message => "Picture is not an image"
  validates_presence_of :width, :on => :update, :message => "width missing"
  validates_presence_of  :height, :on => :update, :messgae => "height missing"
  validates_presence_of :filename, :on => :update, :message => "File name missing"
   
  #attr_accessible :filename, :content_type, :width, :height, :size

end

###########################################################################

attachment-fu
=============

attachment_fu is a plugin by Rick Olson (aka technoweenie ) and is the successor to acts_as_attachment.  To get a basic run-through of its capabilities, check out Mike Clark's tutorial .


attachment_fu functionality
===========================

attachment_fu facilitates file uploads in Ruby on Rails.  There are a few storage options for the actual file data, but the plugin always at a minimum stores metadata for each file in the database.

There are three storage options for files uploaded through attachment_fu:
File system
Database file
Amazon S3

Each method of storage many options associated with it that will be covered in the following section.  Something to note, however, is that the Amazon S3 storage requires you to modify config/amazon_s3.yml and the Database file storage requires an extra table.


attachment_fu models
====================

For all three of these storage options a table of metadata is required.  This table will contain information about the file (hence the 'meta') and its location.  This table has no restrictions on naming, unlike the extra table required for database storage, which must have a table name of db_files (and by convention a model of DbFile).

In the model there are two methods made available by this plugins: has_attachment and validates_as_attachment.

has_attachment(options = {})
This method accepts the options in a hash:
  :content_type     # Allowed content types.
                    # Allows all by default.  Use :image to allow all standard image types.
  :min_size         # Minimum size allowed.
                    # 1 byte is the default.
  :max_size         # Maximum size allowed.
                    # 1.megabyte is the default.
  :size             # Range of sizes allowed.
                    # (1..1.megabyte) is the default.  This overrides the :min_size and :max_size options.
  :resize_to        # Used by RMagick to resize images.
                    # Pass either an array of width/height, or a geometry string.
  :thumbnails       # Specifies a set of thumbnails to generate.
                    # This accepts a hash of filename suffixes and RMagick resizing options.
                    # This option need only be included if you want thumbnailing.
  :thumbnail_class  # Set which model class to use for thumbnails.
                    # This current attachment class is used by default.
  :path_prefix      # path to store the uploaded files.
                    # Uses public/#{table_name} by default for the filesystem, and just #{table_name} for the S3 backend.
                    # Setting this sets the :storage to :file_system.
  :storage          # Specifies the storage system to use..
                    # Defaults to :db_file.  Options are :file_system, :db_file, and :s3.
  :processor        # Sets the image processor to use for resizing of the attached image.
                    # Options include ImageScience, Rmagick, and MiniMagick.  Default is whatever is installed.


Examples:
  has_attachment :max_size => 1.kilobyte
  has_attachment :size => 1.megabyte..2.megabytes
  has_attachment :content_type => 'application/pdf'
  has_attachment :content_type => ['application/pdf', 'application/msword', 'text/plain']
  has_attachment :content_type => :image, :resize_to => [50,50]
  has_attachment :content_type => ['application/pdf', :image], :resize_to => 'x50'
  has_attachment :thumbnails => { :thumb => [50, 50], :geometry => 'x50' }
  has_attachment :storage => :file_system, :path_prefix => 'public/files'
  has_attachment :storage => :file_system, :path_prefix => 'public/files',
                 :content_type => :image, :resize_to => [50,50]
  has_attachment :storage => :file_system, :path_prefix => 'public/files',
                 :thumbnails => { :thumb => [50, 50], :geometry => 'x50' }
  has_attachment :storage => :s3

validates_as_attachment
This method prevents files outside of the valid range (:min_size to :max_size, or the :size range) from being saved.  It does not however, halt the upload of such files.  They will be uploaded into memory regardless of size before validation.

Example:
  validates_as_attachment


attachment_fu migrations
========================

Fields for attachment_fu metadata tables...
in general:
  size,         :integer  # file size in bytes
  content_type, :string   # mime type, ex: application/mp3
  filename,     :string   # sanitized filename
that reference images:
  height,       :integer  # in pixels
  width,        :integer  # in pixels
that reference images that will be thumbnailed:
  parent_id,    :integer  # id of parent image (on the same table, a self-referencing foreign-key).
                          # Only populated if the current object is a thumbnail.
  thumbnail,    :string   # the 'type' of thumbnail this attachment record describes.
                          # Only populated if the current object is a thumbnail.
                          # Usage:
                          # [ In Model 'Avatar' ]
                          #   has_attachment :content_type => :image,
                          #                  :storage => :file_system,
                          #                  :max_size => 500.kilobytes,
                          #                  :resize_to => '320x200>',
                          #                  :thumbnails => { :small => '10x10>',
                          #                                   :thumb => '100x100>' }
                          # [ Elsewhere ]
                          # @user.avatar.thumbnails.first.thumbnail #=> 'small'
that reference files stored in the database (:db_file):
  db_file_id,   :integer  # id of the file in the database (foreign key)

Field for attachment_fu db_files table:
data, :binary # binary file data, for use in database file storage


attachment_fu views
===================

There are two main views tasks that will be directly affected by attachment_fu: upload forms and displaying uploaded images.

There are two parts of the upload form that differ from typical usage.
1. Include ':multipart => true' in the html options of the form_for tag.
  Example:
    <% form_for(:attachment_metadata, :url => { :action => "create" }, :html => { :multipart => true }) do |form| %>
 
2. Use the file_field helper with :uploaded_data as the field name.
  Example:
    <%= form.file_field :uploaded_data %>

Displaying uploaded images is made easy by the public_filename method of the ActiveRecord attachment objects using file system and s3 storage.

public_filename(thumbnail = nil)
Returns the public path to the file.  If a thumbnail prefix is specified it will return the public file path to the corresponding thumbnail.
Examples:
  attachment_obj.public_filename          #=> /attachments/2/file.jpg
  attachment_obj.public_filename(:thumb)  #=> /attachments/2/file_thumb.jpg
  attachment_obj.public_filename(:small)  #=> /attachments/2/file_small.jpg

When serving files from database storage, doing more than simply downloading the file is beyond the scope of this document.


attachment_fu controllers
=========================

There are two considerations to take into account when using attachment_fu in controllers.

The first is when the files have no publicly accessible path and need to be downloaded through an action.

Example:
def readme
  send_file '/path/to/readme.txt', :type => 'plain/text', :disposition => 'inline'
end

See the possible values for send_file for reference.


The second is when saving the file when submitted from a form.
Example in view:
<%= form.file_field :attachable, :uploaded_data %>

Example in controller:
def create
  @attachable_file = AttachmentMetadataModel.new(params[:attachable])
  if @attachable_file.save
    flash[:notice] = 'Attachment was successfully created.'
    redirect_to attachable_url(@attachable_file)  
  else
    render :action => :new
  end
end


install plugin restfull_authentication
2008-05-20T11:28:00.000-07:00
script/plugin source http://svn.techno-weenie.net/projects/plugins
script/plugin/install restful_authentication

script/generate authenticated user sessions

To use:

 ./script/generate authenticated user sessions --include-activation

The first parameter specifies the model that gets created in signup(typically a user or account model).  A model with migration is created, as well as a basic controller with the create method.

The second parameter specifies the sessions controller name.  This is the controller that handles the actual login/logout function on the
site.

The third parameter (--include-activation) generates the code for a ActionMailer and its respective Activation Code through email.

You can pass --skip-migration to skip the user migration.

Also, add an observer to config/environment.rb if you chose the --include-activation option

 config.active_record.observers = :user_observer # or whatever you named your model


SVN Helpful links
2008-05-20T09:16:00.000-07:00
http://www.yasashiisyndicate.org/wp-content/uploads/2006/05/subversion.html


Using Rails with SVN
2008-05-20T08:57:00.000-07:00
1. mkdir getready
2. cd getready
3. rails projectname
4. mv projectname trunk
5. mkdir tags
6. mkdir branches
7. cd trunk/config
8. mv database.yml database_example.yml
9. cd ..
10. rm -r  tmp/*
11. rm -r  log/*
12. cd ..
13 svn import . http://path_to_repository -m "initial import"
14. ...now you can get rid of getready folder - we dont need it anymore
15. svn co http://path_to_project_trunk projectname
16. cd projectname
17. cp config/database_example.yml database.yml
18. add passwords to the database entries
19. svn propset svn:ignore database.yml config/
20. svn propset svn:ignore "*" tmp/
21. svn propset svn:ignore "*" logs/
22. svn commit -m "ignoring files"
23. svn copy http://from_repository_trunk http://repository_tag_path_REL_XXX -m "initial snapshot release"

############################
# just a few things to remember
############################

1. when generating a model, controller or scaffold use the following

useraccount>ruby script/generate scaffold angry farmer bales_of_hey:integer name -c

DON'T FORGET THE -c AT THE END!!!

2. When installing a plugin

ruby script/install name_of_plugin -x

also a great railscast on the basics.

Working

To see the status of the files in the repository use:

useraccount> svn status

To commit changes to the files

useraccount> svn commit -m "somthing about what you are commiting"

To add files that you have changes (they have a ? next to them when you see the status).

useraccount> svn add directory_and_name_of_file

to ignore files

useraccount>  svn propset svn:ignore *.pyc dirname
or
useraccount> svn propset svn:ignore dirname


setting up svn with a rails 2.0.2 project
2008-05-20T07:25:00.000-07:00
more or less got this from here.

Go to the directory you want to set up the rails project in.

then

useraccount> mkdir svn_setup
useraccount> cd svn_setup
useraccount> rails project_name -d mysql
useraccount> mv project_name trunk
useraccount> mkdir tags
useraccount> mkdir branches
useraccount> cd trunk
useraccount> rm -r tmp/*
useraccount> rm -r log/*
useraccount> mv config/database.yml database_example.yml
useraccount> cd ..
useraccount> svn import . url_of_svn_repository_space_on_assembla -m "initial repository import" --user name_of_assembla_user

now the project should be in the svn repository in assembla

now checkout the project from the repository in assembla to your localhost

useraccount> cd
useraccount> svn co url_of_svn_repository_space_on_assembla/trunk project_name

project_name is now what you can work on and thus you can get rid of the svn_setup folder you made earlier.

useraccount> rm -r svn_setup

now for the last bits and bobs.

useraccount> cd project_name
useraccount> cp /config/database_example.yml database.yml

useraccount> svn propset svn:ignore database.yml config/
useraccount> svn propset svn:ignore "*" log/
useraccount> svn propset svn:ignore "*" tmp/


Installing svn repository space on assembla
2008-05-20T07:17:00.000-07:00
I would rather emulate what really might happen with a proper svn than use my local file system for a svn repository so sign up to assembla.com and get some svn space.

under the tab 'Trac/SVN' you will get the url of the SVN repository space.


Setting up mysql
2008-05-20T06:04:00.000-07:00
go to the user and groups setting in the gnome system administration menu and set the mysql user password to something that makes sense for you. Then give the mysql user a shell '/bin/bash' (setting in the advanced tab of user and groups) and then close all the windows with ok to set the changes.

Then change to user mysql

useraccount>su - mysql
password:

and enter the mysql password

now you should have the bash promt:

#bash>

then enter

#bash>mysql_install_db

then

#bash>mysqld --skip-grant-tables &

then

#bash>mysql

you should get the mysql promt

mysql>UPDATE mysql.user SET Password=PASSWORD('MyNewPass') WHERE User='root';

mysql> FLUSH PRIVILEGES;

############################
############################

now open a new terminal window....

useraccount> pfexec /usr/bin/svcadm enable database/mysql:version_50

this should start the mysql database (pfexec /usr/bin/svcadm disable database/mysql:version_50 stops the database)

if you want mysql to automatically start and stop with powerup and powerdown

then do this (which i have not)

pfexec /usr/sbin/svccfg import /var/svc/manifest/application/database/mysql.xml





DO NOT install AMP developers environment
2008-05-20T05:58:00.000-07:00
Installing the reconfigured AMP environment for opensolaris caused me a lot of problems: machine not shutting down properly. not being able to shutdown via GNOME, not unmount startd properly and not getting any Internet when the machine boots up after a shutdown, which is not a shutdown but a restart instead.


Installing Mysql
2008-05-20T05:51:00.000-07:00
as a normal user

useraccount>pexec pkg install SUNWmysql5

This installs mysql in /usr/mysql

Then change to su root and change the owner and groups of the files in etc and var as follows.

root>chown -R mysql:mysql /etc/mysql
root>chown -R mysql:mysql /var/mysql

also see docs



Installing Rails
2008-05-20T04:19:00.000-07:00
as normal user (gems was installed with ruby).

useraccount>pfexec gem install rails --include-dependencies

Rails should now be in /usr/ruby/1.8



installing Ruby
2008-05-20T02:24:00.000-07:00
Do as normal user account.

useraccount> pfexec pkg install ruby-dev

ruby should now be in /usr/ruby