If anyone else knows of some other ones please let me know

== General Practices ==
Dev on a Mac
Read up on TDD (Test Driven Development)
Use Growl for your Autotest notifications
TextMate – The only Editor you need
GitHub – Great space to see open source code and gems and plugins
http://gemcutter.org/

== Rails Setup ==

http://hivelogic.com/ – Has some great tutorials on getting your environment setup on a mac.

== Tutorials ==
http://rubyonrails.org
Rails Casts – Ryan Bates screen casts about all things rails related
PeepCode – Great screen casts about all things rails related

== Blogs ==

Sentia Blog
http://thoughtbot.com
http://weblog.jamisbuck.org
http://blog.jayfields.com
http://errtheblog.com

== Books ==
http://pragmaticstudio.com – Great source of books about rails and other technologies with a focus on the right practices.

Finally the only real way to learn is to try things out. Follow other developers blogs and use all the resources you can such as Google groups etc.
Don’t be scared to get it wrong its the only way to learn.

PayFlow is Paypal’s payment gateway and you need to setup a PayFlow account.
IMPORTANT! This is separate from Paypal’s development sandbox. Follow these steps to setup a Payflow testing account

1. Go to https://www.paypal.com/cgi-bin/webscr?cmd=_payflow-get-started-outside
   and fill in the details for an account.
2. When you get to the page where you need to enter your payment information, hit Save and Exit. This will create a testing PayFlow account for you.
3. You will be sent an email with your partner ID and your vendor login. Take note of your partner ID as this will be important later.
4. You should now be able to login at https://manager.paypal.com/

Now that you have a PayFlow account, you can use ActiveMerchant to setup payments. For now we will muck around in irb to test that methods out.

So lets open up irb and start by including the active merchant gem and setting ActiveMerchant to test mode

kongy@Deadpool: $ irb
irb(main):001:0> require 'rubygems'
irb(main):002:0> require 'active_merchant'
irb(main):003:0> ActiveMerchant::Billing::Base.mode = :test

Now lets setup the gateway.

gateway = ActiveMerchant::Billing::PayflowGateway.new(:login => 'PAYFLOW_LOGIN', :password => 'PAYFLOW_PASSWORD', :partner => 'PARTNER_ID')

This creates the gateway that we will be using to request purchases. By default ActiveMerchant passes PAYPAL as the partner value if you leave it out. I believe that this is the default for US PayFlow account. For my Aussie one, I received a VSA partner_id. I would suggest putting it in there anyway.

PayFlow Testing only accepts testing credit cards numbers.  You can grab them from the PayFlow recurring billing documentation found here. Here is a quick list which I can’t guarantee will be up to date.

So lets create a Mastercard credit card.

irb(main):004:0> credit_card = ActiveMerchant::Billing::CreditCard.new( :number => '5105105105105100', :month => '9', :year => '2007', :first_name => 'Mal', :last_name => 'Reynolds', :verification_value => '123', :type => 'master' )

Now we are ready to start billing. If you want to setup a one time payment it is quite easy.

irb(main):007:0> response = gateway.purchase(1000, credit_card)
irb(main):008:0> response.success?
=> true

If you go into your Paypal Manager and search for transactions you should see it appear.

To setup a recurring billing we need to use the recurring method of the gateway. The recurring method accepts the amount in cents, the credit card object and the time intervals to charge the card, at a minimum. There are other options available which you can find here. Lets charge $10/month

irb(main):009:0> response = gateway.recurring(100, credit_card, :periodicity => :monthly)
irb(main):010:0> response.success?
=> true
irb(main):011:0> response.profile_id
=> "RT0000000002"

You can view the recurring billings in your Paypal Manager by clicking on Service Settings > Recurring Billings > Manage Profiles. You will probably want to store the profile_id in your database for when you need to edit details of the recurring billing. You can do it quite simply by calling the recurring method again. Let’s change the amount we want to bill to $20/week.

irb(main):0012:0> response = gateway.recurring(2000, nil, :profile_id => "RT0000000001",  :periodicity => :weekly)
irb(main):013:0> response.success?
=> true

You can see here that we no longer need to pass in the credit card since we have the profile_id. We update the amount, and change the periodicity of the billing.

And that’s it.

So thats what we are going to do for this example.

Step 1. Create your admin controller

You can use whichever process works best for you, but for this we are going to use script/generate:

 ./script/generate controller admin

Step 2. Create your user controller

You can use whichever process works best for you, but for this we are going to use script/generate:

 ./script/generate controller admin/users

Step 3. Check to ensure proper inheritance

The nested users controller should look something like so:

class Admin::UsersController < ApplicationController
end

Step 4. Create the Routes

The nested users controller should look something like so:

map.namespace :admin do |admin|
  admin.resources :users
end

Before rails 2+ you had to do like like we have below. Personally l don’t mind it makes it a little easier to read but either option works fine

map.resource(:admin) do |admin|
  admin.resources(:users, :controller => 'admin/users')
end

Step 5. Wait there is no step 5 your done

Now when you need to link to any of these actions its very simple keeping in mind that users is nested under the admin controller so all you have to do to create a link that goes to the index action on the nested users controller is add the admin prefix before

 link_to "Users", admin_users_url

The same applies when you are wanting to link to the show action of users all you do is loose the “s” on users as you would normally

 link_to "View User", admin_user_url(@user)

You can see a list of all the routes you have available to you by going to the root directory of your project in terminal and typing

rake routes

sudo gem install passenger

Then you need to install the apache module for passenger.

sudo passenger-install-apache2-module

Now once you do this you will be told to all the following lines to your httpd.conf file in apache. Now you can just add these lines no problems but l like to have it in its own conf file and since apache will also load all conf files in /etc/apache2/other/ directory just create a passenger.conf file and add those lines in. Now these lines are different depending on how you installed ruby. I installed it in user/local keeping the orginal ruby version that ships with mac clean so mine looks like so

LoadModule passenger_module /usr/local/lib/ruby/gems/1.8/gems/passenger-2.2.5/ext/apache2/mod_passenger.so
PassengerRoot /usr/local/lib/ruby/gems/1.8/gems/passenger-2.2.5
PassengerRuby /usr/local/bin/ruby

To create the new passenger.conf file just run the below command assuming you have textmate installed.

mate /etc/apache2/other/passenger.conf

Once you have cut and pasted those lines in save it and close the file. You then need to download the passenger preference pane. Here is a link to the latest build passenger-preference-pane1.3. Download and install then fire it up.

Now unlock it if need be and click on the + button to add a new site. A window will pop up and now just select the root of your rails app and click “open”. You can now change the address if need be but just defaults to (rails_app_name).local. Hit apply and your good to go.

So go back to your browser and type in that address and it will fire up and your up and running. Now you wont see the log like you are used to since your not running webrick etc but all you have to do is tail the development log by going to the root dir of your application in terminal and typing the following

 tail -f log/development.log

And that’s it. You will need to restart passenger if you change the environment.rb file but thats simple enough via the preference pane. So no more ./script/server yay

/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/1.8/rubygems/custom_require.rb:31:in `gem_original_require’: no such file to load — capistrano/ext/multistage (LoadError)

So to fix this l did the following

sudo gem uninstall capistrano
sudo rm -rf /usr/bin/cap
sudo gem install capistrano-ext
sudo gem install capistrano

Needed to do “sudo rm -rf /usr/bin/cap” as doing just the uninstall of capistrano didn’t remove all the files l needed it to.

Firstly create your rails app and using terminal go into the root of that project.

Then create a top, project-level .gitignore file. I use textmate so this can be done like so

$ mate .gitignore

Then add the following to the .gitignore file

.DS_Store
log/*.log
tmp/**/*
config/database.yml
db/*.sqlite3

You can also add more directories or files in here to ignore like css files if using sass for example, or your uploads directory.

Create some .gitignore files so the empty directories get tracked:

$ touch log/.gitignore
$ touch tmp/.gitignore

and finally commit that bad boy

$ git add .
$ git commit -m "First commit"

Running git add will tell git to track all the new files (Since first commit thats all of them). The commit will commit to your local Git repository and all that is left to do would be to add it to GitHub for example and your in business.

namespace :deploy do
  desc "Restarting mod_rails with restart.txt"
  task :restart, :roles => :app, :except => { :no_release => true } do
    run "touch #{current_path}/tmp/restart.txt"
  end

  [:start, :stop].each do |t|
    desc "#{t} task is a no-op with mod_rails"
    task t, :roles => :app do ; end
  end
end

This will tell Capistrano to restart the server the passenger way by touching the restart.txt file in the tmp dir rather then trying to restart using mongrel. Lets hope l don’t forget next time

Ill post more about this soon

Firstly you need to install Comatose. Go to your project root directory in terminal and type the following.

./script/plugin source http://mattmccray.com/svn/rails/plugins
./script/plugin install comatose
./script/generate comatose_migration
rake migrate

Then you need to install fckEditor. To do so go to the root of your app in terminal and type the following

ruby script/plugin install svn://rubyforge.org//var/svn/fckeditorp/trunk/fckeditor

In the Comatose _form.html.erb page you need to change

<%= f.text_area :body, :rows=>20, :tabindex=>2 %>

to this so that the fckeditor appears when creating and editing pages.

<%= fckeditor_textarea('page', 'body', :width => '100%', :height => '500px') %>

Once you have Comatose and FCKEditor installed and running the final step is to get it all working with Authlogic.

So in your environment.rb file you need to add the following.

Comatose.configure do |config|
  #Custom class we wrote to handle current_user etc
  config.admin_includes << :user_methodss
  # Calls :login_required as a before_filter
    config.admin_authorization = :require_user
end

This will force comatose to have require a user to be logged in to use the system. The :user_methodss class is a class we wrote to handle the login methods of Autlogic. You can replace this with your own if you want ill include the class we created below.

module UserMethods
  module ClassMethods
    def permission_required(permission_name,actions, notice=nil)
      notice ||= "You don't have access to that part of the site."
      actions = [actions].flatten
      before_filter(:only => actions) { |controller| require_or_redirect(permission_name, controller, notice) }
    end

    def require_or_redirect(permission_name, controller, notice)
      user = controller.send(:current_user)

      if !user.can?(permission_name)
        # @permission_missing is used for should_require_permission test
        controller.instance_variable_set("@permission_missing", true)
        controller.send(:redirect_back_or_to, "/", notice)
      end
    end
  end

  def self.included(base)
    base.extend(ClassMethods)
  end

  protected 

  # Redirects back or if that fails, redirects to the supplied path
  # Also accepts a notice if you want to flash something
  def redirect_back_or_to(path, notice=nil)
    flash[:notice] = notice unless notice.blank?
    begin
      redirect_to :back
    rescue ActionController::RedirectBackError
      redirect_to path
    end
  end

  # Returns the param to use in a find command for objects with a
  # possible cross-db sort
  def cross_database_order(order, direction, sort_methods_allowed)
    return "#{ order } #{ direction }" if !cross_database_sort?(order, sort_methods_allowed)
  end

  # Returns true if the given order looks like a cross db sort
  # Allowed_methods should be an array of association objects to
  # methods allowed to be called on them.
  def cross_database_sort?(order, allowed_methods)
    return allowed_methods.include?(order)
  end

  # Performs a sort on the given objects by calling methods rather than
  # using a db lookup.
  def cross_database_sort(objects_to_sort, order, direction, sort_methods_allowed)
    if cross_database_sort?(order, sort_methods_allowed)
      methods = order.split(".")
      association_name, method = order.split(".")
      objects_to_sort = objects_to_sort.sort_by do |object|
        methods.each do |meth|
          next if object.nil?
          object = object.send(meth)
        end
        "#{ object }"
      end
      objects_to_sort.reverse! if direction == "desc"
    end

    return objects_to_sort
  end

  private

  # ActionMailer views don't have access to the request, so we need
  # to set these variables manually.
  def setup_host_for_mail
    ActionMailer::Base.default_url_options[:host] = request.host_with_port
  end

  def logout
    current_user_session.destroy if current_user_session
  end

  def current_user_session
    return @current_user_session if defined?(@current_user_session)
    @current_user_session = UserSession.find
  end

  def current_user
    return @current_user if defined?(@current_user)
    @current_user = current_user_session && current_user_session.user
  end

  def require_user
    unless current_user
      store_location
      flash[:notice] = "You must be logged in to access this page"
      redirect_to new_user_session_url
      return false
    end
  end

  def require_no_user
    if current_user
      store_location
      flash[:notice] = "You must be logged out to access this page"
      redirect_to "/"
      return false
    end
  end

  def store_location
    session[:return_to] = request.request_uri
  end

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

Worth noting the “ss” in user_methodss is not a mistake. Because of the way Comatose handles the string/symbol you pass in it wouldn’t render :user_methods but instead looked for :users_methods which was incorrect so this was our little hack to get around that.

So firstly you need to add the following to your UserSession model. What this does is overwrite the default login method with the one we are defining below called “find_by_username_or_mobile”.

class UserSession < Authlogic::Session::Base
  find_by_login_method :find_by_username_or_mobile
end

Then in your user model its as simply as creating the class method for login. Now of course the password is still apart of the login process but we only wanted to allow users to either login via their login or mobile so no need to change the password methods.

class User < ActiveRecord::Base
  def self.find_by_username_or_mobile(login)
    find_by_login(login) || find_by_mobile(login)
  end
end

So give it a try and let us know how you go hope this helps