cc = CreditCard.new(:card_number => 'invalid')
>> cc.save
=> false
>> cc.id
=> 3

def card_number=(num)
  update_attribute(:crypted_card_number, encrypt(num))
end

>> (19.99 * 100).to_s.to_i
=> 1999

#!/usr/bin/env ruby
 
if ARGV.size.zero?
  puts "Usage: #{File.basename($0)} name_of_project"
  exit
end
 
RAILS_ROOT = File.join(Dir.pwd, ARGV[0])
RAILS_ROOT << '/' unless RAILS_ROOT[0] =~ %r{/$}
 
unless File.exists?(RAILS_ROOT)
  puts "#{RAILS_ROOT}: No such file or directory"
  exit
end
 
ls = "ls --color"
scm = File.exists?('.git') ? 'git status' : 'svn status'
test_dir = File.exists?("#{RAILS_ROOT}spec") ? 'spec' : 'test'
 
[
  {
    :geometry => "140x38+90+270",
    :tabs => [
      {:path => "app/models", :command => ls},
      {:path => "app/views", :command => ls},
      {:path => "app/controllers", :command => ls},
      {:path => "app/helpers", :command => ls},
      {:path => "public", :command => ls},
      {:path => "vendor", :command => ls},
      {:path => test_dir, :command => ls},
      {:path => test_dir, :command => ls},
      {:path => "", :command => ls}
    ]
  },
  {
    :geometry => "141x32+185+110",
    :tabs => [
      {:path => "", :command => scm},
      {:path => "", :command => ls},
      {:path => "lib", :command => ls},
      {:path => "", :command => "ruby script/console"},
      {:path => "", :command => ls},
      {:path => "config/locales", :command => ls},
      {:path => "", :command => ls},
      {:path => "", :command => ls},
      {:path => "", :command => ls}
    ]
  }
].each do |window|
  tabs = window[:tabs].map {|tab| "--tab-with-profile=DEFAULT --working-directory='#{RAILS_ROOT}#{tab[:path]}' -e \"bash -c '#{tab[:command]}; bash'\""}.join(' ')
  system "gnome-terminal --geometry #{window[:geometry]} #{tabs}"
end

# lib/tasks/pig.rake
desc "Creates a config/locales/pig-US.yml from config/locales/en-US.yml"
task :pig => :environment do
  DEFAULT_LOCALE = 'en-US'
  File.open(File.join(RAILS_ROOT, 'config', 'locales', 'pig-US.yml'), "w") do |fout|
    File.readlines(File.join(RAILS_ROOT, 'config', 'locales', "#{DEFAULT_LOCALE}.yml")).each do |line|
      unless line =~ /"/
        fout.puts line.sub(DEFAULT_LOCALE, 'pig-US')
      else
        key, *translation = line.split(':')
        translation = translation.join(':')
        translation.split(/(".*?")/).each do |quote|
          if quote =~ /"/
            quote.gsub!('"', '')
            string = quote.split(/(\{\{.*?\}\})/).map do |s|
              (s =~ /\{\{/) ? s : `echo "#{s.gsub('$', '\$')}" | pig`.chomp
            end
            translation.sub!(quote, string.join)
          end
        end
        fout.puts "#{key}:#{translation}"
      end
    end
  end
end

# In some file that gets sourced on startup, like maybe in your config/initializers directory
module I18n
  module Backend
    class Moki < Simple
 
      def translate(locale, key, options = {})
        raise InvalidLocale.new(locale) if locale.nil?
        return key.map { |k| translate(locale, k, options) } if key.is_a? Array
        reserved = :scope, :default
        count, scope, default = options.values_at(:count, *reserved)
        options.delete(:default)
        values = options.reject { |name, value| reserved.include?(name) }
        entry = lookup(locale, key, scope)
        if entry.nil?
          entry = default(locale, default, options)
          entry ||= lookup(I18n.default_locale, key, scope)
          raise(I18n::MissingTranslationData.new(locale, key, options)) if entry.nil?
        end
        entry = pluralize(locale, entry, count)
        entry = interpolate(locale, entry, values)
        entry
      end
 
      def localize(locale, object, format = :default)
        return nil if object.nil?
        raise ArgumentError, "Object must be a Date, DateTime or Time object. #{object.inspect} given." unless object.respond_to?(:strftime)
        type = object.respond_to?(:sec) ? 'time' : 'date'
        formats = translate(locale, "#{type}.formats")
        format = formats[format.to_sym] if formats && formats[format.to_sym]
        format = format.to_s.dup
        format.gsub!(/%a/, translate(locale, "date.abbr_day_names")[object.wday])
        format.gsub!(/%A/, translate(locale, "date.day_names")[object.wday])
        format.gsub!(/%b/, translate(locale, "date.abbr_month_names")[object.mon])
        format.gsub!(/%B/, translate(locale, "date.month_names")[object.mon])
        format.gsub!(/%p/, translate(locale, "time.#{object.hour < 12 ? :am : :pm}")) if object.respond_to? :hour
        object.strftime(format)
      end
 
    end
  end
end
I18n.backend = I18n::Backend::Moki.new

  # Translated image tag
  def timage_tag(source, options = {})
    image_tag("#{I18n.locale}/#{source}", options)
  end

  # Translated will_paginate
  def twill_paginate(collection = nil, options = {})
    will_paginate collection, {:previous_label => t('constants.will_paginate.previous'), :next_label => t('constants.will_paginate.next')}.merge(options)
  end

# config/locales/en-US.yml
en-US:
  constants:
    will_paginate:
      previous: "« Previous"
      next: "Next »"

#config/locales/en-US.yml
en-US:
  activerecord:
    models:
      agent: "Agent"
    attributes:
      agent:
        name: "Name"
        some_calculated_value: "Some Calculated Value"

  # Translate from file (I18n namespace set to file path)
  def tf(file, key, options = {})
    t("#{file.gsub(%r|#{RAILS_ROOT}/app/\w*/|, '').sub(/\.(.*)$/, '').gsub('/', '.')}.#{key}", options)
  end

  <h1><%= tf __FILE__, "title" %></h1>

  def create
    @agent = Agent.new(params[:agent])
    if @agent.save
      flash[:notice] = tf(__FILE__, 'create_s')
      redirect_to documents_url
    else
      flash[:notice] = tf(__FILE__, 'create_f')
      render :action => 'new'
    end
  end

en-US:
  agent_interface:
    agents_controller:
      create_s: "Agent was successfully created."
      create_f: "Error creating agent."
    agents:
      new:
        title: "Create a new Agent"
      show:
        title: "Showing Agent"
      _form:
        legend: "Agent Information"
  layouts:
    agent_interface:
      agent_interface:
        login: "Log In"
        logout: "Log Out"

  current_page?(:action => 'process')
  # => false
 
  current_page?(:action => 'checkout')
  # => true

  def setup(options = {})
    options = {:income => 0, :expenses => 0}.merge(options)
  end

  def setup(options = {})
    options.reverse_merge! :income => 0, :expenses => 0
  end

  Date.parse("10/20/2008")

  "10/20/2008".to_date

script/plugin install svn://rubyforge.org/var/svn/geokit/trunk

script/generate scaffold location name:string address:string city:string \
state:string zip:string

t.decimal :lat, :precision => 15, :scale => 12
t.decimal :lng, :precision => 15, :scale => 12

class Location < ActiveRecord::Base
  acts_as_mappable
 
  validates_presence_of :name, :address, :city, :state, :zip, :lat, :lng
  before_validation_on_create :geocode_address
 
  private
    def geocode_address
      geo=GeoKit::Geocoders::MultiGeocoder.geocode("#{address} #{city} #{state} #{zip}")
      errors.add(:address, "Could not Geocode address") if !geo.success
      self.lat, self.lng = geo.lat,geo.lng if geo.success
    end
end

<div id="map" style="width: 890px; height: 600px;"></div>

# GET /locations
# GET /locations.xml
# GET /locations.js
def index
  respond_to do |format|
    format.html do
      @locations = Location.find(:all)
    end
    format.xml  { render :xml => @locations }
    format.js do
      ne = params[:ne].split(',').collect{|e|e.to_f}  
      sw = params[:sw].split(',').collect{|e|e.to_f}
      @locations = Location.find(:all, :limit => 100, :bounds => [sw, ne])
      render :json => @locations.to_json
    end
  end
end

<% unless @locations.blank? %>
  <script
    src="http://maps.google.com/maps?file=api&v=2.x&key=<%= GeoKit::Geocoders::google -%>"
    type="text/javascript"></script>
  <%= javascript_include_tag 'prototype', 'maps' %>
<% end %>

window.onunload = GUnload;
 
var map;
var markers = new Array();
 
Event.observe(window, 'load', function() {
  if (GBrowserIsCompatible()) {
    map = new GMap2(document.getElementById("map"));
    // Center the map on the US
    map.setCenter(new GLatLng(37.731145,-97.326092),4);
    GEvent.addListener(map,"moveend",function(){updateMap();});
    map.addControl(new GLargeMapControl());
    map.addControl(new GMapTypeControl());
 
    updateMap();
  }
});
 
function updateMap() {
  var bounds = map.getBounds();
  var southWest = bounds.getSouthWest();
  var northEast = bounds.getNorthEast();
 
  // Send an AJAX request for our locations
  new Ajax.Request('/locations.js', {
    method:'get',
    parameters: {sw: southWest.toUrlValue(), ne: northEast.toUrlValue()},
    onSuccess: function(transport){
      // Remove markers outside of our maps boundaries.
      if(markers.length > 0){
        removeMarkersOutsideOfMapBounds();
      }
 
      // Add our new markers to the map (unless they are already on the map.)
      var json = transport.responseText.evalJSON();
      json.each(function(i) {
        id = i.location.id;
        if(!markers[id] || markers[id] == null){
          // Marker doesnt exist, add it.
          markers[id] = createMarker(i.location);
          map.addOverlay(markers[id]);
        }
      });      
    }
  });
}
 
function createMarkerClickHandler(marker, location) {
  return function() {
    marker.openInfoWindowHtml(
      '<div><strong>' + location.name + '</strong><br/> ' +
      location.address + '<br/>' + location.city + ', ' +
      location.state + ' ' + location.zip + '</div>'
    );
    return false;
  };
}
 
function createMarker(location) {
  var latlng = new GLatLng(location.lat, location.lng);
  var marker = new GMarker(latlng);
  var handler = createMarkerClickHandler(marker, location);
  GEvent.addListener(marker, "click", handler);
  return marker;
}
 
function removeMarkersOutsideOfMapBounds() {
  for(i in markers) {
    if(i > 0 && markers[i] && !map.getBounds().containsLatLng(markers[i].getLatLng())) {
      map.removeOverlay(markers[i]);
      markers[i] = null;
    }
  }
}