Skip to content

Instantly share code, notes, and snippets.

@ahoward ahoward/gist:31014
Created Dec 2, 2008

Embed
What would you like to do?
# force const_missing to preload these classes
#
ActionController
ActionController::Base
ActiveRecord
ActiveRecord::Base
# support for using helper methods in controllers/models
#
class Helper
def Helper.list
ActionView::Helpers.constants.grep(/Helper/i).map do |const|
ActionView::Helpers.const_get(const)
end
end
attr_accessor 'controller'
def initialize controller = ( ActionController.current || ApplicationController.new ), *modules
@controller = controller
modules.push nil if modules.empty?
modules.flatten.each do |mod|
case mod
when NilClass, :all, 'all'
Helper.list.each{|helper| extend helper}
when Module
extend mod
when Symbol, String
mod = mod.to_s.underscore.sub(/helper$/, '')
Helper.list.each do |helper|
if mod == helper.name.underscore.sub(/helper$/, '')
extend helper
end
end
when Regexp
Helper.list.each do |helper|
if helper.name =~ mod
extend helper
end
end
else
raise ArgumentError, mod.class.name
end
end
extend @controller.master_helper_module if @controller
end
def session
controller.session
end
end
module ActionController
class << self
attr_accessor 'current'
end
end
class ActionController::Base
before_filter :setup_current_controller
after_filter :teardown_current_controller
protected
def setup_current_controller
::ActionController.current = self
end
def teardown_current_controller
::ActionController.current = nil
end
def helper &block
@helper = Helper.new(::ActionController.current || self)
block ? @helper.instance_eval(&block) : @helper
end
def self.helper_import *methods
methods.flatten.compact.each do |method|
code = <<-code
def #{ method } *a, &b
helper{ #{ method }(*a, &b) }
end
protected '#{ method }'
code
eval code
end
end
end
class ActiveRecord::Base
def helper &block
helper = Helper.new(::ActionController.current || ::ActionController::Base.new)
block ? helper.instance_eval(&block) : helper
end
end
# support for immediate (throw/catch) base rendering methods
#
class ActionController::Base
protected
def render! *a, &b
render *a, &b unless a.empty? and b.nil?
throw :render, self
end
def redirect_to! *a, &b
redirect_to *a, &b
ensure
render!
end
def redirect_to_url! *a, &b
redirect_to_url *a, &b
ensure
render!
end
def not_found! options = {}
options = {:inline => options} if String == options
options.to_options!
unless options.has_key?(:inline) or options.has_key?(:text)
options[:inline] = <<-html
<div style='padding:3em;color:#666;text-align:center;font-size:1.2em;'>
<p>
Sorry, but we could not find the page you are looking for.
</p>
<p style='color:#333'>
#{ h helper.url_for(request.request_uri) }
</p>
</div>
html
end
options[:status] ||= 404
options[:layout] ||= 'application' unless options[:layout] == false
render! options
end
def perform_action_without_filters
if self.class.action_methods.include?(action_name)
catch(:render){ send(action_name) }
render unless performed?
elsif respond_to? :method_missing
catch(:render){ send(:method_missing, action_name) }
render unless performed?
elsif template_exists? && template_public?
render
else
raise ::ActionController::UnknownAction, "No action responded to #{action_name}", caller
end
end
end
# generic error classes used for model level application errors
#
class ActiveRecord::Base
class Error < ::ActiveRecord::ActiveRecordError; end
class RecordNotFound < ::ActiveRecord::RecordNotFound; end
end
# support for logging to the rails log from anywhere in the codebase
#
class Object
def log(*a, &b)
logger = RAILS_DEFAULT_LOGGER
if a.empty? and b.nil?
logger
else
logger.info(*a, &b)
end
end
end
# support for conditional excution based on rails_env
#
class Object
%w( test development production training ).each do |rails_env|
module_eval <<-code
def #{ rails_env }? &block
if defined?(RAILS_ENV) and RAILS_ENV == '#{ rails_env }'
return( block ? block.call : true )
end
return false
end
code
end
def stage? &block
if defined?(RAILS_STAGE) and RAILS_STAGE
return( block ? block.call : true )
end
return false
end
end
# support for executing sql on the raw connection, getting back an array of
# results
#
class Object
def db(*a, &b)
connection = ActiveRecord::Base.connection.raw_connection
return connection if a.empty? and b.nil?
adapter = ActiveRecord::Base.configurations[ RAILS_ENV ][ 'adapter' ].to_s
case adapter
when 'oci', 'oracle'
cursor = connection.exec *a
if b
while row = cursor.fetch;
b.call row
end
else
returning [] do |rows|
while row = cursor.fetch
rows << row
end
end
end
when 'mysql', 'postgresql', 'sqlite'
if b
connection.query(*a).each do |row|
b.call row
end
else
returning [] do |rows|
connection.query(*a).each do |row|
rows << row
end
end
end
else
raise ArgumentError, "#{ adapter } not implemented yet"
end
end
end
# support for class level declarations of ActiveRecord default values for
# *new* records
#
class ActiveRecord::Base
class << self
def defaults *argv, &block
const_set(:Defaults, []) unless const_defined?(:Defaults)
defaults = const_get(:Defaults)
options =
if block
argv.flatten.inject({}){|h,k| h.update k => block}
else
case argv.size
when 2
{ argv.first => argv.last }
else
argv.inject({}){|h,x| h.update x.to_hash}
end
end
options.to_options!
unless options.empty?
options.each{|k,v| defaults << [k,v]}
add_after_initialize_with_defaults! defaults
end
defaults
end
alias_method :default, :defaults
def add_after_initialize_with_defaults! defaults = {}
return if defined?(@add_after_initialize_with_defaults)
after_initialize = instance_method(:after_initialize) rescue nil
define_method(:after_initialize) do |*args|
this = self
after_initialize.bind(self).call(*args) if after_initialize
return unless new_record?
defaults.each do |key, value|
value = instance_eval(&value) if value.respond_to?(:to_proc)
write_attribute key, value
end
end
ensure
@add_after_initialize_with_defaults = true unless $!
end
end
end
# support for indexing operator
#
class ActiveRecord::Base
def self.[](*args, &block)
find(*args, &block)
end
end
# support for using named routes from the console
#
def use_named_routes! options = {}
include ActionController::UrlWriter
options.to_options!
options.reverse_merge! :host => 'localhost', :port => 3000
default_url_options.reverse_merge!(options)
end
module Kernel
private
def transaction(*a, &b)
ActiveRecord::Base.transaction(*a, &b)
end
def rollback!
raise ActiveRecord::Rollback
end
def helper &block
helper = Helper.new(::ActionController.current || ::ActionController::Base.new)
block ? helper.instance_eval(&block) : helper
end
end
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.