browsercms-artirix 4.0.0.rc1.art4

data/lib/cms/configuration.rb

@@ -0,0 +1,79 @@
+require 'active_record/errors'
+
+# Used for some misc configuration around the project.
+module Cms
+
+  class << self
+
+    attr_accessor :attachment_file_permission
+
+    # Determines which WYSIWYG editor is the 'default' for a BrowserCMS project
+    #
+    # bcms modules can changes this by overriding it in their configuration.
+    # @return [String] The single javascript file to include to load the proper WYSIWYG editor.
+    def content_editor
+      # CKEditor is the default.
+      @wysiwig_editor ||= 'ckeditor'
+    end
+
+    def content_editor=(editor)
+      @wysiwig_editor = editor
+    end
+
+    def markdown?
+      Object.const_defined?("Markdown")
+    end
+
+    def reserved_paths
+      @reserved_paths ||= ["/cms", "/cache"]
+    end
+
+    # User Class
+    attr_writer :user_class_name
+    def user_class_name
+      @user_class_name ||= 'Cms::User'
+    end
+
+    def user_class
+      user_class_name.to_s.constantize
+    end
+
+    # User key
+    attr_writer :user_key_field
+    def user_key_field
+      @user_key_field ||= :login
+    end
+
+    # User name field
+    attr_writer :user_name_field
+    def user_name_field
+      @user_name_field ||= :full_name
+    end
+
+  end
+
+  module Errors
+    class AccessDenied < StandardError
+      def initialize
+        super("Access Denied")
+      end
+    end
+
+    # Indicates no content block could be found.
+    class ContentNotFound < ActiveRecord::RecordNotFound
+
+    end
+
+    # Indicates that no draft version of a given piece of content exists.
+    class DraftNotFound < ContentNotFound
+
+    end
+  end
+end
+
+Time::DATE_FORMATS.merge!(
+    :year_month_day => '%Y/%m/%d',
+    :date => '%m/%d/%Y'
+)
+
+

data/lib/cms/configure_simple_form.rb

@@ -0,0 +1,142 @@
+# Use this setup block to configure all options available in SimpleForm.
+SimpleForm.setup do |config|
+  # Wrappers are used by the form builder to generate a
+  # complete input. You can remove any component from the
+  # wrapper, change the order or even add your own to the
+  # stack. The options given below are used to wrap the
+  # whole input.
+  config.wrappers :default, class: :input,
+    hint_class: :field_with_hint, error_class: :field_with_errors do |b|
+    ## Extensions enabled by default
+    # Any of these extensions can be disabled for a
+    # given input by passing: `f.input EXTENSION_NAME => false`.
+    # You can make any of these extensions optional by
+    # renaming `b.use` to `b.optional`.
+
+    # Determines whether to use HTML5 (:email, :url, ...)
+    # and required attributes
+    b.use :html5
+
+    # Calculates placeholders automatically from I18n
+    # You can also pass a string as f.input placeholder: "Placeholder"
+    b.use :placeholder
+
+    ## Optional extensions
+    # They are disabled unless you pass `f.input EXTENSION_NAME => :lookup`
+    # to the input. If so, they will retrieve the values from the model
+    # if any exists. If you want to enable the lookup for any of those
+    # extensions by default, you can change `b.optional` to `b.use`.
+
+    # Calculates maxlength from length validations for string inputs
+    b.optional :maxlength
+
+    # Calculates pattern from format validations for string inputs
+    b.optional :pattern
+
+    # Calculates min and max from length validations for numeric inputs
+    b.optional :min_max
+
+    # Calculates readonly automatically from readonly attributes
+    b.optional :readonly
+
+    ## Inputs
+    b.use :label_input
+    b.use :hint,  wrap_with: { tag: :span, class: :hint }
+    b.use :error, wrap_with: { tag: :span, class: :error }
+  end
+
+  # The default wrapper to be used by the FormBuilder.
+  config.default_wrapper = :default
+
+  # Define the way to render check boxes / radio buttons with labels.
+  # Defaults to :nested for bootstrap config.
+  #   inline: input + label
+  #   nested: label > input
+  config.boolean_style = :nested
+
+  # Default class for buttons
+  config.button_class = 'btn'
+
+  # Method used to tidy up errors. Specify any Rails Array method.
+  # :first lists the first message for each field.
+  # Use :to_sentence to list all errors for each field.
+  # config.error_method = :first
+
+  # Default tag used for error notification helper.
+  config.error_notification_tag = :div
+
+  # CSS class to add for error notification helper.
+  config.error_notification_class = 'alert alert-error'
+
+  # ID to add for error notification helper.
+  # config.error_notification_id = nil
+
+  # Series of attempts to detect a default label method for collection.
+  # config.collection_label_methods = [ :to_label, :name, :title, :to_s ]
+
+  # Series of attempts to detect a default value method for collection.
+  # config.collection_value_methods = [ :id, :to_s ]
+
+  # You can wrap a collection of radio/check boxes in a pre-defined tag, defaulting to none.
+  # config.collection_wrapper_tag = nil
+
+  # You can define the class to use on all collection wrappers. Defaulting to none.
+  # config.collection_wrapper_class = nil
+
+  # You can wrap each item in a collection of radio/check boxes with a tag,
+  # defaulting to :span. Please note that when using :boolean_style = :nested,
+  # SimpleForm will force this option to be a label.
+  # config.item_wrapper_tag = :span
+
+  # You can define a class to use in all item wrappers. Defaulting to none.
+  # config.item_wrapper_class = nil
+
+  # How the label text should be generated altogether with the required text.
+  # config.label_text = lambda { |label, required| "#{required} #{label}" }
+
+  # You can define the class to use on all labels. Default is nil.
+  config.label_class = 'control-label'
+
+  # You can define the class to use on all forms. Default is simple_form.
+  # config.form_class = :simple_form
+
+  # You can define which elements should obtain additional classes
+  # config.generate_additional_classes_for = [:wrapper, :label, :input]
+
+  # Whether attributes are required by default (or not). Default is true.
+  # config.required_by_default = true
+
+  # Tell browsers whether to use the native HTML5 validations (novalidate form option).
+  # These validations are enabled in SimpleForm's internal config but disabled by default
+  # in this configuration, which is recommended due to some quirks from different browsers.
+  # To stop SimpleForm from generating the novalidate option, enabling the HTML5 validations,
+  # change this configuration to true.
+  config.browser_validations = false
+
+  # Collection of methods to detect if a file type was given.
+  # config.file_methods = [ :mounted_as, :file?, :public_filename ]
+
+  # Custom mappings for input types. This should be a hash containing a regexp
+  # to match as key, and the input type that will be used when the field name
+  # matches the regexp as value.
+  # config.input_mappings = { /count/ => :integer }
+
+  # Custom wrappers for input types. This should be a hash containing an input
+  # type as key and the wrapper that will be used for all inputs with specified type.
+  # config.wrapper_mappings = { string: :prepend }
+
+  # Default priority for time_zone inputs.
+  # config.time_zone_priority = nil
+
+  # Default priority for country inputs.
+  # config.country_priority = nil
+
+  # When false, do not use translations for labels.
+  # config.translate_labels = true
+
+  # Automatically discover new inputs in Rails' autoload path.
+  # config.inputs_discovery = true
+
+  # Cache SimpleForm inputs discovery
+  # config.cache_discovery = !Rails.env.development?
+end

data/lib/cms/configure_simple_form_bootstrap.rb

@@ -0,0 +1,58 @@
+# Use this setup block to configure all options available in SimpleForm.
+SimpleForm.setup do |config|
+  config.wrappers :bootstrap, tag: 'div', class: 'control-group row-fluid', error_class: 'error' do |b|
+    b.use :html5
+    b.use :placeholder
+    b.use :label
+    b.use :input
+    b.use :error, wrap_with: {tag: 'span', class: 'help-inline'}
+    b.use :hint, wrap_with: {tag: 'p', class: 'help-block'}
+  end
+
+  config.wrappers :browsercms, tag: 'div', class: 'control-group row-fluid', error_class: 'error' do |b|
+    b.use :html5
+    b.use :placeholder
+    b.use :label
+    b.use :input
+    b.use :error, wrap_with: {tag: 'span', class: 'help-inline'}
+    b.use :hint, wrap_with: {tag: 'p', class: 'help-block'}
+  end
+
+  config.wrappers :checkbox, :tag => 'div', :class => 'control-group row-fluid', :error_class => 'error' do |b|
+    b.use :html5
+    b.use :placeholder
+    b.use :label_input
+    b.use :hint, :wrap_with => {:tag => 'span', :class => 'help-block'}
+    b.use :error, :wrap_with => {:tag => 'span', :class => 'help-inline'}
+  end
+
+  config.wrapper_mappings = { :boolean => :checkbox }
+
+  config.wrappers :prepend, tag: 'div', class: "control-group", error_class: 'error' do |b|
+    b.use :html5
+    b.use :placeholder
+    b.use :label
+    b.wrapper tag: 'div', class: 'input-prepend' do |prepend|
+      prepend.use :input
+    end
+    b.use :hint, wrap_with: {tag: 'span', class: 'help-block'}
+    b.use :error, wrap_with: {tag: 'span', class: 'help-inline'}
+  end
+
+  config.wrappers :append, tag: 'div', class: "control-group", error_class: 'error' do |b|
+    b.use :html5
+    b.use :placeholder
+    b.use :label
+    b.wrapper tag: 'div', class: 'input-append' do |append|
+      append.use :input
+    end
+    b.use :hint, wrap_with: {tag: 'span', class: 'help-block'}
+    b.use :error, wrap_with: {tag: 'span', class: 'help-inline'}
+  end
+
+  # Wrappers for forms and inputs using the Twitter Bootstrap toolkit.
+  # Check the Bootstrap docs (http://twitter.github.com/bootstrap)
+  # to learn about the different styles for forms and inputs,
+  # buttons and other elements.
+  config.default_wrapper = :bootstrap
+end

data/lib/cms/content_filter.rb

@@ -0,0 +1,18 @@
+module Cms
+  class ContentFilter
+
+    # Strips HTML from any attribute that's not :content
+    #
+    # Handles CKEditor's habit of adding opening/closing <p> tags to everything.
+    # @TODO Have this inspect the underlying model to determine the actual attribute.
+    def filter(content)
+      c = content.clone
+      c.keys.each do |key|
+        if(key != :content && key != "content")
+          c[key] = HTML::FullSanitizer.new.sanitize(c[key]).strip
+        end
+      end
+      c
+    end
+  end
+end

data/lib/cms/content_page.rb

@@ -0,0 +1,77 @@
+module Cms
+
+  # Add to controllers to allow them to behave like pages. A newer version of Acts::ContentPage
+  module ContentPage
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :cms_template
+      layout :determine_layout
+      class_attribute :template_name
+      class_attribute :template_options
+
+      include Cms::Authentication::Controller
+      include Cms::PageHelper
+      helper Cms::PageHelper
+      helper Cms::RenderingHelper
+      helper Cms::MenuHelper
+      include Cms::Configuration::ConfigurableTemplate
+    end
+
+    module ClassMethods
+
+      # Specify which CMS template should be used for this controller. Works similarly to ActionController::Base#layout.
+      # Will use the named template from the appropriate directory (typically app/views/layouts/templates)
+      #
+      # The default CMS layout will be used if no template is specified.
+      #
+      # @example
+      #   template :subpage, only: [:new, :create]
+      #   template :subpage, except: [:new, :create]
+      #   template :subpage, only: [:new, :create]
+      #
+      # @param [Symbol] template_name Name of the template with no directory prefixes or file type. (i.e. subpage, homepage)
+      # @param [Hash] options (Optional)
+      # @option options [Array<Symbol>] :only The actions to apply the template to.
+      # @option options [Array<Symbol>] :exception The actions to not apply the template to.
+      def template(template_name, options={})
+        self.template_name = template_name.to_s
+        self.template_options = options
+      end
+
+    end
+
+    # Returns the page template that should be used to render this page.
+    def cms_template
+      "layouts/#{normalize_layout(self.class, self.class.template_name)}"
+    end
+
+    def content_page_layout
+      'cms/content_page'
+    end
+
+    protected
+
+    def template_options
+      self.class.template_options
+    end
+
+    def use_template?
+      if template_name.blank?
+        false
+      elsif template_options.empty?
+        true
+      elsif template_options[:only] && template_options[:only].include?(action_name.to_sym)
+        true
+      elsif template_options[:except] && !template_options[:except].include?(action_name.to_sym)
+        true
+      else
+        false
+      end
+    end
+
+    def determine_layout
+      use_template? ? content_page_layout : 'cms/application'
+    end
+  end
+end

data/lib/cms/content_rendering_support.rb

@@ -0,0 +1,114 @@
+require 'cms/error_handling'
+#
+# 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 ActiveRecord::RecordNotFound, :with => :handle_not_found_on_page
+      base.rescue_from Cms::Errors::ContentNotFound, :with => :handle_not_found_on_page
+      base.rescue_from Cms::Errors::DraftNotFound, :with => :handle_draft_not_found
+      base.rescue_from Cms::Errors::AccessDenied, :with => :handle_access_denied_on_page
+
+    end
+
+    def show_content_as_page(content)
+      @page = content # page templates expect a @page attribute
+      @content_block = content # render.html.erb's expect a @content_block attribute
+    end
+
+    def handle_draft_not_found(exception)
+      logger.warn "Draft Content Not Found"
+      render(:layout => 'cms/application',
+             :template => 'cms/content/no_page',
+             :status => :not_found)
+    end
+
+    def handle_not_found_on_page(exception)
+      logger.warn "Resource not found: Returning the 404 page."
+      handle_error_with_cms_page(Cms::ErrorPages::NOT_FOUND_PATH, exception, :not_found)
+    end
+
+    def handle_access_denied_on_page(exception)
+      logger.warn "Access denied for user '#{current_user.login}': Returning the 403 page."
+      handle_error_with_cms_page(Cms::ErrorPages::FORBIDDEN_PATH, exception, :forbidden)
+    end
+
+    def handle_server_error_on_page(exception)
+      logger.error "An Unexpected exception occurred: #{exception.message}\n"
+      logger.error "#{exception.backtrace.join("\n")}\n"
+      handle_error_with_cms_page(Cms::ErrorPages::SERVER_ERROR_PATH, 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, status) if cms_site?
+      else
+        return handle_server_error(exception, status) 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 = Cms::Page.find_live_by_path(error_page_path)
+        logger.debug "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
+
+        # The error pages are ALWAYS html since they are managed by the CMS as normal pages.
+        # So .gif or .jpg requests that throw errors will return html rather than a format warning.
+        render :layout => @page.layout, :template => 'cms/content/show', :status => status, :formats => [:html]
+      else
+        handle_server_error(exception, status)
+      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.current_connectors
+      @_connectables = @page.contents
+
+      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/controllers/admin_controller.rb

@@ -0,0 +1,78 @@
+module Cms
+
+  # Before for any controller that is considered an admin page within BrowserCMS.
+  module AdminController
+    extend ActiveSupport::Concern
+
+    included do
+      include Cms::Authentication::Controller
+      include Cms::ErrorHandling
+      include Cms::DomainSupport
+
+      helper Cms::ApplicationHelper
+      helper Cms::FormTagHelper
+      include Cms::PathHelper
+      helper Cms::PathHelper
+      include Cms::PageHelper
+      helper Cms::PageHelper
+      helper Cms::MenuHelper
+      helper Cms::RenderingHelper
+      helper Cms::UiElementsHelper
+      include Cms::NavMenuHelper
+
+    end
+
+    protected
+    def escape_javascript(javascript)
+      (javascript || '').gsub('\\', '\0\0').gsub('</', '<\/').gsub(/\r\n|\n|\r/, "\\n").gsub(/["']/) { |m| "\\#{m}" }
+    end
+
+    def redirect_to_first(*urls)
+      urls.each do |url|
+        unless url.blank?
+          return redirect_to(url)
+        end
+      end
+    end
+
+    def current_site
+      @current_site ||= Site.find_by_domain(request.host)
+    end
+
+    def redirect_to_cms_site
+      if using_cms_subdomains? && !request_is_for_cms_subdomain?
+        redirect_to(url_with_cms_domain_prefix)
+      end
+    end
+
+    def append_to_query_string(url, *params)
+      new_url = url["?"] ? url : "#{url}?"
+      new_url << params.map { |k, v| "#{k.to_s}=#{CGI::escape(v.to_s)}" }.join("&")
+    end
+
+    def cms_access_required
+      raise Cms::Errors::AccessDenied unless current_user.able_to?(:administrate, :edit_content, :publish_content)
+    end
+
+    def url_with_cms_domain_prefix
+      if cms_site?
+        request.url
+      elsif request.subdomains.first == "www"
+        request.url.sub(/www\./, "#{cms_domain_prefix}.")
+      else
+        request.url.sub(/:\/\//, "://#{cms_domain_prefix}.")
+      end
+    end
+
+    def url_without_cms_domain_prefix
+      request.url.sub(/#{cms_domain_prefix}\./, '')
+    end
+
+    def ensure_current_user_can_view(content)
+      unless current_user.able_to_view?(content)
+        store_location
+        raise Cms::Errors::AccessDenied
+      end
+    end
+  end
+end

data/lib/cms/data_loader.rb

@@ -0,0 +1,54 @@
+module Cms
+  # A DSL for creating CMS content in seed data. Creating content in this manner will log the creation of the record
+  # and store any created records in a hash.
+  # To use, add the following to your seeds.rb.
+  # require "cms/data_loader"
+  #
+  # @example Create a Page in the root section
+  #   create_page(:hello, name: "Hello", path: "/hello", parent: sections(:root))
+  #
+  # @example Lookup a previously created page
+  #   puts pages(:hello).name
+  module DataLoader
+
+    mattr_accessor :silent_mode
+
+    def method_missing(method_name, *args)
+      if md = method_name.to_s.match(/^create_(.+)$/)
+        klass = model_class(md[1])
+        self.create(klass.name, 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
+
+    # We search the CMS namespace first.
+    # for things like DynamicPortlets "Cms::DynamicPortlet".constantize returns "DynamicPortlet"
+    def model_class(model_name)
+      klass = begin
+        "Cms/#{model_name}".classify.constantize
+      rescue NameError => e
+        model_name.classify.constantize
+      end
+      unless klass.method_defined?(:save!)
+        raise "Can't create an instance of #{klass} because its not an ActiveRecord instance."
+      end
+      klass
+    end
+
+
+    def create(model_name, record_name, data={})
+      puts "-- create_#{model_name}(:#{record_name})" unless Cms::DataLoader.silent_mode
+      @data ||= {}
+      model_storage_name = model_name.demodulize.underscore.pluralize.to_sym
+      @data[model_storage_name] ||= {}
+      model = model_name.classify.constantize.new(data)
+      model.save!
+      @data[model_storage_name][record_name] = model
+    end
+  end
+end
+extend Cms::DataLoader

data/lib/cms/date_picker.rb

@@ -0,0 +1,23 @@
+module Cms
+
+
+  # Helper methods for centralizing Date handling for the CMS.
+  # Eventually, we will need a way to handle i18n formatting of dates, but I would also like to have US style dates
+  # for US locales (M/d/yy), but since Ruby 1.8.7 and 1.9.2 have different handling of Date.parse, that would take some
+  # monkeypatching.
+  #
+  class DatePicker
+
+    class << self
+
+      # Returns the date format that the JQuery selector will need to use.
+      def jquery_format
+        'yy/mm/dd'
+      end
+
+      def format_for_ui(date)
+        date ? date.strftime('%Y/%m/%d') : nil
+      end
+    end
+  end
+end

data/lib/cms/default_accessible.rb

@@ -0,0 +1,13 @@
+module Cms
+  module DefaultAccessible
+
+    def permitted_params
+      attribute_names.map{|string| string.to_sym} - non_permitted_params
+    end
+
+    def non_permitted_params
+      [:id, :type, :created_by_id, :updated_by_id, :created_at, :updated_at]
+    end
+
+  end
+end