browsercms-artirix 4.0.0.rc1.art4

data/lib/cms/domain_support.rb

@@ -0,0 +1,38 @@
+#
+# 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 request_is_for_cms_subdomain?
+      cms_site?
+    end
+
+    def cms_site?
+      subdomains = request.subdomains
+      subdomains.shift if subdomains.first == "www"
+      subdomains.first == cms_domain_prefix
+    end
+
+    # Determines if users should be redirected between the public (www.) and admin (cms.) subdomains.
+    def using_cms_subdomains?
+      result = (wants_to_use_subdomains? && perform_caching)
+      #Rails.logger.debug {"Are we using cms subdomains? #{result} based on 'want subdomain: #{wants_to_use_subdomains?}' and perform_caching: '#{perform_caching}'"}
+      result
+    end
+
+    private
+
+    def wants_to_use_subdomains?
+      !Rails.configuration.cms.use_single_domain
+    end
+
+  end
+end

data/lib/cms/engine.rb

@@ -0,0 +1,135 @@
+# Load just enough dependencies for this file to be loadable.
+require 'cms/module'
+
+module Cms
+  class Engine < Rails::Engine
+    include Cms::Module
+    isolate_namespace Cms
+
+    config.cms = ActiveSupport::OrderedOptions.new
+    config.cms.attachments = ActiveSupport::OrderedOptions.new
+
+    # Allows additional menu items to be added to the 'Tools' menu on the Admin tab.
+    config.cms.tools_menu = ActiveSupport::OrderedOptions.new
+
+    # Define configuration for the CKEditor
+    config.cms.ckeditor = ActiveSupport::OrderedOptions.new
+
+    # Configuration for content types.
+    config.cms.content_types = ActiveSupport::OrderedOptions.new
+
+    # Configuration for working on BrowserCMS core.
+    # We want these configuration for generators.
+    config.generators do |g|
+      g.test_framework :mini_test, :spec => true, :fixture => false
+      g.stylesheets false
+    end
+
+    # Configuration for projects using BrowserCMS>
+    # Need to use our rails model template (rather then its default) when `rails g cms:content_block` is run.
+    config.app_generators do |g|
+      path = File::expand_path('../../templates', __FILE__)
+      g.templates.unshift path
+    end
+
+    # Ensure Attachments are configured:
+    # 1. Before every request in development mode
+    # 2. Once in production
+    config.to_prepare do
+      Attachments.configure
+    end
+
+    # Set reasonable defaults
+    # These default values can be changed by developers in their projects in their application.rb or environment's files.
+    config.before_configuration do |app|
+      WillPaginate.per_page = 15
+
+      # Default cache directories.
+      app.config.cms.mobile_cache_directory = File.join(Rails.root, 'public', 'cache', 'mobile')
+      app.config.cms.page_cache_directory = File.join(Rails.root, 'public', 'cache', 'full')
+
+      # Default storage for uploaded files
+      app.config.cms.attachments.storage = :filesystem
+      app.config.cms.attachments.storage_directory = File.join(Rails.root, 'tmp', 'uploads')
+
+      # Determines if a single domain will be used (i.e. www) or multiple subdomains (www and cms). Enabling this will
+      # turn off page caching and not handle redirects between subdomains.
+      app.config.cms.use_single_domain = false
+
+      # Used to send emails with links back to the Cms Admin. In production, this should include the www. of the public site.
+      # Matters less in development, as emails generally aren't sent.
+      # I.e.
+      #   config.cms.site_domain = "www.browsercms.org"
+      app.config.cms.site_domain = "localhost:3000"
+
+      # Determines what email sender will be applied to messages generated by the CMS.
+      # By default, this is based on the site_domain, i.e. mailbot@example.com
+      app.config.cms.mailbot = :default
+
+      # Allows Addressable content types and Controllers to set which template will be used for page layouts.
+      # This takes precedence over the :template attribute set on models/controllers.
+      #    Keys are looked up based on Class.name.underscore
+      # @example:
+      #   config.cms.templates['cms/form'] = 'my-form-layout' # app/views/layouts/templates/my-form-layout
+      #   config.cms.templates['cms/sites/sessions_controller'] = 'subpage' # For /login
+      #
+      app.config.cms.templates = {}
+
+      # Determines which ckeditor file will be used to configure all instances.
+      # There should be at most ONE of these, so use manifest files which require the below one to augement it.
+      #app.config.cms.ckeditor.configuration_file = 'bcms/ckeditor_standard_config.js'
+      # Note: This no longer works since we are statically loading it via asset pipeline.
+
+      # Define menu items to be added dynamically to the CMS Admin tab.
+      app.config.cms.tools_menu = []
+
+      # Disable portlets so they don't appear in menus and can't be created. Existing portlets will not be deleted.
+      app.config.cms.content_types.blacklist = [:login_portlet, :forgot_password_portlet, :dynamic_portlet]
+
+      # Initialization
+      require 'cms/configure_simple_form'
+      require 'cms/configure_simple_form_bootstrap'
+      require 'cms/configuration/devise'
+
+      # Sets the default .css file that will be added to forms created via the Forms module.
+      # Projects can override this as needed.
+      app.config.cms.form_builder_css = 'cms/default-forms'
+
+    end
+
+    # Needed to ensure routes added to the main app by the Engine are available. (Since engine draws its routes after the main app)
+    # Borrrow from Spree as documenented here: https://github.com/rails/rails/issues/11895
+    config.after_initialize do
+      Rails.application.routes_reloader.reload!
+    end
+
+    initializer 'browsercms.add_core_routes', :after => 'action_dispatch.prepare_dispatcher' do |app|
+      ActionDispatch::Routing::Mapper.send :include, Cms::RouteExtensions
+    end
+
+    initializer 'browsercms.add_load_paths', :after => 'action_controller.deprecated_routes' do |app|
+
+      ActiveSupport::Dependencies.autoload_paths += %W( #{self.root}/vendor #{self.root}/app/mailers #{self.root}/app/helpers)
+      ActiveSupport::Dependencies.autoload_paths += %W( #{self.root}/app/controllers #{self.root}/app/models #{self.root}/app/portlets)
+      ActiveSupport::Dependencies.autoload_paths += %W( #{Rails.root}/app/portlets )
+      ActiveSupport::Dependencies.autoload_paths += %W( #{Rails.root}/app/presenters )
+      ActiveSupport::Dependencies.autoload_paths += %W( #{Rails.root}/app/portlets/helpers )
+      ActionController::Base.append_view_path DynamicView.base_path
+      ActionController::Base.append_view_path %W( #{self.root}/app/views)
+      require 'jdbc_adapter' if defined?(JRUBY_VERSION)
+    end
+
+    initializer 'browsercms.precompile_assets' do |app|
+      # Ensure all engine specific assets are compiled when rake asset:precompile is run.
+      app.config.assets.precompile += ['cms/page_toolbar.js', 'cms/page_editor.js', 'cms/site.js']
+
+      app.config.assets.precompile += ['cms/page_editor.css', 'cms/page_content_editing.css', 'cms/site.js']
+
+      # Ckeditor
+      app.config.assets.precompile += ['bcms/ckeditor_inline.js', 'bcms/ckeditor.js', 'bcms/ckeditor_standard_config.js']
+
+      # Unsure why jquery isn't getting precompiled.
+      app.config.assets.precompile += ['jquery']
+    end
+  end
+end

data/lib/cms/engine_helper.rb

@@ -0,0 +1,103 @@
+module Cms
+
+  class EngineAwarePathBuilder
+
+
+    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
+      else
+        path_subject.class
+      end
+    end
+
+    def build_preview(view)
+      path = []
+      path << engine_name
+      path << path_subject
+      path
+    end
+
+    def build(view)
+      path = []
+      path << engine(view)
+      path << path_subject
+      path
+
+    end
+
+    def main_app_model?
+      engine_name == "main_app"
+    end
+
+    # Determine which 'Engine' this model is from based on the class
+    def engine_name
+      model_class = subject_class.model_name
+      name = EngineAware.module_name(model_class)
+      return "main_app" unless name
+
+      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"
+      end
+      engine.engine_name
+    end
+
+
+    def engine_class
+      if main_app_model?
+        Rails.application
+      else
+        guess_engine_class(subject_class)
+      end
+    end
+
+    private
+
+    # Will raise NameError if klass::Engine doesn't exist.
+    def guess_engine_class(klass)
+      name = EngineAware.module_name(klass)
+      "#{name}::Engine".constantize
+    end
+
+    # 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
+    end
+
+    # 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
+
+
+  end
+
+  module EngineAware
+
+    # Finds the top level module for a given class.
+    # Cms::Thing -> Cms
+    # Thing -> nil
+    # Whatever::Thing -> Whatever
+    #
+    # @param [Class] klass
+    def self.module_name(klass)
+      names = klass.name.split("::")
+      return names.first if names.size > 1
+      nil
+    end
+  end
+end

data/lib/cms/error_handling.rb

@@ -0,0 +1,84 @@
+module Cms
+  module ErrorHandling
+    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_internal_access_denied
+      end
+    end
+
+    # Ensures the entire render stack applies a specific format
+    # For example, this allows missing jpg's to throw the proper error as opposed to 500
+    def with_format(format, &block)
+      old_formats = self.formats
+      self.formats = [format]
+      result = block.call
+      self.formats = old_formats
+      result
+    end
+
+    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 => status,
+               :locals => {:exception => exception}
+      end
+    end
+
+    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")}"
+      NotifierService.notify exception
+    end
+
+    class NotifierService
+      class << self
+        delegate :notify, :register_notifier_call,
+                 to: :service
+      end
+
+      def self.service
+        @service ||= new
+      end
+
+      attr_reader :notifiers
+
+      def initialize
+        @notifiers = []
+
+        autoload_notifiers
+      end
+
+      def notify(exception)
+        notifiers.each { |notifier| notifier.call exception }
+      end
+
+      def register_notifier_call(callable_object = nil, &block)
+        raise ArgumentError unless callable_object.respond_to?(:call) || block_given?
+        @notifiers << (callable_object || block)
+      end
+
+      private
+
+      def autoload_notifiers
+        autoload_airbrake_if_present
+      end
+
+      def autoload_airbrake_if_present
+        if defined?(::Airbrake)
+          register_notifier_call { |exception| ::Airbrake.notify exception }
+        end
+      end
+    end
+  end
+end

data/lib/cms/error_pages.rb

@@ -0,0 +1,8 @@
+module Cms
+  module ErrorPages
+
+    NOT_FOUND_PATH = '/system/not_found'
+    FORBIDDEN_PATH = '/system/access_denied'
+    SERVER_ERROR_PATH = '/system/server_error'
+  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_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/base.rb

@@ -0,0 +1,37 @@
+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
+
+      module ClassMethods
+        # Determines if the database for this Rails App exists yet. Useful for methods which might be called during
+        # rake tasks or initialize where a database not yet being created is not fatal, but should be ignored.
+        #
+        # @return [Boolean] false if it does not exist.
+        def database_exists?
+          begin
+            connection
+            return true
+          rescue StandardError # Hopefully this works with MySql, MySql2 and SQLite
+            logger.warn "Attempted to establish a connection with the database, but could not do so."
+            return false
+          end
+
+        end
+      end
+    end
+  end
+end
+ActiveRecord::Base.send(:include, Cms::Extensions::ActiveRecord::Base)
+ActiveRecord::Base.extend(Cms::Extensions::ActiveRecord::ClassMethods)
+
+

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

@@ -0,0 +1,94 @@
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module SchemaStatements
+
+      # Sticks :cms_ in front of a table name.
+      def cms_(table_name)
+        "cms_#{table_name}"
+      end
+
+      # Create a table and its versioned counterpart. Example:
+      #   create_content_table :cms_events
+      #   => :cms_events
+      #   => :cms_event_versions
+      #
+      # @param table_name [Symbol] The namespaced versioned of the content table (i.e. :cms_events or :bcms_news_articles)
+      # @param options
+      # @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,
+            name: true
+        }
+        options = defaults.merge(options)
+
+        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
+
+        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
+
+      def drop_content_table(table_name)
+        drop_table versioned_(table_name)
+        drop_table table_name
+      end
+
+      # 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 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 versioned_(table_name), column_name, type, options
+      end
+
+      def remove_content_column(table_name, column_name)
+        remove_column table_name, column_name
+        remove_column versioned_(table_name), column_name
+      end
+
+      protected
+
+      def versioned_(table_name)
+        "#{table_name.to_s.singularize}_versions".to_sym
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Cms
+  module Extensions
+    module ActiveModel
+      module Errors
+        def add_from_hash(errors)
+          errors.each{|k,v| add(k, v) } unless errors.blank?
+        end
+      end
+    end
+  end
+end
+ActiveModel::Errors.send(:include, Cms::Extensions::ActiveModel::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,11 @@
+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
+    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)

data/lib/cms/extensions/string.rb

@@ -0,0 +1,24 @@
+module Cms
+  module Extensions
+    module String
+      def indent(n=0)
+        (" "*n.to_i) + self 
+      end
+      def markdown
+        Cms.markdown? ? Markdown.new(self).to_html : "<strong>ERROR</strong>: Markdown Support Not Installed"   
+      end 
+      def to_slug
+        gsub(/\W+/, ' ').strip.downcase.gsub(/\ +/, '-')
+      end
+
+      # Allows for conditional pluralization of names where object counts are not singular.
+      #
+      # @param [Integer] count The number of objects of this string there are.
+      # @return [String] Plural of string, unless count == 1
+      def pluralize_unless_one(count=nil)
+        count == 1 ? self : ActiveSupport::Inflector.pluralize(self)
+      end
+    end
+  end
+end
+String.send(:include, Cms::Extensions::String)

data/lib/cms/extensions.rb

@@ -0,0 +1,5 @@
+# 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/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