browsercms 3.5.7 → 4.0.0.alpha

data/lib/cms/engine_helper.rb

@@ -2,36 +2,34 @@ module Cms
 
   class EngineAwarePathBuilder
 
-    def initialize(model_class_or_content_type_or_model)
-      # ContentType
-      if model_class_or_content_type_or_model.respond_to? :model_class
-        @path_subject = model_class_or_content_type_or_model.model_class
-      else # Class or Model
-        @path_subject = model_class_or_content_type_or_model
-      end
-    end
 
-    # The object that will be added to the constructed path.
-    def path_subject
-      @path_subject
+    attr_reader :path_subject
+
+    def initialize(model_class_or_content_type_or_model)
+      normalize_subject_class(model_class_or_content_type_or_model)
     end
 
     def subject_class
-      if @path_subject.instance_of?(Class)
-        @path_subject
+      if path_subject.instance_of?(Class)
+        path_subject
       else
-        @path_subject.class
+        path_subject.class
       end
     end
 
-    def build(view)
+    def build_preview(view)
       path = []
       path << engine_name
-      path << "cms" if main_app_model?
       path << path_subject
+      path
+    end
 
-      path[0] = view.send(path[0]) # Replace the engine name with an actual lookup of the proper Engine routeset
+    def build(view)
+      path = []
+      path << engine(view)
+      path << path_subject
       path
+
     end
 
     def main_app_model?
@@ -40,7 +38,8 @@ module Cms
 
     # Determine which 'Engine' this model is from based on the class
     def engine_name
-      name = EngineHelper.module_name(subject_class)
+      model_class = subject_class.model_name
+      name = EngineAware.module_name(model_class)
       return "main_app" unless name
 
       begin
@@ -51,52 +50,43 @@ module Cms
       end
       engine.engine_name
     end
-  end
 
-  module EngineHelper
 
-    def main_app_model?
-      engine_name == "main_app"
+    def engine_class
+      if main_app_model?
+        Rails.application
+      else
+        guess_engine_class(subject_class)
+      end
     end
 
-    def engine_exists?
-      !main_app_model?
-    end
+    private
 
-    def engine_name
-      name = EngineHelper.module_name(target_class)
-      return "main_app" unless name
+    # Will raise NameError if klass::Engine doesn't exist.
+    def guess_engine_class(klass)
+      name = EngineAware.module_name(klass)
+      "#{name}::Engine".constantize
+    end
 
-      begin
-        engine = "#{name}::Engine".constantize
-      rescue NameError
-        # This means there is no Engine for this model, so its from the main Rails App.
-        return "main_app"
+    # Allows ContentType, Class, or model to be passed.
+    def normalize_subject_class(model_class_or_content_type_or_model)
+      if model_class_or_content_type_or_model.respond_to? :model_class # i.e. ContentType
+        @path_subject = model_class_or_content_type_or_model.model_class
+      else # Class or Model
+        @path_subject = model_class_or_content_type_or_model
       end
-      engine.engine_name
     end
 
-    def path_elements
-      path = []
-      path << "cms" if main_app_model?
-      path << path_subject
+    # Loads the actual engine (which contains the RouteSet.)
+    # See http://api.rubyonrails.org/classes/ActionDispatch/Routing/PolymorphicRoutes.html
+    def engine(view)
+      view.send(engine_name)
     end
 
-    # Subclasses can override this as necessary
-    def target_class
-      return self.class unless self.instance_of?(Class)
-      self
-    end
 
-    # Subclasses can override this as necessary
-    def path_subject
-      self
-    end
+  end
 
-    # Add this module if its not already.
-    def self.decorate(instance)
-      instance.extend EngineHelper unless instance.respond_to?(:engine_name)
-    end
+  module EngineAware
 
     # Finds the top level module for a given class.
     # Cms::Thing -> Cms

data/{app/controllers → lib}/cms/error_handling.rb

@@ -3,7 +3,7 @@ module Cms
     def self.included(controller)
       controller.class_eval do
         rescue_from Exception, :with => :handle_server_error unless Rails.env == "test"
-        rescue_from Cms::Errors::AccessDenied, :with => :handle_access_denied
+        rescue_from Cms::Errors::AccessDenied, :with => :handle_internal_access_denied
       end
     end
 
@@ -17,21 +17,27 @@ module Cms
       result
     end
 
-    def handle_server_error(exception)
-      logger.error "Handling Exception: #{exception}"
+    def handle_server_error(exception, status=:internal_server_error)
+      log_complete_stacktrace(exception)
       with_format('html') do
         render :layout => 'cms/application',
                :template => 'cms/shared/error',
-               :status => :internal_server_error,
+               :status => status,
                :locals => {:exception => exception}
       end
     end
 
-    def handle_access_denied(exception)
+    def handle_internal_access_denied(exception)
       render :layout => 'cms/application',
              :template => 'cms/shared/access_denied',
              :status => 403
     end
 
+    # Print the underlying stack trace to the logs for debugging.
+    # Should be human readable (i.e. line breaks)
+    # See http://stackoverflow.com/questions/228441/how-do-i-log-the-entire-trace-back-of-a-ruby-exception-using-the-default-rails-l for discussion of implementation
+    def log_complete_stacktrace(exception)
+      logger.error "#{exception.message}\n#{exception.backtrace.join("\n")}"
+    end
   end
 end

data/lib/cms/extensions.rb

@@ -1,4 +1,5 @@
-Dir["#{File.join(File.dirname(__FILE__), "extensions")}/**/*.rb"].each do |f| 
+# All files in cms/extensions will automatically be loaded.
+Dir["#{File.join(File.dirname(__FILE__), "extensions")}/**/*.rb"].each do |f|
   Rails.logger.info "~~ Loading extensions from #{f}" if Rails.logger
   require f
 end

data/lib/cms/extensions/active_model/name.rb

@@ -0,0 +1,13 @@
+module Cms
+  module ActiveModel
+    module Name
+
+      # Provide backwards capablity with Rails 3.2.x method.
+      # Hopefully only has_dynamic_attributes requires this.
+      def foreign_key
+        "#{self.param_key}_id"
+      end
+    end
+  end
+end
+ActiveModel::Name.send(:include, Cms::ActiveModel::Name)

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

@@ -2,130 +2,90 @@ module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module SchemaStatements
 
-      # Applies the current CMS prefix to the given table name.
-      # Useful for where you need CMS related migrations using stock rails migrations (like add_index or create_table)
-      # but still want to dynamically apply the CMS prefixes.
-      def prefix(table_name)
-        Cms::Namespacing.prefixed_table_name(table_name)
+      # Sticks :cms_ in front of a table name.
+      def cms_(table_name)
+        "cms_#{table_name}"
       end
 
-      # Pass in ":versioned => false" in the options hash to create a non-versioned table.
+      # Create a table and its versioned counterpart. Example:
+      #   create_content_table :cms_events
+      #   => :cms_events
+      #   => :cms_event_versions
       #
-      # @param table_name
+      # @param table_name [Symbol] The namespaced versioned of the content table (i.e. :cms_events or :bcms_news_articles)
       # @param options
-      # @option :prefix [Boolean]
+      # @option :versioned [Boolean] false creates a non-versioned table. (Default: true)
+      # @option :name [Boolean] Create a :name column in the generated table. (Default: true)
       def create_content_table(table_name, options={}, &block)
         defaults = {
             versioned: true,
-            prefix: true
+            name: true
         }
         options = defaults.merge(options)
 
-        if options[:prefix]
-          table_name = Cms::Namespacing.prefixed_table_name(table_name)
+        versioned = options.delete(:versioned)
+        named = options.delete(:name)
+
+        create_table table_name, options, &block
+        change_table table_name do |td|
+          if versioned
+            td.integer :version
+            td.integer :lock_version, :default => 0
+          end
+          td.string :name if !column_exists?(table_name.to_sym, :name) && named
+          td.boolean :published, :default => false
+          td.boolean :deleted, :default => false
+          td.boolean :archived, :default => false
+          td.integer :created_by_id
+          td.integer :updated_by_id
+          td.timestamps unless column_exists?(table_name.to_sym, :created_at)
         end
 
-        #Create 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 :original_record_id
-          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)
+        if versioned
+          table_name_versioned = versioned_(table_name)
+          create_table table_name_versioned, options, &block
+          change_table table_name_versioned do |vt|
+            vt.integer :original_record_id
+            vt.integer :version
+            vt.string :name if !column_exists?(table_name_versioned, :name) && named
+            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 unless column_exists?(table_name_versioned, :created_at)
+          end
         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)
-        table_name = Cms::Namespacing.prefixed_table_name(table_name)
-        drop_table "#{table_name.singularize}_versions".to_sym
+      def drop_content_table(table_name)
+        drop_table versioned_(table_name)
         drop_table table_name
       end
 
-      alias :drop_content_table :drop_versioned_table
-
       # Rename a column for both its
       def rename_content_column(table_name, old_name, new_name)
         rename_column table_name, old_name, new_name
-        rename_column version_table_name(table_name), old_name, new_name
+        rename_column versioned_(table_name), old_name, new_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 version_table_name(table_name), column_name, type, options
+        add_column versioned_(table_name), column_name, type, options
       end
 
       def remove_content_column(table_name, column_name)
         remove_column table_name, column_name
-        remove_column version_table_name(table_name), column_name
-      end
-
-      # Will namespace the content table
-      def content_table_exists?(table_name)
-        table_exists?(Cms::Namespacing.prefixed_table_name(table_name))
+        remove_column versioned_(table_name), column_name
       end
 
-      private
+      protected
 
-      def version_table_name(table_name)
+      def versioned_(table_name)
         "#{table_name.to_s.singularize}_versions".to_sym
       end
 

data/lib/cms/extensions/hash.rb

@@ -5,18 +5,6 @@ module Cms
       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
-      #
-      # Note: This behavior is slightly different from ActiveSupport Hash#extract! which can add nil keys if they don't exist.
-      def extract_only!(*keys)
-        keys.inject({}) do |hash, key|
-          hash[key] = delete(key) if has_key?(key)
-          hash
-        end
-      end
     end
   end
 end

data/lib/cms/form_builder/content_block_form_builder.rb

@@ -0,0 +1,45 @@
+require 'cms/form_builder/deprecated_inputs'
+
+module Cms
+  module FormBuilder
+    # Adds additional methods to the forms for creating content blocks.
+    class ContentBlockFormBuilder < SimpleForm::FormBuilder
+      include DeprecatedInputs
+
+      # Allows editors to add multiple files uploader for attachments.
+      # Usage:
+      #   <%= f.attachment_manager %>
+      #
+      # Generator: The following will generate an attachments field with an associated attachment manager input.
+      #   rails generate cms:content_block Widget photos:attachments
+      def cms_attachment_manager
+        input :attachments, as: :attachments
+      end
+
+      # Allows editors add a space separated list of tags. Each tag entered will be created if needed as an instance of a Cms::Tag.
+      #
+      # Usage:
+      #   <%= f.cms_tag_list %>
+      #
+      # There is no generator for this field type.
+      #
+      def cms_tag_list(options={})
+        input :tag_list, as: :tag_list, label: "Tags", input_html: {autocomplete: 'off'}, hint: "A space separated list of tags."
+      end
+
+      # Displays a concise list of error messages. This is may be unnecessary given that simple form will display error inline.
+      # Handles 'global' messages that aren't specific to a field.
+      def cms_error_messages
+        return unless object.respond_to?(:errors) && object.errors.any?
+
+        errors_list = ""
+        errors_list << @template.content_tag(:h2, "#{object.errors.size} error prohibited this #{object_name.humanize} from being saved.".html_safe)
+        errors_list << @template.content_tag(:p, "There were problems with the following fields:")
+        errors_list << @template.content_tag(:ul, object.errors.full_messages.map { |message| @template.content_tag(:li, message).html_safe }.join("\n").html_safe).html_safe
+
+        @template.content_tag(:div, errors_list.html_safe, :class => "errorExplanation", :id => "errorExplanation")
+      end
+
+    end
+  end
+end

data/lib/cms/form_builder/default_input.rb

@@ -0,0 +1,13 @@
+module Cms
+  module FormBuilder
+    module DefaultInput
+
+      # Use a default value if there isn't one specfied already.
+      def extract_default
+        if options[:default] && object.new_record? && object.send(attribute_name).blank?
+          input_html_options[:value] = options[:default]
+        end
+      end
+    end
+  end
+end