module ActionController
  class AbstractRequest
    attr_reader :recognized_route
    
    def init_recognized_route_from_path_parameters
      recognized_route = path_parameters.delete(:recognized_route) 
    end
  end

  module Routing
    
    class RouteSet
      def recognize_with_route(request)
        result = recognize_without_route(request)
        request.init_recognized_route_from_path_parameters
        result
      end
      alias_method_chain :recognize, :route

      def write_recognize_optimized_with_route
        tree = segment_tree(routes)
        body = generate_code(tree)
        instance_eval %{
          def recognize_optimized(path, env)
            segments = to_plain_segments(path)
            index = #{body}
            return nil unless index
            while index < routes.size
              result = routes[index].recognize(path, env) and result[:recognized_route] = routes[index] and return result
              index += 1
            end
            nil
          end
        }, __FILE__, __LINE__
      end
      alias_method_chain :write_recognize_optimized, :route

    end
  end
end

has_many :things do
  def active
    find :all, :conditions => ['active = ?', true]
  end
end

extensions = lambda {
  def active
    find :all, :conditions => ['active = ?', true]
  end
}

has_many :things, &extensions
has_many :more_things, &extensions

class PeopleController < ApplicationController
  caches_action :show, :for => 1.hour, :cache_path => Proc.new { |c| "people/#{c.params[:id]}_for_#{Person.logged_in.id}" }
end

module ActionController
  module Caching
    module Fragments
      # expire a cache key only if the block returns true or
      # if the age of the fragment is more than the specified age argument.
      def expire_fragment_by_mtime(key, age=nil, &block)
        block = Proc.new { |m| m < age.ago } unless block_given?
        if (m = cache_store.mtime(fragment_cache_key(key))) and block.call(m)
          expire_fragment(key)
        end
      end
    end
    module Actions
      module ClassMethods
        # adds an option :for
        # caches_action :show, :for => 2.hours, :cache_path => ...
        # :cache_path is required, unfortunately
        def caches_action_with_for(*actions)
          original_actions = actions.clone
          options = actions.extract_options!
          if for_time = options.delete(:for)
            cache_path = options[:cache_path]
            before_filter do |controller|
              cache_path = cache_path.call(controller) if cache_path.respond_to?(:call)
              controller.expire_fragment_by_mtime(cache_path, for_time)
            end
          end
          caches_action_without_for(*original_actions)
        end
        alias_method_chain :caches_action, :for
      end
    end
  end
end

# Add a method to grab the last modified time of the cache key.
# If you use a store other than the FileStore, you'll need to add
# a method like this to your store.
module ActiveSupport
  module Cache
    class FileStore
      def mtime(name)
        File.mtime(real_file_path(name)) rescue nil
      end
    end
  end
end

rake radiant:freeze:gems

map.resources :titles, :member => { :rate => :any }

require 'linguistics'
Linguistics::use(:en)  # extends Array, String, and Numeric

<ul class="star-rating" id="<%= dom_id(@title) -%>_rating"><%= render :partial => '/partials/star_rating', :locals => { :record => @title } %></ul>

<li class="current-rating" style="width: <%= number_to_percentage((record.rating.to_f * 25) / (5 * 25) * 100) -%>;">Currently <%= record.rating -%>/5 Stars.</li>
<% (1..5).each do |i| -%>
    <li><%= link_to_remote pluralize(i, 'Star'), {
        :update => "#{dom_id(record)}_rating",
        :url => eval("rate_#{record.class.name.downcase}_url(:rating => #{i})")
    }, {
        :class => "#{i.en.numwords}-#{i.abs == 1 ? 'star' : 'stars'}",
        :title => "#{pluralize(i, 'star')} out of 5"
    } -%></li>
<% end -%>

require 'digest/sha1'

# this model expects a certain database layout and its based on the name/login pattern.
class User < ActiveRecord::Base
        has_and_belongs_to_many :groups,
                :class_name => 'Group',
                :join_table => 'users_groups'

        def self.authenticate(username, password)
                @user = find(:first, :conditions => ["username = ? AND password = ? and confirmed = ?", username, sha1(password), true])
        end

        def remember_me
                self.remember_token_expires = 2.weeks.from_now
                self.remember_token = Digest::SHA1.hexdigest("GFDHDFUHFJI&&%ET%&*%^£FESER^&J&IJR%TXEYFGU(*I$R^%E&DU&-#{self.email}#{self.remember_token_expires}")
                self.save_with_validation(false)
        end

        def forget_me
                self.remember_token_expires = nil
                self.remember_token = nil
                self.save_with_validation(false)
        end

        def reset_password
                tmppwd = self.generate_password
                write_attribute("password", self.class.sha1(tmppwd))
                self.save_with_validation(false)
                tmppwd
        end

        protected

        def generate_password
                chars = ("a".."z").to_a + ("1".."9").to_a
                Array.new(6, '').collect{chars[rand(chars.size)]}.join
        end

        def self.sha1(pass)
                Digest::SHA1.hexdigest(pass + "FSDT%^Y&JTFHY^&*IFY^H&&*(T&&RG%U&*I^HFGCDUI*TUF^HYU&*Y&T^F&*^&FUH")
        end

        before_create :crypt_password

        def crypt_password
                write_attribute("password", self.class.sha1(password))
        end

        validates_length_of :username, :within => 4..24
        validates_length_of :password, :within => 6..32
        validates_presence_of :username, :password, :password_confirmation
        validates_uniqueness_of :username, :on => :create
        validates_confirmation_of :password, :on => :create

        validates_format_of :email, :with => /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
        validates_format_of :username, :with => /^(\w*)$/i
        validates_format_of :name, :with => /^([\w ]*)$/i

        validates_presence_of :email, :name
        validates_length_of :name, :within => 6..32
        validates_uniqueness_of :email, :on => :create
end

class String
  def translit
    ActiveSupport::Multibyte::Handlers::UTF8Handler.normalize(self,:d).split(//u).reject { |e| e.length > 1 }.join
  end
end

def l(id,label)
    "<label for='#{id}'>#{label}</label>"
end

<%= l('my_field_id','My Label') %>

module ActionView
  module Helpers
    module NumberHelper
      def number_to_currency(number, options = {})
        options  = options.stringify_keys
        precision = options["precision"] || 2
        unit    = options["unit"] || "$"
        separator = precision > 0 ? options["separator"] || "." : ""
        delimiter = options["delimiter"] || ","

        begin
          parts = number_with_precision(number, precision).split('.')
          delimitered_number = number_with_delimiter(parts[0], delimiter) + separator + parts[1].to_s
          if Float(number) >= 0.00
            unit + delimitered_number
          else
            #'(' + unit + delimitered_number.gsub(/^-/, '') + ')'
            '-' + unit + delimitered_number.gsub(/^-/, '')
          end
        rescue
          number
        end
      end
    end
  end
end