browsercms-artirix 4.0.0.rc1.art4

data/lib/cms/behaviors/rendering.rb

@@ -0,0 +1,195 @@
+module Cms
+  module Behaviors
+    # The Rendering Behavior allows a model to be rendered within a view.
+    # The key methods are the instance methods perform_render, render and 
+    # inline_options.  From within a view or a helper, you can render a
+    # renderable object by calling the perform_render and passing the controller
+    # object to it.
+    #
+    # When perform_render is called, it will first call the render instance method
+    # of the renderable object.  This is very similar to a controller action.
+    # The purpose of this method is to setup instance varaibles to be used by the
+    # renderable's view.
+    #
+    # After the render method is called, it checks to see if there is a inline_options
+    # instance method on the renderable object.  If so, it calls this and it expects
+    # this to return a Hash that will be passed to render.  This expects there to be
+    # an inline option, so this is the way to do inline rendering.
+    #
+    # Assuming there is no inline_options method, it will look for a template in the 
+    # view path at cms/pluralized_class_name/render.  So if the Renderable class is
+    # Article, the template should be at cms/articles/render.  It uses the same
+    # format and template engine options as regular views, to the file name should
+    # be render.html.erb.
+    #
+    module Rendering
+      def self.included(model)
+        model.extend(MacroMethods)
+      end
+
+      module MacroMethods
+        def renderable?
+          false
+        end
+
+        def is_renderable(options={})
+
+          @instance_variable_name_for_view = options[:instance_variable_name_for_view]
+
+          extend ClassMethods
+          include InstanceMethods
+
+          # I'm not pleased with the need to include all of the these rails helpers onto every 'renderable' content item
+          # It's likely to lead to unfortunate side effects.
+          # Need to determine how this can be simplified.
+
+          # Required to make the calls to add Rails Core controllers work
+          include ActiveSupport::Configurable
+
+          # Include all the core rails helpers
+          include ActionController::Helpers
+          include ActionController::RequestForgeryProtection
+
+          helper ApplicationHelper
+
+          attr_accessor :controller
+          delegate :params, :session, :request, :flash, :to => :controller
+
+        end
+      end
+    end
+    module ClassMethods
+      def renderable?
+        true
+      end
+
+      # This will be the used as the name of instance variable 
+      # that will be available in the view.  The default value is "@renderable"
+      def instance_variable_name_for_view
+        @instance_variable_name_for_view ||= "@renderable"
+      end
+
+      def helper_path
+        "app/helpers/#{name.underscore}_helper.rb"
+      end
+
+      def helper_class
+        "Cms::#{name}Helper".constantize
+      end
+
+      # This is where the path to the template. The default is based on the class
+      # of the renderable, so if you have an Article that is renderable, 
+      # the template will be "articles/render"
+      def template_path
+        "#{name.underscore.pluralize}/render"
+      end
+
+      # Instance variables that will not be copied from the renderable to the view
+      def ivars_to_ignore
+        ['@controller', '@_already_rendered']
+      end
+
+    end
+    module InstanceMethods
+
+      # Returns the Mercury editor type for a given attribute
+      # @param [Symbol] method (i.e. :name, :content, etc)
+      # @return [Hash]
+      def editor_info(method)
+        column = self.class.columns_hash[method.to_s]
+        if column.type == :text
+          {:element => 'div', :region => 'full'}
+        else
+          {:element => 'span', :region => 'simple'}
+        end
+      end
+
+      def prepare_to_render(controller)
+        # Give this renderable a reference to the controller
+        @controller = controller
+
+        copy_instance_variables_from_controller!
+
+        # This gives the view a reference to this object
+        instance_variable_set(self.class.instance_variable_name_for_view, self)
+
+        # This is like a controller action
+        # We will call it if you have defined a render method
+        # but if you haven't we won't
+        render if should_render_self?
+      end
+
+      def perform_render(controller)
+        return "Exception: #{@render_exception}" if @render_exception
+
+
+        unless @controller
+          # We haven't prepared to render. This should only happen when logged in, as we don't want
+          # errors to bubble up and prevent the page being edited in that case.
+          prepare_to_render(controller)
+        end
+
+        if self.respond_to?(:deleted) && self.deleted
+          logger.error "Attempting to render deleted object: #{self.inspect}"
+          msg = (edit_mode? ? %Q[<div class="error">This #{self.class.name} has been deleted.  Please remove this container from the page</div>] : '')
+          return msg
+        end
+
+        # Create, Instantiate and Initialize the view
+        action_view = Cms::ViewContext.new(@controller, assigns_for_view)
+
+        add_content_helpers_if_defined(action_view)
+
+        # Determine if this content should render from a file system template or inline (i.e. database based template)
+        if respond_to?(:inline_options) && self.inline_options && self.inline_options.has_key?(:inline)
+          options = self.inline_options
+          locals = {}
+          action_view.render(options, locals)
+        else
+          action_view.render(:file => self.class.template_path)
+        end
+      end
+
+      def render_exception=(exception)
+        @render_exception = exception
+      end
+
+      # Determines if a block should have its 'render' method called when it's rendered within a page.
+      def should_render_self?
+        # Reason to exist: This was added to work around the fact that Rails 3 AbstractController::Helpers defines its own
+        # render method, which was conflicted with block's render methods.
+        public_methods(false).include?(:render)
+      end
+
+      protected
+
+      # Add the helper class for this particular object, if its defined
+      # This is mostly for portlets, and should not fail if no helper is defined.
+      def add_content_helpers_if_defined(action_view)
+        begin
+          helper_module = self.class.helper_class
+          action_view.extend(helper_module)
+        rescue NameError => error
+          logger.debug "No helper class named '#{error.missing_name}' was found. This isn't necessarily an error as '#{self.class}' doesn't NEED a separate helper.'"
+        end
+      end
+
+      def copy_instance_variables_from_controller!
+        if @controller.respond_to?(:instance_variables_for_rendering)
+          @controller.instance_variables_for_rendering.each do |iv|
+            #logger.info "Copying #{iv} => #{@controller.instance_variable_get(iv).inspect}"
+            instance_variable_set(iv, @controller.instance_variable_get(iv))
+          end
+        end
+      end
+
+      def assigns_for_view
+        (instance_variables - self.class.ivars_to_ignore).inject({}) do |h, k|
+          h[k[1..-1]] = instance_variable_get(k)
+          h
+        end
+      end
+
+    end
+  end
+end

data/lib/cms/behaviors/searching.rb

@@ -0,0 +1,45 @@
+module Cms
+  module Behaviors
+    module Searching
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+      module MacroMethods
+        def searchable?
+          !!@is_searchable
+        end
+        def is_searchable(options={})
+          @is_searchable = true
+          @searchable_columns = options[:searchable_columns] ? options[:searchable_columns].map(&:to_sym) : [:name]
+          extend ClassMethods
+        
+          #This is in a method to allow classes to override it
+          scope :search, lambda{|search_params|
+            term = search_params.is_a?(Hash) ? search_params[:term] : search_params
+            conditions = []
+            unless term.blank?
+              searchable_columns.each do |c|
+                if conditions.empty?
+                  conditions = ["#{table_name}.#{c} like ?"]
+                else
+                  conditions.first << "or #{table_name}.#{c} like ?"
+                end
+                conditions << "%#{term}%"
+              end
+              #conditions[0] = "(#{conditions[0]})"
+            end
+            where(conditions)
+            #scope = {}
+            #scope[:conditions] = conditions if conditions
+            #scope
+          }
+        end
+      end
+      module ClassMethods
+        def searchable_columns
+          @searchable_columns
+        end
+      end
+    end
+  end
+end

data/lib/cms/behaviors/soft_deleting.rb

@@ -0,0 +1,103 @@
+module Cms
+  module Behaviors
+    module SoftDeleting
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+
+      module MacroMethods
+        def uses_soft_delete?
+          !!@uses_soft_delete
+        end
+
+        def handle_missing_table_error_during_startup(message, e)
+          Rails.logger.debug "#{message}: #{e.inspect}"
+        end
+
+        def uses_soft_delete(options={})
+          @uses_soft_delete = true
+
+          scope :not_deleted, -> {where (["#{table_name}.deleted = ?", false])}
+          class << self
+            alias_method :delete_all!, :delete_all
+          end
+
+          extend ClassMethods
+          include InstanceMethods
+         #attr_accessible :deleted
+
+          # By default, all queries for blocks should filter out deleted rows.
+          begin
+            default_scope {where(:deleted => false)}
+          # This may fail during gem loading, if no DB or the table does not exist. Log it and move on.
+          rescue StandardError => e
+            handle_missing_table_error_during_startup("Can't set a default_scope for soft_deleting", e)
+          end
+        end
+      end
+
+      # TODO: Refactor this class to remove need for overriding count, delete_all, etc.
+      # Should not be necessary due to introduction of 'default_scope'.
+      #
+      # 2. TODO: Allow a record to define its own default_scope that doesn't 'override' this one.
+      # See http://github.com/fernandoluizao/acts_as_active for an implementation of this
+      module ClassMethods
+
+        # Returns a content block even if it is marked as deleted.
+        # @param [Hash] options Hash suitable to be passed to '#where'
+        def find_with_deleted(options)
+          self.unscoped.where(options).first
+        end
+
+        # Returns a count of all records of this type, including those marked as deleted.
+        #
+        # Behaves like ActiveRecord.count is originally implemented.
+        #
+        # @param args Same params as ActiveRecord.count
+        def count_with_deleted(* args)
+          self.unscoped.count(* args)
+        end
+
+        def delete_all(conditions=nil)
+          where(conditions).update_all(["deleted = ?", true])
+        end
+
+        def exists?(id_or_conditions)
+          query = if id_or_conditions.is_a?(Hash) || id_or_conditions.is_a?(Array)
+            where id_or_conditions
+          else
+            where(:id => id_or_conditions)
+          end
+          query.count > 0
+        end
+      end
+      module InstanceMethods
+
+        # Destroying a soft deletable model should mark the record as deleted, and not actually remove it from the database.
+        #
+        # Overrides original destroy method
+        def destroy
+          run_callbacks :destroy do
+            if self.class.publishable?
+              update_attributes(:deleted => true, :publish_on_save => true)
+            else
+              update_attributes(:deleted => true)
+            end
+          end
+        end
+
+        def mark_as_deleted!
+          destroy
+        end
+
+        def destroy!
+          transaction { super.destroy }
+        end
+
+        def destroyed?
+          @destroyed
+        end
+      end
+    end
+  end
+end

data/lib/cms/behaviors/taggable.rb

@@ -0,0 +1,66 @@
+module Cms
+  module Behaviors
+    module Taggable
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+
+      module MacroMethods
+        def taggable?
+          !!@is_taggable
+        end
+
+        def is_taggable(options={})
+          @is_taggable = true
+          @tag_separator = options[:separator] || " "
+
+          has_many :taggings, :as => :taggable, :class_name => 'Cms::Tagging'
+          has_many :tags, -> { order("#{Cms::Tag.table_name}.name") }, :class_name => 'Cms::Tag', :through => :taggings
+
+
+          after_save :save_tags
+
+          extend ClassMethods
+          include InstanceMethods
+
+        end
+      end
+      module ClassMethods
+        def tagged_with(t)
+          where(["#{Cms::Tag.table_name}.name = ?", t]).includes(:taggings => :tag).references(:tags)
+        end
+
+        def tag_cloud
+          Cms::Tagging.cloud(base_class.name)
+        end
+
+        def tag_separator
+          @tag_separator
+        end
+      end
+      module InstanceMethods
+        def tag_list
+          @tag_list ||= tags.reload.map(&:name).join(self.class.tag_separator)
+        end
+
+        def tag_list=(tag_names)
+          changed_attributes["tag_list"] = tag_list unless @tag_list == tag_names
+          @tag_list = tag_names
+        end
+
+        def save_tags
+          tag_list_tags = tag_list.to_s.split(self.class.tag_separator).map { |t| Cms::Tag.find_or_create_by(name: t.strip) }
+          taggings.each do |tg|
+            if tag_list_tags.include?(tg.tag)
+              tag_list_tags.delete(tg.tag)
+            else
+              tg.destroy
+            end
+          end
+          tag_list_tags.each { |t| taggings.create(:tag => t, :taggable => self) }
+          self.tag_list = nil
+        end
+      end
+    end
+  end
+end

data/lib/cms/behaviors/userstamping.rb

@@ -0,0 +1,42 @@
+module Cms
+  module Behaviors
+    module Userstamping
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+
+      module MacroMethods
+        def userstamped?
+          !!@is_userstamped
+        end
+
+        def is_userstamped(_options={})
+          @is_userstamped = true
+          extend ClassMethods
+          include InstanceMethods
+        
+          belongs_to :created_by, class_name: Cms.user_class_name
+          belongs_to :updated_by, class_name: Cms.user_class_name
+        
+          before_save :set_userstamps
+
+          scope :created_by, lambda { |user| { conditions: { created_by: user } } }
+          scope :updated_by, lambda { |user| { conditions: { updated_by: user } } }
+        end
+      end
+
+      module ClassMethods
+      end
+
+      module InstanceMethods
+        def set_userstamps
+          current_user = Cms::User.current ? Cms::User.current : nil
+          if new_record?
+            self.created_by = current_user
+          end
+          self.updated_by = current_user
+        end
+      end
+    end
+  end
+end