browsercms-artirix 4.0.0.rc1.art4

data/doc/test_procedure.txt

@@ -0,0 +1,141 @@
+Here is a series of tasks to test the basic interface functionality of the CMS.
+
+Note: It is best to build the cms gem and install it, then test the functionality in a rails app that has been configured to use the new gem.
+
+Sitemap:
+  Add Section
+  Add Page
+  Test Edit Page Link
+  Add Link
+  Edit Section Properties
+  Edit Page Properties
+  Edit Link Properties
+  Publish Link
+  Move Link
+  Move Page
+  Move Section
+  Delete Link
+  Delete Page
+  Delete Section
+
+Content Library:
+  Add Image
+  Edit Image Metadata
+  Edit Image File
+  Revert Image to different metadata
+  Revert Image to different file
+  Search Image
+  Add Text
+  Edit Text
+  Add Link to Text
+  Add Image to Text
+  Revert Text
+  Bulk add Text
+  Paginated Search links
+  Delete Text
+  Delete Image
+  Add Portlet
+  Edit Portlet
+  Search Portlet
+  Delete Portlet
+  Add File
+  Edit File Metadata
+  Edit File File
+  Revert File to metadata
+  Revert File to different file
+  Search File
+  Delete File
+  Add Category Type
+  Edit Category Type
+  Search Category Type
+  Add Category
+  Edit Category
+  Search Category
+  Delete Category
+  Delete Category Type
+  Add Tag
+  Edit Tag
+  Search Tag
+  Delete Tag
+
+Administration:
+  Add Public User Group
+  Add Admin Group
+  Edit Public User Group
+  Edit Admin Group
+  Add User
+  Edit User
+  Search User
+  Disable User
+  Search inactive User
+  Enable User
+  Login as User
+  Change User Password
+  Login as User
+  Add Page Partial
+  Edit Page Partial
+  Add Page Partial
+  Delete Page Partial
+  Add Page Template
+  Edit Page Template
+  Add Page Template
+  Delete Page Template
+  Add Page Route
+  Test Page Route
+  Edit Page Route
+  Test old Page Route
+  Test new Page Route
+  Delete Page Route
+  Test old Page Route
+  Test new Page Route
+  Test Rails Route
+  Clear Page Cache
+  Add Redirect
+  Test Redirect
+  Edit Redirect
+  Test old Redirect
+  Test new Redirect
+  Delete Redirect
+  Test old Redirect
+  Test new Redirect
+
+Page:
+  Toggle Visual Editor On
+  Toggle Visual Editor Off
+  Toggle Visual Editor On
+  Add New Text to Container
+  Add Existing Text to Container
+  Move Text Up
+  Move Text Down
+  Edit Text
+  Remove Text
+  Publish
+  List Versions
+  Revert
+  Assign
+  Complete Task
+  Edit Properties
+  Add New Portlet to Container
+  Add Existing Portlet to Container
+  Move Portlet Up
+  Move Portlet Down
+  Edit Portlet
+  Remove Portlet
+  Add New File to Container
+  Add Existing File to Container
+  Move File Up
+  Move File Down
+  Edit File
+  Remove File
+  Add New Image to Container
+  Add Existing Image to Container
+  Move Image Up
+  Move Image Down
+  Edit Image
+  Remove Image
+  Delete Page
+
+Dashboard:
+  Publish page
+  Publish pages
+  Remove task

data/lib/acts_as_list.rb

@@ -0,0 +1,257 @@
+module ActsAsList
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  # This +acts_as+ extension provides the capabilities for sorting and reordering a number of objects in a list.
+  # The class that has this specified needs to have a +position+ column defined as an integer on
+  # the mapped database table.
+  #
+  # To Do list example:
+  #
+  #   class TodoList < ActiveRecord::Base
+  #     has_many :todo_items, :order => "position"
+  #   end
+  #
+  #   class TodoItem < ActiveRecord::Base
+  #     belongs_to :todo_list
+  #     acts_as_list :scope => :todo_list
+  #   end
+  #
+  #   todo_list.first.move_to_bottom
+  #   todo_list.last.move_higher
+  module ClassMethods
+    # Configuration options are:
+    #
+    # * +column+ - specifies the column name to use for keeping the position integer (default: +position+)
+    # * +scope+ - restricts what is to be considered a list. Given a symbol, it'll attach <tt>_id</tt> 
+    #   (if it hasn't already been added) and use that as the foreign key restriction. It's also possible 
+    #   to give it an entire string that is interpolated if you need a tighter scope than just a foreign key.
+    #   Example: <tt>acts_as_list :scope => 'todo_list_id = #{todo_list_id} AND completed = 0'</tt>
+    def acts_as_list(options = {})
+      configuration = {:column => "position", :scope => "1 = 1"}
+      configuration.update(options) if options.is_a?(Hash)
+
+      configuration[:scope] = "#{configuration[:scope]}_id".intern if configuration[:scope].is_a?(Symbol) && configuration[:scope].to_s !~ /_id$/
+
+      if configuration[:scope].is_a?(Symbol)
+        scope_condition_method = %(
+          def scope_condition
+            if #{configuration[:scope].to_s}.nil?
+              "#{configuration[:scope].to_s} IS NULL"
+            else
+              "#{configuration[:scope].to_s} = \#{#{configuration[:scope].to_s}}"
+            end
+          end
+        )
+      else
+        scope_condition_method = "def scope_condition() \"#{configuration[:scope]}\" end"
+      end
+
+      class_eval <<-EOV
+        include ActsAsList::InstanceMethods
+
+        def acts_as_list_class
+          ::#{self.name}
+        end
+
+        def position_column
+          '#{configuration[:column]}'
+        end
+
+        #{scope_condition_method}
+
+        before_destroy :remove_from_list_without_saving
+        before_create  :add_to_list_bottom
+      EOV
+    end
+  end
+
+  # All the methods available to a record that has had <tt>acts_as_list</tt> specified. Each method works
+  # by assuming the object to be the item in the list, so <tt>chapter.move_lower</tt> would move that chapter
+  # lower in the list of all chapters. Likewise, <tt>chapter.first?</tt> would return +true+ if that chapter is
+  # the first in the list of all chapters.
+  module InstanceMethods
+    # Insert the item at the given position (defaults to the top position of 1).
+    def insert_at(position = 1)
+      insert_at_position(position)
+    end
+
+    # Swap positions with the next lower item, if one exists.
+    def move_lower
+      lower = lower_item
+      return unless lower
+      acts_as_list_class.transaction do
+        self.update_attribute(position_column, lower.send(position_column))
+        lower.decrement_position
+      end
+    end
+
+    # Swap positions with the next higher item, if one exists.
+    def move_higher
+      higher = higher_item
+      return unless higher
+      acts_as_list_class.transaction do
+        self.update_attribute(position_column, higher.send(position_column))
+        higher.increment_position
+      end
+    end
+
+    # Move to the bottom of the list. If the item is already in the list, the items below it have their
+    # position adjusted accordingly.
+    def move_to_bottom
+      return unless in_list?
+      acts_as_list_class.transaction do
+        decrement_positions_on_lower_items
+        assume_bottom_position
+      end
+    end
+
+    # Move to the top of the list. If the item is already in the list, the items above it have their
+    # position adjusted accordingly.
+    def move_to_top
+      return unless in_list?
+      acts_as_list_class.transaction do
+        increment_positions_on_higher_items
+        assume_top_position
+      end
+    end
+
+    # Removes the item from the list.
+    def remove_from_list(save = true)
+      if in_list?
+        decrement_positions_on_lower_items
+        update_attribute(position_column, nil) if save
+      end
+    end
+
+    def remove_from_list_without_saving
+      self.remove_from_list(false)
+    end
+
+    # Increase the position of this item without adjusting the rest of the list.
+    def increment_position
+      return unless in_list?
+      update_attribute position_column, self.send(position_column).to_i + 1
+    end
+
+    # Decrease the position of this item without adjusting the rest of the list.
+    def decrement_position
+      return unless in_list?
+      update_attribute position_column, self.send(position_column).to_i - 1
+    end
+
+    # Return +true+ if this object is the first in the list.
+    def first?
+      return false unless in_list?
+      self.send(position_column) == 1
+    end
+
+    # Return +true+ if this object is the last in the list.
+    def last?
+      return false unless in_list?
+      self.send(position_column) == bottom_position_in_list
+    end
+
+    # Return the next higher item in the list.
+    def higher_item
+      return nil unless in_list?
+      acts_as_list_class
+        .where("#{scope_condition} AND #{position_column} < #{send(position_column).to_s}")
+        .order("#{position_column} DESC")
+        .first
+    end
+
+    # Return the next lower item in the list.
+    def lower_item
+      return nil unless in_list?
+      acts_as_list_class.where("#{scope_condition} AND #{position_column} > #{send(position_column).to_s}")
+        .order("#{position_column} ASC" )
+        .first
+    end
+
+    # Test if this record is in a list
+    def in_list?
+      !send(position_column).nil?
+    end
+
+    private
+    def add_to_list_top
+      increment_positions_on_all_items
+    end
+
+    def add_to_list_bottom
+      self[position_column] = bottom_position_in_list.to_i + 1
+    end
+
+    # Overwrite this method to define the scope of the list changes
+    def scope_condition()
+      "1"
+    end
+
+    # Returns the bottom position number in the list.
+    #   bottom_position_in_list    # => 2
+    def bottom_position_in_list(except = nil)
+      item = bottom_item(except)
+      item ? item.send(position_column) : 0
+    end
+
+    # Returns the bottom item
+    def bottom_item(except = nil)
+      conditions = scope_condition
+      conditions = "#{conditions} AND #{self.class.primary_key} != #{except.id}" if except
+      acts_as_list_class.where(conditions).order("#{position_column} DESC").first
+    end
+
+    # Forces item to assume the bottom position in the list.
+    def assume_bottom_position
+      update_attribute(position_column, bottom_position_in_list(self).to_i + 1)
+    end
+
+    # Forces item to assume the top position in the list.
+    def assume_top_position
+      update_attribute(position_column, 1)
+    end
+
+    # This has the effect of moving all the higher items up one.
+    def decrement_positions_on_higher_items(position)
+      acts_as_list_class.update_all(
+          "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} <= #{position}"
+      )
+    end
+
+    # This has the effect of moving all the lower items up one.
+    def decrement_positions_on_lower_items
+      return unless in_list?
+      acts_as_list_class.where(
+          "#{scope_condition} AND #{position_column} > #{send(position_column).to_i}"
+      ).update_all("#{position_column} = (#{position_column} - 1)")
+    end
+
+    # This has the effect of moving all the higher items down one.
+    def increment_positions_on_higher_items
+      return unless in_list?
+      acts_as_list_class.where("#{scope_condition} AND #{position_column} < #{send(position_column).to_i}").update_all("#{position_column} = (#{position_column} + 1)")
+    end
+
+    # This has the effect of moving all the lower items down one.
+    def increment_positions_on_lower_items(position)
+      acts_as_list_class.where("#{scope_condition} AND #{position_column} >= #{position}").update_all(
+          "#{position_column} = (#{position_column} + 1)"
+      )
+    end
+
+    # Increments position (<tt>position_column</tt>) of all items in the list.
+    def increment_positions_on_all_items
+      acts_as_list_class.where("#{scope_condition}").update_all(
+          "#{position_column} = (#{position_column} + 1)"
+      )
+    end
+
+    def insert_at_position(position)
+      remove_from_list
+      increment_positions_on_lower_items(position)
+      self.update_attribute(position_column, position)
+    end
+  end
+end

data/lib/browsercms-artirix.rb

@@ -0,0 +1 @@
+require_relative './browsercms'

data/lib/browsercms.rb

@@ -0,0 +1,73 @@
+# Load all dependencies needed at boot time.
+require 'rails'
+require 'cms/configuration'
+require 'cms/version'
+require 'browsercms'
+
+require 'sass-rails'
+require 'compass-rails'
+require 'bootstrap-sass'
+
+# Gem name is different than file name
+# Must be required FIRST, so that our assets paths appear before its do.
+# This allows app/assets/ckeditor/config.js to set CMS specific defaults.
+require 'ckeditor-rails'
+
+# Explicitly require this, so that CMS projects do not need to add it to their Gemfile
+# especially while upgrading
+require 'jquery-rails'
+require 'jquery-ui-rails'
+
+require 'underscore-rails'
+require 'will_paginate'
+require 'will_paginate/active_record'
+require 'actionpack/page_caching'
+require 'panoramic'
+require 'simple_form'
+require 'devise'
+
+require 'cms/engine'
+require 'cms/extensions'
+require 'cms/route_extensions'
+require 'cms/caching'
+require 'cms/error_pages'
+
+require 'cms/users_service'
+
+#Load libraries that are included with CMS
+require 'acts_as_list'
+ActiveRecord::Base.send(:include, ActsAsList)
+
+require 'cms/acts'
+require 'cms/authentication'
+require 'cms/content_page'
+require 'cms/configuration/configurable_template'
+require 'cms/domain_support'
+require 'cms/authoring'
+require 'cms/date_picker'
+require 'cms/content_rendering_support'
+require 'cms/mobile_aware'
+require 'cms/attachments/configuration'
+require 'cms/controllers/admin_controller'
+require 'cms/default_accessible'
+require 'cms/admin_tab'
+require 'cms/publish_workflow'
+require 'cms/content_filter'
+require 'cms/polymorphic_single_table_inheritance'
+require 'cms/form_builder/default_input'
+require 'cms/form_builder/content_block_form_builder'
+require 'cms/form_builder/workflow_buttons'
+
+# This shouldn't be necessary, except for the need to get into the loadpath for testing.
+require 'command_line'
+
+#Include CMS Behaviors
+ActiveRecord::Base.send(:include, Cms::Acts::ContentBlock)
+require 'cms/behaviors'
+require 'cms/concerns'
+
+
+ActiveRecord::Base.send(:include, Cms::Acts::CmsUser)
+require 'cms/responders/content_responder'
+
+require "panoramic"

data/lib/cms/acts/cms_user.rb

@@ -0,0 +1,131 @@
+module Cms
+  module Acts
+
+    # Allows any ActiveRecord object to behave like a Cms User. This is a bit of an experiment being added to 3.4, so
+    # so it might be deprecated in a future version if we add something like devise.
+    #
+    # The use case would be something like:
+    #
+    #   class AdminUser < ActiveRecord::Base
+    #     acts_as_cms_user :groups => [Cms::Group.find_by_code('admin')]
+    #   end
+    #
+    # where groups could be an array, proc, or instance method (as a symbol).
+    # Could be used it with authlogic to grant logins and permissions to
+    # everyone in a custom model.  It's not quite a drop in authentication
+    # schema, but it does make it easier to wire up just about any model to be
+    # the current_user on CMS pages.
+    module CmsUser
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+
+      module MacroMethods
+        def acts_as_cms_user(options = {})
+          include InstanceMethods
+
+          # Adding a cms_group method to each person object that returns a list of
+          # CMS Groups the user belongs to.  Can be set with an array, proc, or
+          # instance method on the person.  Defaults to Cms::Group.guest
+          define_method "cms_groups" do
+            fetch_group_list = Proc.new do
+              if options[:groups].nil?
+                [Cms::Group.guest]
+              elsif options[:groups].kind_of? Array
+                options[:groups]
+              elsif options[:groups].is_a? Proc
+                options[:groups].call(self)
+              elsif self.respond_to?(options[:groups])
+                self.send(options[:groups])
+              else
+                raise ArgumentError, "acts_as_cms_user :groups option expected to be of type Array, Proc, or instance method - #{options[:groups].class} found instead"
+              end
+            end
+
+            @cms_groups ||= begin
+              specified = Array(fetch_group_list.call).select { |x| x.kind_of? Cms::Group }
+              specified << Cms::Group.guest if specified.empty?
+              specified
+            end
+
+          end
+        end
+
+        module InstanceMethods
+
+          # The following came from Cms::User
+          def guest?
+            false
+          end
+
+          # checks for usage
+          def cms_user_compatible?
+            true
+          end
+
+          def enable_able?
+            false
+          end
+
+          def disable_able?
+            false
+          end
+
+          # Determine if this user has permission to view the specific object. Permissions
+          #   are always tied to a specific section. This method can take different input parameters
+          #   and will attempt to determine the relevant section to check.
+          # Expects object to be of type:
+          #   1. Section - Will check the user's groups to see if any of those groups can view this section.
+          #   2. Path - Will look up the section based on the path, then check it.  (Note that section paths are not currently unique, so this will check the first one it finds).
+          #   3. Other - Assumes it has a section attribute and will call that and check the return value. 
+          #
+          # Returns: true if the user can view this object, false otherwise.
+          # Raises: ActiveRecord::RecordNotFound if a path to a not existent section is passed in.
+          def able_to_view?(object)
+            section = object
+            if object.is_a?(String)
+              section = Cms::Section.find_by_path(object)
+              raise ActiveRecord::RecordNotFound.new("Could not find section with path = '#{object}'") unless section
+            elsif !object.is_a?(Cms::Section)
+              section = object.section
+            end
+            viewable_sections.include?(section) || cms_access?
+          end
+
+
+          # The following came from Cms::GuestUser or Cms::User
+
+          # Expects a list of names of Permissions
+          # true if the user has any of the permissions
+          def able_to?(*required_permissions)
+            perms = required_permissions.map(&:to_sym)
+            permissions.any? do |p|
+              perms.include?(p.name.to_sym)
+            end
+          end
+
+
+          # Guests never get access to the CMS.
+          def cms_access?
+            false
+          end
+
+          # Return a list of the sections associated with this user that can be viewed.
+          # Overridden from user so that able_to_view? will work correctly.
+          def viewable_sections
+            @viewable_sections ||= Cms::Section.includes(:groups).where(["#{Cms::Group.table_name}.id  in (?)", cms_groups.collect(&:id)])
+          end
+
+          def permissions
+            @permissions ||= Cms::Permission.includes(:groups).where(["#{Cms::Group.table_name}.id  in (?)", cms_groups.collect(&:id)])
+          end
+
+          def able_to_edit?(section)
+            false
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/cms/acts/content_block.rb

@@ -0,0 +1,61 @@
+module Cms
+  module Acts
+    module ContentBlock
+
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+
+      module MacroMethods
+
+        # Adds Content Block behavior to this class
+        #
+        # @param [Hash] options
+        # @option options [Boolean] :allow_attachments (true) Determines whether this content block can be marked as having attachments.
+        def acts_as_content_block(options={})
+          defaults = {
+              # Set default values here.
+              :allow_attachments => true,
+              :content_module => true
+          }
+          options = defaults.merge(options)
+
+          if options[:belongs_to_attachment].present?
+            raise ArgumentError.new ":belongs_to_attachment option is no longer supported. Please use :has_attachments option"
+          end
+
+          extend Cms::DefaultAccessible
+          allow_attachments if options[:allow_attachments]
+          is_archivable(options[:archiveable].is_a?(Hash) ? options[:archiveable] : {}) unless options[:archiveable] == false
+          is_connectable(options[:connectable].is_a?(Hash) ? options[:connectable] : {}) unless options[:connectable] == false
+          flush_cache_on_change(options[:flush_cache_on_change].is_a?(Hash) ? options[:flush_cache_on_change] : {}) unless options[:flush_cache_on_change] == false
+          is_renderable({:instance_variable_name_for_view => "@content_block"}.merge(options[:renderable].is_a?(Hash) ? options[:renderable] : {})) unless options[:renderable] == false
+          is_publishable(options[:publishable].is_a?(Hash) ? options[:publishable] : {}) unless options[:publishable] == false
+          is_searchable(options[:searchable].is_a?(Hash) ? options[:searchable] : {}) unless options[:searchable] == false
+          uses_soft_delete(options[:soft_delete].is_a?(Hash) ? options[:soft_delete] : {}) unless options[:soft_delete] == false
+          is_taggable(options[:taggable].is_a?(Hash) ? options[:taggable] : {}) if options[:taggable]
+          is_userstamped(options[:userstamped].is_a?(Hash) ? options[:userstamped] : {}) unless options[:userstamped] == false
+          is_versioned(options[:versioned].is_a?(Hash) ? options[:versioned] : {}) unless options[:versioned] == false
+
+          include InstanceMethods
+
+          unless options[:content_module] == false
+            has_content_type
+          end
+          extend Cms::Behaviors::Naming
+
+        end
+
+        module InstanceMethods
+          def to_s
+            "#{self.class.name.demodulize.titleize} '#{name}'"
+          end
+        end
+
+
+      end
+
+
+    end
+  end
+end