dead_simple_cms 0.9.0

data/lib/dead_simple_cms/rails/action_controller/extensions.rb

@@ -0,0 +1,24 @@
+module DeadSimpleCMS
+  module Rails
+    module ActionController
+      module Extensions
+
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def cms_cache_sweeper(options={})
+            cache_sweeper ActionView::FragmentSweeper, options
+          end
+        end
+
+        private
+
+        # Private: Update the values for the cms with the arguments from the params hash.
+        def update_sections_from_params
+          DeadSimpleCMS::Section.update_from_params(params)
+        end
+
+      end
+    end
+  end
+end

data/lib/dead_simple_cms/rails/action_controller/fragment_sweeper.rb

@@ -0,0 +1,19 @@
+module DeadSimpleCMS
+  module Rails
+    module ActionView
+      # Public: Class to handle expiring the fragment caches from the cms.
+      # ::ActionController::Caching::Sweeper inherits from ActiveRecord::Observer even though we aren't observing an
+      # ActiveRecord class. This still works though because the interface (update callback) is the same on the Section.
+      class FragmentSweeper < ::ActionController::Caching::Sweeper
+
+        observe DeadSimpleCMS::Section
+
+        # Make sure we expire any fragments that we are using on those pages.
+        def after_save(section)
+          section.fragments.each { |f| expire_fragment(f) }
+        end
+
+      end
+    end
+  end
+end

data/lib/dead_simple_cms/rails/action_view/extensions.rb

@@ -0,0 +1,14 @@
+module DeadSimpleCMS
+  module Rails
+    module ActionView
+      module Extensions
+
+        def dead_simple_cms
+          @dead_simple_cms ||= Presenter.new(self)
+        end
+
+      end
+    end
+  end
+end
+

data/lib/dead_simple_cms/rails/action_view/form_builders/default.rb

@@ -0,0 +1,16 @@
+module DeadSimpleCMS
+  module Rails
+    module ActionView
+      module FormBuilders
+        # Public: Interface for buildering form builders to work with this library.
+        class Default < ::ActionView::Helpers::FormBuilder
+
+          include Interface
+
+          self.actions_options  = {:class => "form-actions"}
+
+        end
+      end
+    end
+  end
+end

data/lib/dead_simple_cms/rails/action_view/form_builders/interface.rb

@@ -0,0 +1,72 @@
+module DeadSimpleCMS
+  module Rails
+    module ActionView
+      module FormBuilders
+        # Public: Interface used for a form builder to work with dead simple cms.
+        module Interface
+
+          def self.included(base)
+            base.class_eval do
+              class_attribute :form_for_method
+              self.form_for_method = :form_for
+
+              class_inheritable_hash :form_for_options
+              self.form_for_options = {}
+
+              [:update, :actions, :preview, :attribute].each do |name|
+                option_name = "#{name}_options"
+                class_inheritable_hash option_name, :instance_writer => false
+                self.send("#{option_name}=", {})
+              end
+            end
+            super
+          end
+
+          def attribute(attribute)
+            label(attribute.identifier, attribute.label) +
+              case attribute.input_type
+              when :string then text_field(attribute.identifier)
+              when :text   then text_area(attribute.identifier)
+              when :file   then file_field(attribute.identifier)
+              when :select then select(attribute.identifier, attribute.collection)
+              when :radio  then radio_buttons(attribute.identifier, attribute.collection)
+              else              raise("Unknown type: #{attribute.identifier}")
+              end
+          end
+
+          def actions(&block)
+            @template.content_tag(:div, actions_options, &block)
+          end
+
+          def update
+            submit("Update", update_options)
+          end
+
+          def radio_buttons(identifier, collection)
+            collection.map { |v| radio_button(identifier, v) }.join.html_safe
+          end
+
+          def preview(section)
+            @template.link_to("Preview", section.path, preview_options) if section.path
+          end
+
+          def fields_for_group(section_or_group, options={})
+            section_or_group.groups.values.map do |group|
+              next if group.attributes.empty? && group.groups.empty?
+              fields_for(group.identifier, options) do |builder|
+                @template.content_tag(:fieldset) do
+                  # Following fieldset/legend convention: https://github.com/twitter/bootstrap/issues/1214
+                  legend        = @template.content_tag(:legend, group.label) unless group.root? # don't show the group name if it's the root group.
+                  attributes    = group.attributes.values.map { |attribute| builder.attribute(attribute) }.join.html_safe
+                  nested_groups = builder.fields_for_group(group, options)
+                  [legend, attributes, nested_groups].join.html_safe
+                end
+              end
+            end.join.html_safe
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/dead_simple_cms/rails/action_view/form_builders/simple_form.rb

@@ -0,0 +1,43 @@
+module DeadSimpleCMS
+  module Rails
+    module ActionView
+      module FormBuilders
+        # Public: SimpleForm builder for use with the Dead Simple CMS
+        # The class names embed into this builder are for twitter bootstrap.
+        class SimpleForm < ::SimpleForm::FormBuilder
+
+          include Interface
+
+          # Public: Translation of the Attribute::Type::Base#input_type to :as option for SimpleForm.
+          AS_LOOKUP = Hash.new { |h, k| k }.update(:radio => :radio_buttons)
+
+          self.preview_options = {:target => "_blank"}
+
+          def self.form_for_method
+            :simple_form_for
+          end
+
+          def attribute(attribute)
+            as = AS_LOOKUP[attribute.input_type]
+            hint = attribute.hint.to_s.dup
+            hint << %{ <a href="#{attribute.value}" target="_blank">preview</a>} if attribute.is_a?(Attribute::Type::Image)
+            options = {:required => attribute.required, :hint => hint, :as => as, :label => attribute.label}
+            if attribute.is_a?(Attribute::Type::CollectionSupport) && (collection = attribute.collection)
+              options[:collection] = collection
+              options[:as] = as
+              options[:include_blank] = false if as==:select
+            end
+
+            input(attribute.identifier, attribute_options.update(options))
+          end
+
+          def update
+            button(:submit, "Update", update_options)
+          end
+
+        end
+      end
+    end
+  end
+end
+

data/lib/dead_simple_cms/rails/action_view/form_builders/simple_form_with_bootstrap.rb

@@ -0,0 +1,19 @@
+module DeadSimpleCMS
+  module Rails
+    module ActionView
+      module FormBuilders
+        class SimpleFormWithBootstrap < SimpleForm
+
+          self.form_for_options = {:wrapper => :bootstrap, :html => { class: "form-horizontal well" }}
+          self.update_options   = {:class => "btn-primary"}
+          self.actions_options  = {:class => "form-actions btn-group"}
+          self.preview_options  = {:class => "btn"}
+
+        end
+      end
+    end
+  end
+end
+
+
+

data/lib/dead_simple_cms/rails/action_view/presenter.rb

@@ -0,0 +1,63 @@
+require 'delegate'
+module DeadSimpleCMS
+  module Rails
+    module ActionView
+      class Presenter < SimpleDelegator
+
+        class_attribute :form_builder
+
+        def initialize(template)
+          __setobj__(template)
+        end
+
+        # Renders a group into the view.
+        def group(group, *args, &block)
+          group.render(__getobj__, *args, &block) # pass through the action_view template.
+        end
+
+        def sections
+          DeadSimpleCMS.sections.values.map { |section| section(section, options) }.join.html_safe
+        end
+
+        # Public: Render the dead simple cms with tabs
+        # This is *coupled* with twitter bootstrap. If you are running it, this will work great, otherwise this will be sad.
+        # http://twitter.github.com/bootstrap/javascript.html#tabs
+        def with_bootstrap_tabs(options={})
+          js = javascript_include_tag(options.delete(:bootstrap_tab_js) || "bootstrap-2.0.3/bootstrap-tab.js")
+          js << javascript_tag(<<-JAVASCRIPT)
+          $(document).ready(function() {
+            var $tabs = $('#section-tabs a') ;
+            $tabs.click(function (e) { e.preventDefault(); $(this).tab('show'); });
+            $("#" + (window.location.hash.replace("#", "") || "#{DeadSimpleCMS.sections.identifiers[0]}") + "-tab").tab('show');
+          })
+          JAVASCRIPT
+          lis = DeadSimpleCMS.sections.values.map do |section|
+            content_tag(:li, link_to(section.label, "##{section.identifier.to_s.csserize}", :id => "#{section.identifier.to_s.csserize}-tab"))
+          end.join.html_safe
+          tabs = content_tag(:ul, lis, :class => "nav nav-tabs", :id => "section-tabs")
+          sections = content_tag(:div, :class => "tab-content") do
+            DeadSimpleCMS.sections.values.map do |section|
+              content_tag(:div, section(section), :class => "tab-pane", :id => "#{section.identifier.to_s.csserize}")
+            end.join.html_safe
+          end
+          js + tabs + sections
+        end
+
+        def section(section, options={})
+          content_tag(:h2, section.label) + form(section, options)
+        end
+
+        def form(section, options={})
+          options.reverse_merge!(:builder => form_builder, :url => {:action => :edit})
+          options.reverse_merge!(options[:builder].form_for_options)
+
+          (options[:html] ||= {}).update(:multipart => true) if section.attributes.values.any? { |a| a.input_type == :file }
+
+          send(options[:builder].form_for_method, section, {:as => section.identifier}.update(options)) do |form|
+            form.fields_for_group(section, options) + form.actions { form.update + form.preview(section) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dead_simple_cms/section.rb

@@ -0,0 +1,103 @@
+module DeadSimpleCMS
+# Public: Represents a section in the website a user wants to be able to modify the data in an immediate-simple way.
+  class Section < Group
+
+    include Util::Identifier
+
+    include ActiveModel::Observing
+
+    extend ActiveModel::Callbacks
+    define_model_callbacks :save
+
+    self.dictionary_identifier_method = :section_identifier
+
+    # Public: a Symbol representing the default storage class
+    class_attribute :storage_class, :instance_writer => false
+
+    attr_reader :path, :root_group
+
+    before_save :upload_file_attributes
+
+    def initialize(identifier, options={}, &block)
+      super(identifier, options)
+      @path       = options[:path]
+      @root_group = Group.root # The root group for the section.
+      @fragments  = Array.wrap(options[:fragments])
+      add_group(@root_group)
+
+      build(&block) if block_given?
+    end
+
+    # Public: Update the sections with the params and return the updated sections.
+    def self.update_from_params(params)
+      params.map do |section_identifier, attributes|
+        DeadSimpleCMS.sections[section_identifier].tap do |section|
+          section.update_attributes(attributes) if section
+        end
+      end.compact
+    end
+
+    def add_attribute(attribute)
+      super
+      attribute.section = self
+    end
+
+    def fragments
+      @fragments.map { |f| f.is_a?(Proc) ? f.call(self) : f }
+    end
+
+    def storage
+      @storage ||= storage_class.new(self)
+    end
+
+    # Public: Update the section values.
+    #
+    # Examples
+    #
+    #   update_attributes("left_attributes" => {"header" => "Hi There", "paragraph" => "how's it going"}})
+    #   update_attributes("left_header" => "Hi There", "left_paragraph" => "how's it going"})
+    #
+    # Both of these work assuming the user defined a group called "left" and has attributes in it called "header" and
+    # "paragraph". The "left_attributes=" method plays nicely with nested fields_for which the form builder dependes on.
+    def update_attributes(attributes)
+      super
+      save!
+    end
+
+    def save!
+      _run_save_callbacks { storage.write }
+    end
+
+    def build(&block)
+      Builder.new(self, &block)
+    end
+
+    def to_param
+      identifier.to_s
+    end
+
+    def cache_key
+      "cms/#{identifier}"
+    end
+
+    private
+
+    # Tried to make an observer class for the uploading, but had some trouble getting it working. - Aryk
+    def upload_file_attributes
+      attributes.values.each { |a| a.upload! if a.is_a?(Attribute::Type::File) }
+    end
+
+    def attribute_accessor(attribute)
+      super
+      identifier = attribute.send(dictionary_identifier_method)
+      # If the attribute is in the root group, then create an alias from "root_foo" to simply "foo"
+      if attribute.root_group?
+        instance_eval <<-RUBY, __FILE__, __LINE__ + 1
+          alias #{attribute.identifier} #{identifier}
+          alias #{attribute.identifier}= #{identifier}=
+        RUBY
+      end
+    end
+
+  end
+end

data/lib/dead_simple_cms/section/builder.rb

@@ -0,0 +1,73 @@
+module DeadSimpleCMS
+  class Section
+    # Public: A Builder class which provides a nice DSL to describe different sections of the site that a user wants to modify
+    # through a CMS.
+    class Builder
+
+      attr_accessor :group_hierarchy
+      attr_reader :section
+
+      def self.define_attribute_builder_method(klass)
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{klass.builder_method_name}(identifier, options={})
+            group_hierarchy = self.group_hierarchy.presence || [section.root_group] # fallback on the root group
+            attribute = #{klass}.new(identifier, options.merge(:group_hierarchy => group_hierarchy, :section => section))
+            group_hierarchy.last.add_attribute(attribute)
+            section.add_attribute(attribute)
+          end
+        RUBY
+      end
+
+      def initialize(section, &block)
+        @section = section
+        @group_hierarchy = []
+        instance_eval(&block)
+      end
+
+      def display(*args, &block)
+        (current_group || section).display(*args, &block)
+      end
+
+      def group(*args, &block)
+        options = args.extract_options!
+        attribute_options_by_identifier = options.delete(:attribute_options) || {}
+
+        identifier = args.first
+        # If no identifier provided, first key, value pair of the hash is the identifier => group_configuration.
+        identifier, group_configuration = options.shift unless identifier
+        unless group_configuration.is_a?(DeadSimpleCMS::Group::Configuration)
+          group_configuration = DeadSimpleCMS.group_configurations[group_configuration]
+        end
+        options.update(group_configuration.options) if group_configuration
+        group = Group.new(identifier, options)
+
+        nest_group(group) do
+          if group_configuration
+            display(group_configuration.presenter_class, &group_configuration.render_proc)
+            group_configuration.attribute_arguments.each do |attribute_identifier, (attribute_type, attribute_options)|
+              attribute_options = attribute_options.merge(attribute_options_by_identifier[attribute_identifier] || {})
+              send(attribute_type, attribute_identifier, attribute_options)
+            end
+          end
+          instance_eval(&block) if block_given?
+        end
+      end
+
+      private
+
+      def current_group
+        group_hierarchy.last
+      end
+
+      def nest_group(group)
+        tmp = group_hierarchy
+        (group_hierarchy.last || section).add_group(group) # chain it with the last group or section if its top-level.
+        self.group_hierarchy += [group]
+        yield
+      ensure
+        self.group_hierarchy = tmp
+      end
+
+    end # Builder
+  end
+end