class User
  def to_json
    super(:except => [:password, :password_salt, :encrypted_password,
      :last_sign_in_ip, :updated_at, :current_sign_in_ip,
      :remember_token, :reset_password_token, :remember_created_at])
  end
end

@user = User.first
@user.to_json
# works fine

@users = User.all
@users.to_json
# prints all attributes (does not hit our custom to_json)

@users = User.all
data = {}
data[:results] = @users
data[:count] = @users.length
data.to_json
# prints all attributes (does not hit our custom to_json)

class User
def as_json(options)
    super(:except => [:password, :password_salt, :encrypted_password,
      :last_sign_in_ip, :updated_at, :current_sign_in_ip,
      :remember_token, :reset_password_token, :remember_created_at])
  end
end
 
...
@users = User.order_by("last_name")
      if @users
        data = {}
        data[:results] = @users
        res = data.as_json
        ActiveSupport::JSON.encode(res)
...

class JoinDuplicateRemover
 
  def self.de_dup
    models_dedup_hash = {
      AccountEventType => [:account_id, :event_type_id],
      ClientEventType => [:client_id, :event_type_id],
      AccountProductPackage => [:account_id, :product_package_id],
      ClientProductPackage => [:client_id, :product_package_id],
      ClientEventCountry => [:client_id, :country_id],
      ClientResearchCountry => [:client_id, :country_id],
      AccountEventCountry => [:account_id, :country_id],
      AccountResearchCountry => [:account_id, :country_id]
    }
 
    models_dedup_hash.each do |klass,scope_attrs|
 
      puts "\nStart de-duping #{klass.to_s} - #{Time.now}"
      rows_to_del = []
      index = 0
 
      klass.all.each do |instance|
 
        index += 1
        if index % 10 == 0
          print "."
          STDOUT.flush
        end
 
        conditions_hash = Hash.new
        scope_attrs.each do |sa|
          conditions_hash[sa] = instance.send(sa)
        end
        klass.where(conditions_hash).each_with_index do |dupl,i|
          rows_to_del << dupl.id unless i == 0 or rows_to_del.include?(dupl.id) 
        end
      end
 
      rows_to_del.each do |dupl|
        instance = klass.find(dupl)
        puts "Destroying: #{instance.inspect}"
        instance.destroy
      end
 
      puts "\nFinished de-duping #{klass.to_s} - #{Time.now}"
    end
  end
 
end

class AssetDeliveryPopulater
 
  def self.populate
    results_text = []
    asset_secrets_count, asset_delivery_count, asset_not_found_count, asset_delivery_creation_errors = 0,0,0,0
 
    Email.all.tap{|emails| results_text << "#{emails.length} emails parsed." }.each do |e|
      next unless e.body
 
      asset_secrets = extract_asset_secrets_from_text(e.body)
      next unless asset_secrets
 
      asset_secrets.tap{|as| asset_secrets_count += as.length}.each do |asset_secret|
        if a = Asset.find_by_secret(asset_secret)
          if ad = AssetDelivery.create(
              :asset => a,
              :campaign => e.campaign,
              :client => e.client,
              :created_at => e.created_at
            )
            asset_delivery_count += 1
            puts "Recorded an asset delivery: #{ad.inspect}"
          else
            asset_delivery_creation_errors += 1
            puts "Could not record the delivery: #{ad.errors.inspect}"
          end
        else
          asset_not_found_count += 1
          puts "Could not find asset with secret #{asset_secret}"
        end
      end
    end
 
    results_text << "#{asset_secrets_count} asset secrets found."
    results_text << "#{asset_delivery_count} asset deliveries recorded."
    results_text << "#{asset_not_found_count} assets not found."
    results_text << "#{asset_delivery_creation_errors} asset delivery records not created due to errors."
    puts results_text.join("\n")
  end
 
  # Given some text, extract secret asset hashes and return an array
  def self.extract_asset_secrets_from_text(text)
    text.scan(/http:\/\/[^'\/]+\/products\/([^'\/]+)/).first
  end
end

post  '/api/v1/users/', 
          params.merge(:sig => 
             Authentication.calculate(TestAuthData.secret_access_key,params.to_query)
          ).to_json

sig = Authentication.calculate(TestAuthData.secret_access_key,params.to_query)
puts "sig = #{sig}"
post  '/api/v1/users/', params.merge(:sig => sig).to_json

post  '/api/v1/users/', 
          params.merge(:sig => 
            Authentication.calculate(TestAuthData.secret_access_key,params.to_query).tap{|s| puts "sig = #{s}"}
          ).to_json

rake spec

devise_for :users
resources :users

class UsersController < ApplicationController
  before_filter :get_user, :only => [:index,:new,:edit]
  before_filter :accessible_roles, :only => [:new, :edit, :show, :update, :create]
  load_and_authorize_resource :only => [:show,:new,:destroy,:edit,:update]
 
  # GET /users
  # GET /users.xml                                                
  # GET /users.json                                       HTML and AJAX
  #-----------------------------------------------------------------------
  def index
    @users = User.accessible_by(current_ability, :index).limit(20)
    respond_to do |format|
      format.json { render :json => @users }
      format.xml  { render :xml => @users }
      format.html
    end
  end
 
  # GET /users/new
  # GET /users/new.xml                                            
  # GET /users/new.json                                    HTML AND AJAX
  #-------------------------------------------------------------------
  def new
    respond_to do |format|
      format.json { render :json => @user }   
      format.xml  { render :xml => @user }
      format.html
    end
  end
 
  # GET /users/1
  # GET /users/1.xml                                                       
  # GET /users/1.json                                     HTML AND AJAX
  #-------------------------------------------------------------------
  def show
    respond_to do |format|
      format.json { render :json => @user }
      format.xml  { render :xml => @user }
      format.html      
    end
 
  rescue ActiveRecord::RecordNotFound
    respond_to_not_found(:json, :xml, :html)
  end
 
  # GET /users/1/edit                                                      
  # GET /users/1/edit.xml                                                      
  # GET /users/1/edit.json                                HTML AND AJAX
  #-------------------------------------------------------------------
  def edit
    respond_to do |format|
      format.json { render :json => @user }   
      format.xml  { render :xml => @user }
      format.html
    end
 
  rescue ActiveRecord::RecordNotFound
    respond_to_not_found(:json, :xml, :html)
  end
 
  # DELETE /users/1     
  # DELETE /users/1.xml
  # DELETE /users/1.json                                  HTML AND AJAX
  #-------------------------------------------------------------------
  def destroy
    @user.destroy!
 
    respond_to do |format|
      format.json { respond_to_destroy(:ajax) }
      format.xml  { head :ok }
      format.html { respond_to_destroy(:html) }      
    end
 
  rescue ActiveRecord::RecordNotFound
    respond_to_not_found(:json, :xml, :html)
  end
 
  # POST /users
  # POST /users.xml         
  # POST /users.json                                      HTML AND AJAX
  #-----------------------------------------------------------------
  def create
    @user = User.new(params[:user])
 
    if @user.save
      respond_to do |format|
        format.json { render :json => @user.to_json, :status => 200 }
        format.xml  { head :ok }
        format.html { redirect_to :action => :index }
      end
    else
      respond_to do |format|
        format.json { render :text => "Could not create user", :status => :unprocessable_entity } # placeholder
        format.xml  { head :ok }
        format.html { render :action => :new, :status => :unprocessable_entity }
      end
    end
  end
  ...
end

  # Get roles accessible by the current user
  #----------------------------------------------------
  def accessible_roles
    @accessible_roles = Role.accessible_by(current_ability,:read)
  end
 
  # Make the current user object available to views
  #----------------------------------------
  def get_user
    @current_user = current_user
  end

  # PUT /users/1
  # PUT /users/1.xml
  # PUT /users/1.json                                            HTML AND AJAX
  #----------------------------------------------------------------------------
  def update
    if params[:user][:password].blank?
      [:password,:password_confirmation,:current_password].collect{|p| params[:user].delete(p) }
    else
      @user.errors[:base] << "The password you entered is incorrect" unless @user.valid_password?(params[:user][:current_password])
    end
 
    respond_to do |format|
      if @user.errors[:base].empty? and @user.update_attributes(params[:user])
        flash[:notice] = "Your account has been updated"
        format.json { render :json => @user.to_json, :status => 200 }
        format.xml  { head :ok }
        format.html { render :action => :edit }
      else
        format.json { render :text => "Could not update user", :status => :unprocessable_entity } #placeholder
        format.xml  { render :xml => @user.errors, :status => :unprocessable_entity }
        format.html { render :action => :edit, :status => :unprocessable_entity }
      end
    end
 
  rescue ActiveRecord::RecordNotFound
    respond_to_not_found(:js, :xml, :html)
  end

<!-- table header stuff here -->
<% @users.each do |u| %>
  <tr>
    <td><%= link_to_if(can?(:read, User), "#{u.name}", user_path(u.id)) {} %></td>
    <td><%= "#{u.email}" %></td>
    <td><%= "#{u.roles.collect{|r| r.name}}" %></td>
    <td><%= link_to_if(can?(:edit, User), image_tag("/images/edit_icon.gif"), edit_user_path(u.id)) {} %></td>
    <td><%= link_to_if(can?(:delete, u), image_tag("/images/delete_icon.gif"), u, :confirm => "Are you sure?", :method => :delete) {} %></td>
  </tr>
<% end %>

<h2>Register User</h2>
 
<%= form_for(@user) do |f| %>
  <%= error_messages(@user,"Could not register user") %>
 
  <%= render :partial => 'user_fields', :locals => { :f => f } %>
 
  <p><%= f.label :password %></p>
  <p><%= f.password_field :password %></p>
 
  <p><%= f.label :password_confirmation %></p>
  <p><%= f.password_field :password_confirmation %></p>
 
  <p><%= f.submit "Register" %></p>
<% end %>

<p><%= f.label :first_name %></p>
<p><%= f.text_field :first_name %></p>
 
<p><%= f.label :last_name %></p>
<p><%= f.text_field :last_name %></p>
 
<p><%= f.label :email %></p>
<p><%= f.text_field :email %></p>
 
<% if can? :read, Role %>
	<p><%= f.label :role %></p>
	<ul class="no-pad no-bullets">
		<%= habtm_checkboxes(@user, :role_ids, @accessible_roles, :name) %>
	</ul>
<% end %>

<h3><%= @user == @current_user ? "Your Account Settings" : "Edit User" %></h3>
 
<%= form_for(@user, :html => { :method => :put }) do |f| %>
	<%= error_messages(@user,"Could not update user") %>
	<%= render :partial => 'user_fields', :locals => { :f => f } %>
 
	<p><%= f.label :password %> <i>(leave blank if you don't want to change it)</i></p>
	<p><%= f.password_field :password %></p>
 
	<p><%= f.label :password_confirmation %></p>
	<p><%= f.password_field :password_confirmation %></p>
 
	<p><%= f.label :current_password %> <i>(we need your current password to confirm your changes)</i></p>
	<p><%= f.password_field :current_password %></p>
 
  <p><%= f.submit "Update" %></p>
<% end %>
<%= link_to "Back", :back %>

<h3><%= @user.name %></h3>
 
<%= link_to_if(can?(:update,@user), "Edit", edit_user_path(@user)) %> |
<%= link_to_if(can?(:delete, @user), "Delete", user_path(@user), :confirm => "Are you sure?", :method => :delete) {} %>
 
<table class="one-column-emphasis">
	<tbody>
		<tr>
			<td class="oce-first">Email:</td>
			<td><%= @user.email %></td>
		</tr>
		<tr>
			<td class="oce-first">Role:</td>
			<td><%= @user.roles.first.name %></td>
		</tr>
	<% if can?(:see_timestamps,User) %>
		<tr>
			<td class="oce-first">Created at:</td>
			<td><%= @user.created_at %></td>
		</tr>
		<tr>
			<td class="oce-first">Last Sign In:</td>
			<td><%= @user.last_sign_in_at %></td>
		</tr>
		<tr>
			<td class="oce-first">Sign In Count:</td>
			<td><%= @user.sign_in_count %></td>
		</tr>
	<% end %>
	</tbody>
</table>

#------------------------------------------------
def initialize(user)
    user ||= User.new # guest user
 
    if user.role? :admin
      can :see_timestamps, User
    elsif user.role? :normal
      can :see_timestamps, User, :id => user.id
    end
end

gem install devise
rails generate devise:install
rails generate devise user

# In your model
 class User < ActiveRecord::Base
    devise :database_authenticatable, :confirmable, :recoverable, :rememberable, :trackable, :validatable
end
 
# In your migration
create_table :users do |t|
    t.database_authenticatable
    t.confirmable
    t.recoverable
    t.rememberable
    t.trackable
    t.timestamps
end
 
# In your routes
devise_for :users

# In your controllers
before_filter :authenticate_user!, :except => [:some_action_without_auth]
# Access Current User
def index
    @things = current_user.things
end

rails generate devise:views

class CreateRoles < ActiveRecord::Migration
  def self.up
    create_table :roles do |t|
      t.string :name
      t.timestamps
    end
  end
 
  def self.down
    drop_table :roles
  end
end
 
class UsersHaveAndBelongToManyRoles < ActiveRecord::Migration
  def self.up
    create_table :roles_users, :id => false do |t|
      t.references :role, :user
    end
  end
 
  def self.down
    drop_table :roles_users
  end
end

# User Model
class User < ActiveRecord::Base
  has_and_belongs_to_many :roles
....
# Role model
class Role < ActiveRecord::Base
  has_and_belongs_to_many :users
end

class Ability
  include CanCan::Ability
 
  def initialize(user)
    user ||= User.new # guest user
 
    if user.role? :super_admin
      can :manage, :all
    elsif user.role? :product_admin
      can :manage, [Product, Asset, Issue]
    elsif user.role? :product_team
      can :read, [Product, Asset]
      # manage products, assets he owns
      can :manage, Product do |product|
        product.try(:owner) == user
      end
      can :manage, Asset do |asset|
        asset.assetable.try(:owner) == user
      end
    end
  end
end

def role?(role)
    return !!self.roles.find_by_name(role.to_s.camelize)
end

class Users::RegistrationsController < Devise::RegistrationsController
  before_filter :check_permissions, :only => [:new, :create, :cancel]
  skip_before_filter :require_no_authentication
 
  def check_permissions
    authorize! :create, resource
  end
end

# replace devise_for :users with:
devise_for :users,  :controllers => { :registrations => "users/registrations" }

class ApplicationController < ActionController::Base
  ...
  rescue_from CanCan::AccessDenied do |exception|
    flash[:error] = exception.message
    redirect_to root_url
  end
  ...
end

alias spotlight-off='sudo mdutil -a -i off && sudo mv /System/Library/CoreServices/Search.bundle/ /System/Library/CoreServices/SearchOff.bundle/'
alias spotlight-on='sudo mdutil -a -i on && sudo mv /System/Library/CoreServices/SearchOff.bundle/ /System/Library/CoreServices/Search.bundle/'

source ~/.bash_profile

$ spotlight-off

$ ps aux | grep SystemUIServer.app
# take note of the PID which is the first number you will see
$ kill -HUP <insert PID here>