browsercmsi 3.1.0

data/lib/cms/behaviors/versioning.rb

@@ -0,0 +1,273 @@
+module Cms
+  module Behaviors
+    module Versioning
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+      module MacroMethods      
+        def versioned?
+          !!@is_versioned
+        end
+        def is_versioned(options={})
+          @is_versioned = true
+
+          @version_foreign_key = (options[:version_foreign_key] || "#{name.underscore}_id").to_s
+          @version_table_name = (options[:version_table_name] || "#{table_name.singularize}_versions").to_s
+
+          extend ClassMethods
+          include InstanceMethods
+
+          has_many :versions, :class_name  => version_class_name, :foreign_key => version_foreign_key
+
+          before_validation_on_create :initialize_version
+
+          attr_accessor :revert_to_version
+
+          #Define the version class
+          const_set("Version", Class.new(ActiveRecord::Base)).class_eval do 
+            class << self; attr_accessor :versioned_class end
+
+            def versioned_class
+              self.class.versioned_class
+            end
+            def versioned_object_id
+              send("#{versioned_class.name.underscore}_id")
+            end
+            def versioned_object
+              send(versioned_class.name.underscore.to_sym)
+            end                 
+          end unless self.const_defined?("Version")
+
+          version_class.versioned_class = self
+
+          version_class.belongs_to(name.underscore.to_sym, :foreign_key => version_foreign_key)
+
+          version_class.is_userstamped if userstamped?
+
+        end
+      end
+      module ClassMethods        
+        def version_class
+          const_get "Version"
+        end
+
+        def version_class_name
+          "#{name}::Version"
+        end        
+
+        def version_foreign_key
+          @version_foreign_key
+        end
+
+        def version_table_name        
+          @version_table_name
+        end
+
+        def versioned_columns
+          @versioned_columns ||= (version_class.new.attributes.keys - 
+            (%w[id lock_version position version_comment created_at updated_at created_by_id updated_by_id type] + [version_foreign_key]))
+        end                   
+      end
+      module InstanceMethods
+        def initialize_version
+          self.version = 1
+        end
+
+        def build_new_version
+          # First get the values from the draft
+          attrs = draft_attributes
+
+          # Now overwrite all values
+          (self.class.versioned_columns - %w(version)).each do |col|
+            attrs[col] = send(col)
+          end
+
+          attrs[:version_comment] = @version_comment || default_version_comment
+          @version_comment = nil            
+          new_version = versions.build(attrs)
+          new_version.version = new_record? ? 1 : (draft.version.to_i + 1)
+          after_build_new_version(new_version) if respond_to?(:after_build_new_version)
+          new_version
+        end
+
+        def draft_attributes
+          # When there is no draft, we'll just copy the attibutes from this object
+          # Otherwise we need to use the draft
+          d = new_record? ? self : draft
+          self.class.versioned_columns.inject({}){|attrs, col| attrs[col] = d.send(col); attrs }
+        end 
+
+        def default_version_comment
+          if new_record?
+            I18n.t("behaviors.versioning.created")
+          else
+            I18n.t("behaviors.versioning.changed", :changes => (changes.keys - %w[version created_by_id updated_by_id]).sort.join(', '))
+          end
+        end
+
+        def save(perform_validations=true)
+          transaction do
+            #logger.info "..... Calling valid?"
+            return false unless !perform_validations || valid?            
+            
+            if different_from_last_draft?
+              #logger.info "..... Changes => #{changes.inspect}"
+            else
+              #logger.info "..... No Changes"
+              return true
+            end
+            
+            #logger.info "..... Calling before_save"
+            return false if callback(:before_save) == false
+
+            if new_record?
+              #logger.info "..... Calling before_create"
+              return false if callback(:before_create) == false
+            else      
+              #logger.info "..... Calling before_update"
+              return false if callback(:before_update) == false
+            end
+
+            #logger.info "..... Calling build_new_version"
+            new_version = build_new_version
+            #logger.info "..... Is new version valid? #{new_version.valid?}"
+            if new_record?
+              self.version = 1
+              #logger.info "..... Calling create_without_callbacks"
+              if result = create_without_callbacks
+                #logger.info "..... Calling after_create"
+                if callback(:after_create) != false
+                  #logger.info "..... Calling after_save"
+                  callback(:after_save)
+                end
+                
+                if @publish_on_save
+                  publish
+                  @publish_on_save = nil
+                end                
+                changed_attributes.clear                                   
+              end
+              result
+            elsif new_version
+              #logger.info "..... Calling save"
+              if result = new_version.save
+                #logger.info "..... Calling after_save"
+                if callback(:after_update) != false
+                  #logger.info "..... Calling after_update"
+                  callback(:after_save)
+                end
+                
+                if @publish_on_save
+                  publish
+                  @publish_on_save = nil
+                end 
+                changed_attributes.clear
+              end
+              result
+            end
+            true
+          end
+        end
+
+        def save!(perform_validations=true)
+          save(perform_validations) || raise(ActiveRecord::RecordNotSaved.new(errors.full_messages))
+        end
+
+        def draft
+          versions.first(:order => "version desc")    
+        end
+        
+        def draft_version?
+          version == draft.version
+        end
+        
+        def live_version
+          find_version(self.class.find(id).version)
+        end
+
+        def live_version?
+          version == self.class.find(id).version
+        end
+
+        def current_version
+          find_version(self.version)
+        end
+        
+        def find_version(number)
+          versions.first(:conditions => { :version => number })
+        end
+
+        def as_of_draft_version
+          as_of_version(draft.version)
+        end
+
+        def as_of_version(version)
+          v = find_version(version)
+          raise ActiveRecord::RecordNotFound.new("version #{version.inspect} does not exist for <#{self.class}:#{id}>") unless v
+          obj = self.class.new
+
+          (self.class.versioned_columns + [:version, :created_at, :created_by_id, :updated_at, :updated_by_id]).each do |a|
+            obj.send("#{a}=", v.send(a))
+          end
+          obj.id = id
+          obj.lock_version = lock_version
+
+          # Need to do this so associations can be loaded
+          obj.instance_variable_set("@new_record", false)
+
+          # Callback to allow us to load other data when an older version is loaded
+          obj.after_as_of_version if obj.respond_to?(:after_as_of_version)
+
+          # Last but not least, clear the changed attributes
+          if changed_attrs = obj.send(:changed_attributes)
+            changed_attrs.clear
+          end
+
+          obj      
+        end
+
+        def revert
+          draft_version = draft.version
+          revert_to(draft_version - 1) unless draft_version == 1
+        end
+
+        def revert_to_without_save(version)
+          raise "Version parameter missing" if version.blank?
+          self.revert_to_version = find_version(version)
+          raise "Could not find version #{version}" unless revert_to_version
+          (self.class.versioned_columns - ["version"]).each do |a|
+            send("#{a}=", revert_to_version.send(a))
+          end  
+          self.version_comment = "Reverted to version #{version}"
+          self            
+        end    
+
+        def revert_to(version)
+          revert_to_without_save(version)
+          save
+        end    
+
+        def version_comment
+          @version_comment
+        end
+
+        def version_comment=(version_comment)
+          @version_comment = version_comment
+          send(:changed_attributes)["version_comment"] = @version_comment
+        end
+
+        def different_from_last_draft?
+          return true if self.changed?
+          last_draft = self.draft
+          return true unless last_draft
+          (self.class.versioned_columns - %w(version)).each do |col|
+            return true if self.send(col) != last_draft.send(col)
+          end
+          return false
+        end
+
+      end
+    end
+
+  end
+end

data/lib/cms/behaviors.rb

@@ -0,0 +1,33 @@
+# Behaviors are used in CMS to add features to a model. 
+# They are very similar to the various "acts_as_*" or "*_fu" plugins/gems 
+# that have been created for Rails.  
+#
+# Generally, each behavior has three modules in it.  They are:
+# * MacroMethods
+# * ClassMethods
+# * InstanceMethods
+#
+# When the CMS starts up, all of the Behaviors are included into ActiveRecord::Base.
+# The MacroMethods module of each Behavior is also included into ActiveRecord::Base.
+# The MacroMethods module contains Class methods that you can call within your model
+# in order to enable that Behavior for that Class.  For example, if you want to have
+# an Article module that is taggable, you would do this:
+#
+#     class Article < ActiveRecord::Base
+#       is_taggable
+#     end
+#
+# So in this case, you are calling the `is_taggable` macro method, which enables the 
+# taggable behavior for the Article model.  It enables the behavior by extending the
+# ClassMethods module and including the InstanceMethods module into the Article class.
+# Each Behavior typically has one macro method which takes an options Hash, which of course
+# varies from Behavior to Behavior.  The macro method will also sometimes call other
+# macro methods, like before_fitler, named_scope, etc. to modify the model.
+# Consult the documentation for each module for specific details as to what
+# the Behavior does.
+module Cms::Behaviors; end
+
+Dir["#{File.dirname(__FILE__)}/behaviors/*.rb"].each do |b| 
+  require File.join("cms", "behaviors", File.basename(b, ".rb"))
+  ActiveRecord::Base.send(:include, "Cms::Behaviors::#{File.basename(b, ".rb").camelize}".constantize)
+end

data/lib/cms/caching.rb

@@ -0,0 +1,20 @@
+module Cms
+  module Caching
+    def caching_enabled?
+      ActionController::Base.perform_caching
+    end
+    def flush_cache
+      #Hmmm...this is kinda scary.  What if page cache directory is
+      #set to the the default, which is /public?
+      #So we are going to check that the directory is not called "public"
+      if File.exists?(ActionController::Base.page_cache_directory) && 
+          File.basename(ActionController::Base.page_cache_directory) != "public"
+        FileUtils.rm_rf Dir.glob("#{ActionController::Base.page_cache_directory}/*")
+        Rails.logger.info "Cache Flushed"
+      end
+    end   
+  end
+  class << self
+    include Caching
+  end
+end

data/lib/cms/content_rendering_support.rb

@@ -0,0 +1,96 @@
+#
+# This module can be added to Controllers to provide support for rendering CMS content pages.
+#
+module Cms
+  module ContentRenderingSupport
+
+    def self.included(base)
+      base.send :include, Cms::ErrorHandling
+
+      base.rescue_from Exception, :with => :handle_server_error_on_page
+      base.rescue_from Cms::Errors::AccessDenied, :with => :handle_access_denied_on_page
+      base.rescue_from ActiveRecord::RecordNotFound, :with => :handle_not_found_on_page
+    end
+
+    def handle_not_found_on_page(exception)
+      logger.warn "Page Not Found"
+      handle_error_with_cms_page('/system/not_found', exception, :not_found)
+    end
+
+    def handle_access_denied_on_page(exception)
+      logger.warn "Access Denied"
+      handle_error_with_cms_page('/system/access_denied', exception, :forbidden)
+    end
+
+    def handle_server_error_on_page(exception)
+      logger.warn "Exception: #{exception.message}\n"
+      logger.warn "#{exception.backtrace.join("\n")}\n"
+      handle_error_with_cms_page('/system/server_error', exception, :internal_server_error)
+    end
+
+    private
+
+    # This is the method all error handlers delegate to
+    def handle_error_with_cms_page(error_page_path, exception, status, options={})
+
+      # If we are in the CMS, we just want to show the exception
+      if perform_caching
+        return handle_server_error(exception) if cms_site?
+      else
+        return handle_server_error(exception) if current_user.able_to?(:edit_content, :publish_content)
+      end
+
+      # We must be showing the page outside of the CMS
+      # So we will show the error page
+      if @page = Page.find_live_by_path(error_page_path)
+        logger.info "Rendering Error Page: #{@page.inspect}"
+        @mode = "view"
+        @show_page_toolbar = false
+
+        # copy new instance variables to the template
+        %w[page mode show_page_toolbar].each do |v|
+          @template.instance_variable_set("@#{v}", instance_variable_get("@#{v}"))
+        end
+
+        # clear out any content already captured
+        # by previous attempts to render the page within this request
+        @template.instance_variables.select{|v| v =~ /@content_for_/ }.each do |v|
+          @template.instance_variable_set("#{v}", nil)
+        end
+
+        prepare_connectables_for_render
+        render :layout => @page.layout, :template => 'cms/content/show', :status => status
+      else
+        handle_server_error(exception)
+      end
+    end
+
+    # If any of the page's connectables (portlets, etc) are renderable, they may have a render method
+    # which does "controller" stuff, so we need to get that run before rendering the page.
+    def prepare_connectables_for_render
+
+      @_connectors = @page.connectors.for_page_version(@page.version)
+      @_connectables = @_connectors.map(&:connectable_with_deleted)
+      unless (logged_in? && current_user.able_to?(:administrate, :edit_content, :publish_content))
+        worst_exception = nil
+        @_connectables.each do |c|
+          begin
+            c.prepare_to_render(self)
+          rescue
+            logger.debug "THROWN EXCEPTION by connectable #{c}: #{$!}"
+            case $!
+              when ActiveRecord::RecordNotFound
+                raise
+              when Cms::Errors::AccessDenied
+                worst_exception = $!
+              else
+                c.render_exception = $!
+            end
+          end
+        end
+        raise worst_exception if worst_exception
+      end
+    end
+
+  end
+end

data/lib/cms/data_loader.rb

@@ -0,0 +1,28 @@
+module Cms
+  module DataLoader
+    def method_missing(method_name, *args)
+      if md = method_name.to_s.match(/^create_(.+)$/)
+        begin
+          #Make sure this is an active record class
+          super unless md[1].classify.constantize.ancestors.include?(ActiveRecord::Base)
+        rescue NameError => e
+          super
+        end
+        self.create(md[1], args[0], args[1] || {})
+      elsif @data && @data.has_key?(method_name)
+        record = @data[method_name][args.first]
+        record ? record.class.find(record.id) : nil
+      else
+        super
+      end
+    end
+    def create(model_name, record_name, data={})
+      puts "-- create_#{model_name}(:#{record_name})"
+      @data ||= {}
+      @data[model_name.pluralize.to_sym] ||= {}
+      model = model_name.classify.constantize.new(data)
+      model.save!
+      @data[model_name.pluralize.to_sym][record_name] = model
+    end
+  end
+end

data/lib/cms/domain_support.rb

@@ -0,0 +1,20 @@
+#
+# A support module for handling detecting if a page or controller is being
+# served by the public or cms domain.
+#
+module Cms
+  module DomainSupport
+
+    protected
+
+    def cms_domain_prefix
+      "cms"
+    end
+
+    def cms_site?
+      subdomains = request.subdomains
+      subdomains.shift if subdomains.first == "www"
+      subdomains.first == cms_domain_prefix
+    end
+  end
+end

data/lib/cms/extensions/action_view/base.rb

@@ -0,0 +1,13 @@
+module Cms
+  module Extensions
+    module ActionView
+      module Base
+        def next_tabindex
+          @tabindex ||= 0
+          @tabindex += 1
+        end
+      end
+    end
+  end
+end
+ActionView::Base.send(:include, Cms::Extensions::ActionView::Base)

data/lib/cms/extensions/active_record/base.rb

@@ -0,0 +1,16 @@
+module Cms
+  module Extensions
+    module ActiveRecord
+      module Base
+        def updated_on_string(fmt="%b %e, %Y")
+          if respond_to?(:updated_at) && updated_at
+            updated_at.strftime(fmt).gsub(/\s{2,}/," ")
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end
+ActiveRecord::Base.send(:include, Cms::Extensions::ActiveRecord::Base)

data/lib/cms/extensions/active_record/connection_adapters/abstract/schema_statements.rb

@@ -0,0 +1,88 @@
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module SchemaStatements
+
+      # Pass in ":versioned => false" in the options hash to create a non-versioned table.
+      def create_content_table(table_name, options={}, &block)
+
+        #Do the primary table
+        t = TableDefinition.new(self)
+        t.primary_key(options[:primary_key] || Base.get_primary_key(table_name)) unless options[:id] == false
+
+        unless options[:versioned] == false
+          t.integer :version
+          t.integer :lock_version, :default => 0
+        end
+
+        yield t
+
+        # Blocks currently must have a name column, otherwise the UI fails in several places.
+        # Some migrations may have already specified a name attribute, so we don't want to overwrite it here.
+        t.string :name unless t[:name]
+
+        t.boolean :published, :default => false
+        t.boolean :deleted, :default => false
+        t.boolean :archived, :default => false
+        t.integer :created_by_id
+        t.integer :updated_by_id
+        t.timestamps
+        
+        create_table_from_definition(table_name, options, t)
+
+        unless options[:versioned] == false
+          #Do the versions table
+          vt = TableDefinition.new(self)
+          vt.primary_key(options[:primary_key] || Base.get_primary_key(table_name)) unless options[:id] == false
+
+          vt.integer "#{table_name.to_s.singularize}_id".to_sym
+          vt.integer :version
+          yield vt
+
+          # Create implicit name column in version table as well.
+          vt.string :name unless vt[:name]
+
+          vt.boolean :published, :default => false
+          vt.boolean :deleted, :default => false
+          vt.boolean :archived, :default => false        
+          vt.string :version_comment
+          vt.integer :created_by_id
+          vt.integer :updated_by_id
+          vt.timestamps
+
+          create_table_from_definition("#{table_name.to_s.singularize}_versions".to_sym, options, vt)
+        end
+        
+      end   
+
+      #
+      # @deprecated - create_versioned_table should be considered deprecated and may be removed in a future version.
+      # Use create_content_table instead in your migrations
+      #
+      alias :create_versioned_table :create_content_table
+
+      def create_table_from_definition(table_name, options, table_definition)
+        if options[:force] && table_exists?(table_name)
+         drop_table(table_name, options)
+        end
+
+        create_sql = "CREATE#{' TEMPORARY' if options[:temporary]} TABLE "
+        create_sql << "#{quote_table_name(table_name)} ("
+        create_sql << table_definition.to_sql
+        create_sql << ") #{options[:options]}"
+        execute create_sql            
+      end
+      
+      def drop_versioned_table(table_name)
+        drop_table "#{table_name.singularize}_versions".to_sym
+        drop_table table_name
+      end
+
+      # Adds a column to both the primary and versioned table. Save needing two calls.
+      # This is only needed if your content block is versioned, otherwise add_column will work just fine.
+      def add_content_column(table_name, column_name, type, options={})
+        add_column table_name, column_name, type, options
+        add_column "#{table_name.to_s.singularize}_versions".to_sym, column_name, type, options
+      end
+    end
+  end
+end

data/lib/cms/extensions/active_record/errors.rb

@@ -0,0 +1,12 @@
+module Cms
+  module Extensions
+    module ActiveRecord
+      module Errors
+        def add_from_hash(errors)
+          errors.each{|k,v| add(k, v) } unless errors.blank?
+        end
+      end
+    end
+  end
+end
+ActiveRecord::Errors.send(:include, Cms::Extensions::ActiveRecord::Errors)

data/lib/cms/extensions/active_support/cache/file_store.rb

@@ -0,0 +1,9 @@
+module ActiveSupport
+  module Cache
+    class FileStore
+      def flush
+        FileUtils.rm_rf cache_path if File.exist?(cache_path)
+      end
+    end
+  end
+end

data/lib/cms/extensions/hash.rb

@@ -0,0 +1,21 @@
+module Cms
+  module Extensions
+    module Hash
+      #Returns a copy of the hash without the keys passed as arguments
+      def except(*args)
+        reject {|k,v| args.include?(k) }
+      end
+      
+      # This takes a list of keys and returns a new hash 
+      # containing the key/values that match the keys passed in. 
+      # This will also remove the keys from this hash
+      def extract!(*keys)
+        keys.inject({}) do |hash, key|
+          hash[key] = delete(key) if has_key?(key)
+          hash
+        end
+      end      
+    end
+  end
+end
+Hash.send(:include, Cms::Extensions::Hash)

data/lib/cms/extensions/integer.rb

@@ -0,0 +1,16 @@
+module Cms
+  module Extensions
+    module Integer
+      def round_bytes
+        if self > 1.megabyte
+          "%0.2f MB" % (self.to_f/1.megabyte)
+        elsif self > 1.kilobyte
+          "%0.2f KB" % (self.to_f/1.kilobyte)
+        else
+          "#{self} bytes"
+        end
+      end
+    end
+  end
+end
+Integer.send(:include, Cms::Extensions::Integer)

data/lib/cms/extensions/nil.rb

@@ -0,0 +1,19 @@
+module Cms
+  module Extensions 
+    module NilClass
+      def round_bytes
+        to_i.round_bytes
+      end
+      def markdown
+        nil
+      end
+      def to_slug
+        to_s
+      end
+      def to_formatted_s(format=nil)
+        nil
+      end
+    end
+  end
+end
+NilClass.send(:include, Cms::Extensions::NilClass)