adva_cms 0.0.1

data/lib/extensible_forms.rb

@@ -0,0 +1,283 @@
+require 'action_view'
+require 'action_view/helpers'
+require 'action_view/helpers/form_helper'
+
+module ActionView
+  module Helpers
+    module FormHelper
+      def fields_for_with_resource_form_builders(name, *args, &block)
+        name = singular_class_name(name) unless name.class.in?(String, Symbol)
+
+        options = args.last.is_a?(Hash) ? args.last : {}
+        options[:builder] ||= pick_form_builder(name)
+
+        fields_for_without_resource_form_builders(name, *args, &block)
+      end
+      alias_method_chain :fields_for, :resource_form_builders
+
+      def field_set(object_name, name, content = nil, options = {}, &block)
+        options.delete(:object)
+        options[:name] ||= name
+        options[:id] ||= name
+        content ||= self.capture(&block) if block_given?
+        content_tag("fieldset", raw(content), options).html_safe
+      end
+
+      protected
+        def singular_class_name(name)
+          ActiveModel::Naming.singular(name)
+        end
+
+        def pick_form_builder(name)
+          name = "#{name.to_s.classify}FormBuilder"
+          name.constantize
+        rescue NameError
+          Object.const_set(name, Class.new(ActionView::Base.default_form_builder)) rescue ActionView::Base.default_form_builder
+        end
+    end
+  end
+end
+
+class ExtensibleFormBuilder < ActionView::Helpers::FormBuilder
+  class_attribute :callbacks
+  self.callbacks = { :before => {}, :after => {} }
+
+  class_attribute :tabs
+  self.tabs = []
+
+  class_attribute :options
+  self.options = { :labels => false, :wrap => false, :default_class_names => {} }
+
+  class << self
+    [:labels, :wrap].each do |option|
+      define_method(:"#{option}=") { |value| self.options[option] = value }
+    end
+
+    def default_class_names(type = nil)
+      if type
+        self.options[:default_class_names][type] ||= []
+      else
+        self.options[:default_class_names]
+      end
+    end
+
+    def before(object_name, method, string = nil, &block)
+      add_callback(:before, object_name, method, string || block)
+    end
+
+    def after(object_name, method, string = nil, &block)
+      add_callback(:after, object_name, method, string || block)
+    end
+
+    def tab(name, options = {}, &block)
+      self.tabs.reject! { |n, b| name == n }
+      self.tabs << [name, block]
+    end
+
+    protected
+
+      def add_callback(stage, object_name, method, callback)
+        method = method.to_sym
+        callbacks[stage][object_name] ||= { }
+        callbacks[stage][object_name][method] ||= []
+        callbacks[stage][object_name][method] << callback
+      end
+  end
+
+  helpers = field_helpers + %w(select date_select datetime_select time_select time_zone_select collection_select) -
+                            %w(hidden_field label fields_for apply_form_for_options!)
+
+  helpers.each do |method_name|
+    class_eval <<-src, __FILE__, __LINE__
+      def #{method_name}(*args, &block)
+        type = #{method_name.to_sym.inspect}
+
+        options = args.extract_options!
+        options = add_default_class_names(options, type)
+        # options = add_tabindex(options, type)
+
+        label, wrap, hint = options.delete(:label), options.delete(:wrap), options.delete(:hint)
+        name = args.first
+
+        with_callbacks(name) do
+          tag = super(*(args << options), &block)
+          # remember_tabindex(tag, options)
+          tag = hint(tag, hint) if hint
+          tag = labelize(type, tag, name, label) if label || self.options[:labels]
+          tag = wrap(tag) if wrap || self.options[:wrap]
+          tag
+        end
+      end
+    src
+  end
+
+  def field_set(*args, &block)
+    options = args.extract_options!
+    options = add_default_class_names(options, :field_set)
+
+    name    = args.first
+    name ||= :default_fields
+
+    @template.concat with_callbacks(name) {
+      legend = options.delete(:legend) || ''
+      legend = @template.content_tag('legend', legend) unless legend.blank?
+      @template.field_set(@object_name, name, nil, objectify_options(options)) do
+        legend.to_s + (block ? block.call.to_s : '')
+      end
+    }
+  end
+
+  def tabs
+    yield if block_given?
+    assign_ivars!
+    @template.content_tag(:div, :class => 'tabs') {
+      @template.content_tag(:ul) {
+        self.class.tabs.map { |name, block|
+          klass = self.class.tabs.first.first == name ? 'active' : nil
+          @template.content_tag 'li', @template.link_to(I18n.t(name, :scope => :'adva.titles'), "##{name}"), :class => klass
+        }.join.html_safe
+      } +
+      self.class.tabs.map { |name, block|
+        klass = self.class.tabs.first.first == name ? 'tab active' : 'tab'
+        @template.content_tag 'div', block.call(self), :id => "tab_#{name}", :class => klass
+      }.join.html_safe
+    }.html_safe
+  end
+
+  def tab(name, &block)
+    with_callbacks(:"tab_#{name}") {
+      self.class.tab(name, &block)
+    }
+  end
+
+  def buttons(name = :submit_buttons, &block)
+    @template.concat with_callbacks(name) {
+      @template.capture { @template.buttons(&block) }
+    }
+  end
+
+  def render(*args)
+    @template.send(:render, *args)
+  end
+
+  protected
+
+    def labelize(type, tag, method, label = nil)
+      label = case label
+      when String then label
+      when Symbol then I18n.t(label)
+      when TrueClass then
+        scope = [:activerecord, :attributes] + object.class.to_s.underscore.split('/')
+        string = I18n.t(method, :scope => scope)
+        string.is_a?(String) ? string : method.to_s.titleize
+      else nil
+      end
+
+      case type
+      when :check_box, :radio_button
+        tag + self.label(method, label, :class => 'inline light', :for => extract_id(tag), :id => "#{extract_id(tag)}_label")
+      else
+        self.label(method, label) + tag
+      end
+    end
+
+    def wrap(tag)
+      @template.content_tag(:p, tag)
+    end
+
+    def hint(tag, hint)
+      hint = I18n.t(hint) if hint.is_a?(Symbol)
+      tag + @template.content_tag(:span, hint, :class => 'hint', :for => extract_id(tag))
+    end
+
+    def add_default_class_names(options, type)
+      options[:class] = (Array(options[:class]) + self.class.default_class_names(type)).join(' ')
+      options.delete(:class) if options[:class].blank?
+      options
+    end
+
+    def tabindex_increment!
+      @tabindex_count ||= 0
+      @tabindex_count += 1
+    end
+
+    def set_tabindex_position(index = nil, position = nil)
+      position = case position
+      when :after  then tabindexes[index] + 1
+      when :before then tabindexes[index] - 1
+      when :same   then tabindexes[index]
+      else tabindex_increment!
+      end
+      position
+    end
+
+    def add_tabindex(options, type)
+      index = options[:tabindex]
+
+      if index.is_a?(Hash)
+        key = index.keys.first
+        options[:tabindex] = set_tabindex_position(index[key], key)
+      elsif index.is_a?(Symbol)
+        options[:tabindex] = set_tabindex_position(index, :same)
+      elsif index.blank?
+        options[:tabindex] = set_tabindex_position
+      end
+
+      options
+    end
+
+    def tabindexes
+      @tabindexes ||= {}
+    end
+
+    def remember_tabindex(tag, options)
+      id = extract_id(tag)
+      tabindexes[:"#{id}"] = options[:tabindex] unless id.blank?
+    end
+
+    def with_callbacks(method, &block)
+      result = ''
+      result += run_callbacks(:before, method) if method
+      result += yield.to_s
+      result += run_callbacks(:after, method) if method
+      result.html_safe
+    end
+
+    def run_callbacks(stage, method)
+      if callbacks = callbacks_for(stage, method.to_sym)
+        callbacks.inject('') do |result, callback|
+          result + case callback
+            when Proc
+              assign_ivars!
+              instance_eval(&callback)
+            else
+              callback
+          end.to_s
+        end
+      end || ''
+    end
+
+    def callbacks_for(stage, method)
+      object_name = @object_name.try(:to_sym)
+      self.callbacks[stage][object_name] and
+      self.callbacks[stage][object_name][method.to_sym]
+    end
+
+    def assign_ivars!
+      unless @ivars_assigned
+        @template.assigns.each { |key, value| instance_variable_set("@#{key}", value) }
+        vars = @template.controller.instance_variable_names
+        vars.each { |name| instance_variable_set(name, @template.controller.instance_variable_get(name)) }
+        @ivars_assigned = true
+      end
+    end
+
+    # yep, we gotta do this crap because there doesn't seem to be a sane way
+    # to hook into actionview's form_helper methods
+    def extract_id(tag)
+      tag =~ /id="([^"]+)"/
+      $1
+    end
+end
+
+ActionView::Base.default_form_builder = ExtensibleFormBuilder

data/lib/has_options.rb

@@ -0,0 +1,46 @@
+# TODO allow a :type option and typecast the value
+
+module HasOptions
+  class << self
+    def included(base)
+      base.class_eval do
+        extend ClassMethods
+        class_attribute :option_definitions
+        self.option_definitions = {}
+        serialize :options
+      end
+    end
+
+    module ClassMethods
+      def has_option(*names)
+        definition = names.extract_options!
+        names.each do |name|
+          self.option_definitions[name] = definition.reverse_update(:default => nil, :type => :text_field)
+          class_eval <<-src, __FILE__, __LINE__
+            def #{name}
+              #{name}_before_type_cast
+            end
+
+            def #{name}_before_type_cast
+              self.options ||= {}
+              options.key?(:#{name}) ? options[:#{name}] : self.class.option_definition(:#{name}, :default)
+            end
+
+            def #{name}=(value)
+              options_will_change!
+              value = !!value if self.class.option_definition(:#{name}, :type) == :boolean
+              self.options ||= {}
+              options[:#{name}] = value
+            end
+          src
+        end
+      
+        def option_definition(name, key)
+          option_definitions[name][key]
+        rescue
+          superclass.option_definition(name, key) unless self.class.superclass == ActiveRecord::Base
+        end
+      end
+    end
+  end
+end

data/lib/html_diff.rb

@@ -0,0 +1,48 @@
+require 'rubygems'
+begin
+  require 'diff/lcs'
+rescue MissingSourceFile => e
+end
+
+module HtmlDiff
+  class << self
+    def diff(str1, str2)
+      return 'gem diff/lcs is not installed' unless defined?(Diff::LCS)
+      format = Formatter.new
+      Diff::LCS.traverse_sequences(str1, str2, format)
+      format.finish
+    end
+  end
+
+  class Formatter
+    def initialize
+      @html = ''
+    end
+
+    def match(event)
+      start(:match) unless @state == :match
+      @html << event.old_element
+    end
+
+    def discard_a(event)
+      start(:"diff-delete") unless @state == :"diff-delete"
+      @html << event.old_element
+    end
+
+    def discard_b(event)
+      start(:"diff-add") unless @state == :"diff-add"
+      @html << event.new_element
+    end
+
+    def start(state)
+      finish unless @state == state
+      @state = state
+      @html << %Q(<span class="#{state}">)
+    end
+
+    def finish
+      @html << '</span>' if @state
+      @html
+    end
+  end
+end

data/lib/rails_ext.rb

@@ -0,0 +1,15 @@
+require 'rails_ext/action_controller/cacheable_flash'
+require 'rails_ext/action_controller/default_params'
+require 'rails_ext/action_controller/event_helper'
+require 'rails_ext/action_controller/page_caching'
+require 'rails_ext/action_controller/content_for_assignments'
+require 'rails_ext/action_controller/responds_to_parent'
+require 'rails_ext/action_controller/render_with_error_proc'
+require 'rails_ext/action_controller/url_for_returning'
+
+require 'rails_ext/active_record/sti_instantiation'
+require 'rails_ext/active_record/sticky_changes'
+
+require 'rails_ext/railties/plugin_configuration'
+require 'rails_ext/railties/plugin_initializers'
+

data/lib/rails_ext/action_controller/cacheable_flash.rb

@@ -0,0 +1,30 @@
+# http://github.com/pivotal/cacheable-flash
+
+require "json"
+
+module CacheableFlash
+  def self.included(base)
+    base.prepend_around_filter :write_flash_to_cookie
+  end
+
+  def write_flash_to_cookie
+    yield self
+
+    cookie_flash = begin
+      JSON.parse(cookies["flash"] || "{}")
+    rescue JSON::ParserError
+      {}
+    end
+
+    flash.each do |key, value|
+      if cookie_flash[key.to_s].blank?
+        cookie_flash[key.to_s] = value
+      else
+        cookie_flash[key.to_s] << "<br/>#{value}" # TODO should be an array
+      end
+    end
+
+    cookies['flash'] = cookie_flash.to_json
+    flash.clear
+  end
+end

data/lib/rails_ext/action_controller/content_for_assignments.rb

@@ -0,0 +1,105 @@
+# FIXME Suggest a core patch for splitting render like this:
+module ActionView
+  module Renderable #:nodoc:
+    def render(view, local_assigns = {})
+      compile(local_assigns)
+
+      view.with_template self do
+        view.send(:_evaluate_assigns_and_ivars)
+        view.send(:_set_controller_content_type, mime_type) if respond_to?(:mime_type)
+
+        view.send(method_name(local_assigns), local_assigns, &content_assignments_proc(view))
+      end
+    end
+
+    def content_assignments_proc(view)
+      Proc.new do |*names|
+        ivar = :@_proc_for_layout
+        if !view.instance_variable_defined?(:"@content_for_#{names.first}") && view.instance_variable_defined?(ivar) && (proc = view.instance_variable_get(ivar))
+          view.capture(*names, &proc)
+        elsif view.instance_variable_defined?(ivar = :"@content_for_#{names.first || :layout}")
+          view.instance_variable_get(ivar)
+        end
+      end
+    end
+  end
+end
+
+ActionView::Renderable.module_eval do
+  def content_assignments_proc_with_content_for_filters(view)
+    Proc.new do |*names|
+      if view.controller.registered_contents
+        contents = view.controller.registered_contents.select { |id, content| content.target == names.first }
+        contents.each do |id, content|
+          # content_for always appends the new content. we might want to have
+          # more finegrained control over that.
+          view.content_for(names.first, content.render(view))
+        end
+      end
+      content_assignments_proc_without_content_for_filters(view).call(*names)
+    end
+  end
+  alias_method_chain :content_assignments_proc, :content_for_filters
+end
+
+
+ActionController::Base.class_eval do
+  class_attribute :registered_contents
+  self.registered_contents = ActiveSupport::OrderedHash.new
+
+  class << self
+    def content_for(target, id, *args, &block)
+      self.registered_contents[id] = RegisteredContent.new(id, target, *args, &block)
+    end
+  end
+end
+
+class RegisteredContent
+  attr_reader :id, :target, :content, :options
+
+  def initialize(id, target, *args, &block)
+    @id = id
+    @target = target
+    @options = args.extract_options!
+    @content = block_given? ? block : args.first
+    
+    normalize_options!
+  end
+
+  def render(view)
+    view.content_for(target, eval_content(view)) if applies?(view)
+  end
+
+  def applies?(view)
+    included = options[:only] ? condition_applies?(:only, view) : true
+    excluded = options[:except] ? condition_applies?(:except, view) : false
+    included and not excluded
+  end
+
+  private
+
+    def eval_content(view)
+      content.is_a?(Proc) ? view.instance_eval(&content) : content
+    end
+
+    def condition_applies?(type, view)
+      proc = lambda do |condition, value|
+        condition = options[type][condition]
+        condition.is_a?(Proc) ? condition.call(view.controller) : value.in?(condition)
+      end
+      proc.call(:controller, view.controller.controller_path.to_sym) or
+      proc.call(:action, view.controller.action_name.to_sym) or
+      proc.call(:format, view.template_format.to_sym)
+    end
+    
+    def normalize_options!
+      @options.each do |type, condition|
+        condition.each do |key, value|
+          case value
+          when Array;  @options[type][key] = value.map(&:to_sym)
+          when String; @options[type][key] = value.to_sym
+          end
+        end
+      end
+    end
+end