adva_cms 0.0.1

data/lib/rails_ext/action_controller/default_params.rb

@@ -0,0 +1,19 @@
+ActionController::Base.class_eval do
+  class_attribute :default_param
+  self.default_param = {}
+  
+  class << self
+    def default_param(*args, &block)
+      before_filter(args.extract_options!) do |controller|
+        controller.default_param(*args, &block)
+      end
+    end
+  end
+
+  def default_param(*keys, &value)
+    key = keys.pop
+    value = instance_eval(&value)
+    target = keys.inject(params) { |target, k| target[k] ||= {} }
+    target[key] ||= value
+  end
+end

data/lib/rails_ext/action_controller/event_helper.rb

@@ -0,0 +1,18 @@
+module ActionController
+  module EventHelper
+    def trigger_events(object, *changes)
+      options = changes.extract_options!
+      # changes += object.state_changes
+      changes.uniq.each do |change|
+        trigger_event(object, change, options)
+      end
+    end
+    
+    def trigger_event(object, change = nil, options = {})
+      type = :"#{object.class.name.underscore}_#{change}"
+      Event.trigger type, object, self, options
+    end
+  end
+end
+
+ActionController::Base.send :include, ActionController::EventHelper

data/lib/rails_ext/action_controller/page_caching.rb

@@ -0,0 +1,23 @@
+ActionController::Base.class_eval do 
+  def expire_pages(pages)
+    pages.each { |page| expire_page(page.url) if page.url }
+    CachedPage.expire_pages(pages)
+  end
+
+  def expire_site_page_cache
+    # FIXME 
+    # We can not simply kill the whole cache dir.
+    # The following misses assets (like stylesheets) from themes though 
+    # because they are not referenced as cached, yet. Do we need to expire
+    # these assets at all though?
+    expire_pages CachedPage.find_all_by_site_id(@site.id)
+
+    # cache_dir = page_cache_directory
+    # if cache_dir.gsub('/', '') =~ /public$/ 
+    #   expire_pages CachedPage.find_all_by_site_id(@site.id)
+    # else
+    #   @site.cached_pages.delete_all
+    #   Pathname.new(cache_dir).rmtree rescue Errno::ENOENT
+    # end
+  end
+end

data/lib/rails_ext/action_controller/render_with_error_proc.rb

@@ -0,0 +1,46 @@
+ActionController::Base.class_eval do
+  class_attribute :default_error_proc
+
+  class << self
+    def renders_with_error_proc(error_proc_key)
+      self.default_error_proc = error_proc_key
+    end
+  end
+
+  cattr_accessor :field_error_procs
+  self.field_error_procs = {
+    :above_field => Proc.new { |html_tag, instance|
+      html_tag =~ /<label/ ? html_tag : %(<span class="error_message">#{Array(instance.error_message).to_sentence}</span>).html_safe + html_tag
+    },
+    :below_field => Proc.new { |html_tag, instance|
+      html_tag =~ /<label/ ? html_tag : html_tag + %(<span class="error_message">#{Array(instance.error_message).to_sentence}</span>).html_safe
+    }
+  }
+  
+  def render_with_error_proc(*args, &block)
+    options = args.last.is_a?(Hash) ? args.last : {}
+    with_error_proc(extract_error_proc_key(options)) do
+      render_without_error_proc(*args, &block)
+    end
+  end
+  alias_method_chain :render, :error_proc unless method_defined? :render_without_error_proc
+
+  def extract_error_proc_key(options)
+    error_proc_key = options.delete(:errors) if options.is_a? Hash
+    error_proc_key ||= self.class.default_error_proc
+  end
+
+  def with_error_proc(error_proc_key)
+    if error_proc_key
+      raise "invalid error_proc_key: #{error_proc_key}" unless self.field_error_procs[error_proc_key]
+      old_proc = ActionView::Base.field_error_proc
+      ActionView::Base.field_error_proc = self.field_error_procs[error_proc_key]
+      yield.tap do
+        ActionView::Base.field_error_proc = old_proc
+      end
+    else
+      yield
+    end
+  end
+  helper_method :with_error_proc
+end

data/lib/rails_ext/action_controller/responds_to_parent.rb

@@ -0,0 +1,46 @@
+# Module containing the methods useful for child IFRAME to parent window communication
+module RespondsToParent
+  # Executes the response body as JavaScript in the context of the parent window.
+  # Use this method of you are posting a form to a hidden IFRAME or if you would like
+  # to use IFRAME base RPC.
+  def responds_to_parent(&block)
+    yield
+    
+    if performed?
+      # We're returning HTML instead of JS or XML now
+      response.headers['Content-Type'] = 'text/html; charset=UTF-8'
+      
+      # Either pull out a redirect or the request body
+      script =  if location = erase_redirect_results
+                  "document.location.href = #{location.to_s.inspect}"
+                else
+                  response.body
+                end
+                
+      # Escape quotes, linebreaks and slashes, maintaining previously escaped slashes
+      # Suggestions for improvement?
+      script = (script || '').
+        gsub('\\', '\\\\\\').
+        gsub(/\r\n|\r|\n/, '\\n').
+        gsub(/['"]/, '\\\\\&').
+        gsub('</script>','</scr"+"ipt>')
+
+      # Clear out the previous render to prevent double render
+      erase_results
+      
+      # Eval in parent scope and replace document location of this frame 
+      # so back button doesn't replay action on targeted forms
+      # loc = document.location to be set after parent is updated for IE
+      # with(window.parent) - pull in variables from parent window
+      # setTimeout - scope the execution in the windows parent for safari
+      # window.eval - legal eval for Opera
+      render :text => "<html><body><script type='text/javascript' charset='utf-8'>
+        var loc = document.location;
+        with(window.parent) { setTimeout(function() { window.eval('#{script}'); loc.replace('about:blank'); }, 1) } 
+      </script></body></html>"
+    end
+  end
+  alias respond_to_parent responds_to_parent
+end
+
+ActionController::Base.send :include, RespondsToParent

data/lib/rails_ext/action_controller/url_for_returning.rb

@@ -0,0 +1,12 @@
+ActionController::Base.class_eval do
+  def url_for_with_returning(options = {})
+    return url_for_without_returning(options) unless options.is_a?(Hash)
+
+    case returning = options.delete(:return)
+    when true, :here
+      options.reverse_merge! :return_to => params[:return_to] || request.request_uri
+    end
+    url_for_without_returning(options)
+  end
+  alias_method_chain :url_for, :returning
+end

data/lib/rails_ext/active_record/exists.rb

@@ -0,0 +1,5 @@
+ActiveRecord::Base.class_eval do
+  def exists?
+    !new_record?
+  end
+end

data/lib/rails_ext/active_record/sti_instantiation.rb

@@ -0,0 +1,35 @@
+# http://coderrr.wordpress.com/2008/04/22/building-the-right-class-with-sti-in-rails/
+
+module ActiveRecord::StiInstantiation
+  module ActMacro
+    def instantiates_with_sti
+      include InstanceMethods
+      extend ClassMethods
+      instantiates_with_sti?
+    end
+
+    def instantiates_with_sti?
+      included_modules.include?(ActiveRecord::StiInstantiation::InstanceMethods)
+    end
+  end
+
+  module InstanceMethods
+  end
+
+  module ClassMethods
+    def new(*args, &block)
+      options = args.first.is_a?(Hash) ? args.first : {}
+      type = options[:type] || options['type']
+      klass = type.is_a?(Class) ? type : type.constantize if type
+
+      if type and klass != self
+        raise "STI instantiation error: class #{klass.name} should be a descendant of #{self.name}" unless klass < self
+        klass.new(*args, &block)
+      else
+        super
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :extend, ActiveRecord::StiInstantiation::ActMacro

data/lib/rails_ext/active_record/sticky_changes.rb

@@ -0,0 +1,30 @@
+# This stops the record from forgetting changes when the record 
+# is saved.
+#
+# If you're interested in changes between subsequent saves
+# you can call #clear_changes! to clear them.
+
+# ActiveRecord::Base.class_eval do
+#   alias :save :save_without_dirty
+#   alias :save! :save_without_dirty!
+#   
+#   def clear_changes! # TODO figure out a better name
+#     changed_attributes.clear
+#   end
+#   
+#   def state_changes
+#     if frozen?
+#       [:deleted]
+#     elsif just_created?
+#       [:created]
+#     elsif changed?
+#       [:updated]
+#     else
+#       []
+#     end
+#   end
+#   
+#   def just_created?
+#     !!changes['id'] and changes['id'].first.nil?
+#   end
+# end

data/lib/rails_ext/railties/plugin.rb

@@ -0,0 +1,58 @@
+# - keep track of plugins in Rails.plugins
+# - allow engines to ship their own vendor/plugins
+# - add observers to plugin.app_paths
+# - add an alias to register_[asset]_expansion to plugins
+Rails::Configuration.class_eval do
+  def default_plugin_loader
+    Rails::Plugin::RegisteringLoader
+  end
+  
+  def default_plugin_locators
+    locators = []
+    locators << Rails::Plugin::GemLocator if defined? Gem
+    locators << Rails::Plugin::NestedFileSystemLocator
+  end
+end
+
+module Rails
+  class << self
+    def plugins
+      @@plugins ||= ActiveSupport::OrderedHash.new
+    end
+  
+    def plugin?(name)
+      plugins.keys.include?(name.to_sym)
+    end
+  end
+
+  class Plugin
+    class RegisteringLoader < Rails::Plugin::Loader # ummm, what's a better name?
+      def register_plugin_as_loaded(plugin)
+        Rails.plugins[plugin.name.to_sym] = plugin
+        super
+      end
+    end
+  
+    def app_paths
+      ['models', 'helpers', 'observers'].map { |path| File.join(directory, 'app', path) } << controller_path << metal_path
+    end
+  
+    def register_javascript_expansion(*args)
+      ActionView::Helpers::AssetTagHelper.register_javascript_expansion *args
+    end
+  
+    def register_stylesheet_expansion(*args)
+      ActionView::Helpers::AssetTagHelper.register_stylesheet_expansion *args
+    end
+    
+    class NestedFileSystemLocator < FileSystemLocator
+      def locate_plugins_under(base_path)
+        plugins = super
+        Dir["{#{plugins.map(&:directory).join(',')}}/vendor/plugins"].each do |path|
+          plugins.concat super(path)
+        end unless plugins.empty?
+        plugins
+      end
+    end
+  end
+end

data/lib/rails_ext/railties/plugin_configuration.rb

@@ -0,0 +1,72 @@
+module Rails 
+  class Plugin
+    module Configurable
+      class Config < ActiveRecord::Base
+        self.table_name = 'plugin_configs'
+        serialize :options, Hash
+        belongs_to :owner, :polymorphic => true
+
+        after_initialize do
+          write_attribute(:options, {}) if read_attribute(:options).nil?
+        end
+      end
+      
+      attr_accessor :owner
+
+      def option_definitions
+        @option_definitions ||= {}
+      end
+
+      def option(name, default, type = :string)
+        define_option_accessors(name, default)
+        option_definitions[name.to_sym] = { :default => default, :type => type }
+      end
+
+      def options=(options)
+        # FIXME symbolize_keys and slice defined options
+        config.options = options
+      end
+
+      def id
+        name
+      end
+
+      def to_param
+        name
+      end
+
+      def save!
+        config.save!
+      end
+
+      def destroy
+        config.destroy
+        @config = nil
+      end
+
+      private
+      
+        def define_option_accessors(name, default)
+          raise "can't use #{name.inspect} as an option name" if respond_to? name
+          instance_eval <<-END, __FILE__, __LINE__
+            def #{name}
+              config.options[#{name.inspect}] || #{default.inspect}
+            end
+            def #{name}=(value)
+              config.options[#{name.inspect}] = value
+            end
+          END
+        end
+
+        def config
+          @config ||= begin
+            raise 'undefined @owner for plugin config' unless @owner
+            Config.find_by_name_and_owner_type_and_owner_id(self.name, @owner.class.name, @owner.id) ||
+            Config.new(:name => self.name, :owner => @owner)
+          end
+        end
+    end
+  end
+end
+
+Rails::Plugin.send :include, Rails::Plugin::Configurable

data/lib/rails_ext/railties/plugin_initializers.rb

@@ -0,0 +1,25 @@
+# Rails::Initializer.class_eval do
+#   def load_application_initializers_with_plugin_initializers
+#     if gems_dependencies_loaded
+#       plugin_loader.load_plugin_initializers 
+#     end
+#     load_application_initializers_without_plugin_initializers
+#   end
+#   alias_method_chain :load_application_initializers, :plugin_initializers
+# end
+# 
+# Rails::Plugin::Loader.class_eval do
+#   def load_plugin_initializers
+#     plugins.each do |plugin| 
+#       plugin.load_plugin_initializers if plugin.engine?
+#     end
+#   end
+# end
+# 
+# Rails::Plugin.class_eval do
+#   def load_plugin_initializers
+#     Dir["#{directory}/config/initializers/**/*.rb"].sort.each do |initializer|
+#       Kernel.load(initializer)
+#     end
+#   end
+# end

data/lib/registry.rb

@@ -0,0 +1,49 @@
+class Registry < Hash
+  class << self
+    def instance
+      @@instance ||= new
+    end
+    
+    def get(*args)
+      instance.get *args
+    end
+    
+    def set(*args)
+      instance.set *args
+    end
+    
+    def clear
+      instance.clear
+    end
+  end
+
+  def initialize
+    blk = lambda {|h,k| h[k] = Registry.new(&blk)}
+    super &blk
+  end
+
+  def set(*args)
+    value, last_key = args.pop, args.pop
+    target = args.inject(self){|result, key| result[key] }
+    value = to_registry(value) if value.is_a?(Hash)
+    target[last_key] = value
+  end
+
+  def get(*keys)
+    keys.inject self do |result, key| 
+      return nil unless result.has_key?(key)
+      result[key]
+    end
+  end
+  
+  protected
+  
+    def to_registry(hash)
+      registry = Registry.new
+      hash.each do |key, value|
+        value = to_registry(value) if value.is_a?(Hash)
+        registry[key] = value
+      end
+      registry
+    end
+end