browsercms-artirix 4.0.0.rc1.art4

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

data/lib/cms/form_builder/deprecated_inputs.rb

@@ -0,0 +1,40 @@
+module Cms
+  module FormBuilder
+    # These FormBuilder inputs are deprecated as of BrowserCMS v4.0 and will be remove in 4.1.
+    module DeprecatedInputs
+
+      # @deprecated Use <%= f.input :attribute_name %> instead.
+      def cms_text_field(method, options={})
+        method_deprecated_use_instead(:cms_text_field, "<%= f.input :#{method} %>")
+        input method, options
+      end
+
+      def cms_text_editor(method, options={})
+        method_deprecated_use_instead(:cms_text_editor, "<%= f.input :#{method}, as: :text_editor %>")
+        input method, options.merge(as: :text_editor)
+      end
+
+      def template_editor(method, options={})
+        method_deprecated_use_instead(:template_editor, "<%= f.input :#{method}, as: :template_editor %>")
+        input method, options.merge(as: :template_editor)
+      end
+
+      def cms_file_field(method, options={})
+        method_deprecated_use_instead(:cms_file_field, "<%= f.input :#{method}, as: :file_picker %>")
+        input method, options.merge(as: :file_picker)
+      end
+
+      def cms_drop_down(method, collection, options={})
+        method_deprecated_use_instead(:cms_drop_down, "<%= f.association :association_name %>")
+        input method, options.merge(collection: collection)
+      end
+
+      protected
+
+      def method_deprecated_use_instead(original, alternative)
+        full_message = "Calling <%= f.#{original.to_s} %> is deprecated and will be removed in BrowserCMS 4.1. Try instead #{alternative}"
+        ActiveSupport::Deprecation.warn(full_message, caller(3))
+      end
+    end
+  end
+end

data/lib/cms/form_builder/workflow_buttons.rb

@@ -0,0 +1,38 @@
+module Cms
+  module WorkflowButtons
+    def publish_button(*args, &block)
+      button_with_normalized_options(args, "Publish") do |options|
+        options[:class] << "btn-primary right"
+      end
+    end
+
+    def save_draft(*args, &block)
+      button_with_normalized_options(args, "Save Draft")
+    end
+
+    def save(*args, &block)
+      button_with_normalized_options(args, "Save") do |opts|
+        opts[:class] << "btn-primary right"
+      end
+    end
+
+    private
+
+    def normalize_location(options)
+      location = options.delete(:location)
+      if location == :top
+        options[:class] << 'btn-small'
+      end
+    end
+
+    def button_with_normalized_options(args, label, &block)
+      options = args.extract_options!.dup
+      normalize_location(options)
+      yield options if block_given?
+      args << options
+      args.unshift label
+      button(:submit, *args, &block)
+    end
+  end
+end
+SimpleForm::FormBuilder.send :include, Cms::WorkflowButtons

data/lib/cms/installation_actions.rb

@@ -0,0 +1,8 @@
+module Cms
+  module InstallationActions
+
+    def default_engine_path(module_name, path=nil)
+      "/#{module_name.name.underscore}"
+    end
+  end
+end

data/lib/cms/mobile_aware.rb

@@ -0,0 +1,67 @@
+module Cms
+
+  module MobileAware
+
+    include Cms::DefaultCaches
+
+    # Looks for a mobile template if the request is mobile, falling back to the html template if it can't be found.
+    #
+    # @return [String] relative path/name of the layout to be rendered by a page (i.e. 'layouts/templates/default')
+    def determine_page_layout
+      if respond_as_mobile?
+        mobile_exists = template_exists?(@page.layout_name, "layouts/mobile")
+        return @page.layout(:mobile) if mobile_exists
+      end
+      @page.layout(:full)
+    end
+
+    # This is changing a class attribute in order to write the page cache to a different directory based on mobile vs full page request.
+    # @warning - May not be thread safe?
+    def select_cache_directory
+      if respond_as_mobile?
+        self.class.page_cache_directory = mobile_cache_directory
+      else
+        self.class.page_cache_directory = cms_cache_directory
+      end
+    end
+
+    # Because of caching, CMS pages should only return mobile content on a separate subdomain.
+    # or if a CMS editor wants to see the mobile version of the page.
+    #
+    # @return [Boolean] true if this request is considered 'mobile', false otherwise
+    def respond_as_mobile?
+      log "For mobile optimization, checking the subdomain for '#{request.domain}' is '#{request.subdomain}'."
+      if params[:template] =='mobile'
+        session[:mobile_mode] = true
+      elsif params[:template] =='full'
+        session[:mobile_mode] = false
+      end
+
+      request.subdomain == "m" || (session[:mobile_mode] == true && current_user.able_to?(:edit_content))
+    end
+
+    private
+
+    def print_request_info
+      log "*" * 20
+      log "User Agent: #{request.user_agent}"
+      m = "Mobile Request?: "
+      if respond_as_mobile?
+        m += "Yes"
+      else
+        m += "No"
+      end
+      log m
+    end
+
+    def log(m)
+      logger.debug m
+    end
+
+    def banner(m)
+      log "*" * 20
+      log m
+    end
+  end
+
+end

data/lib/cms/module.rb

@@ -0,0 +1,36 @@
+require 'cms/engine_helper'
+
+module Cms
+
+  # All BrowserCMS modules will:
+  # 1. Add app/portlets to the loadpath
+  # 2. Serve static assets from their public directory.
+  module Module
+
+    def self.current_namespace=(ns)
+      @ns = ns
+    end
+
+    def self.current_namespace
+      @ns
+    end
+
+    def self.included(base)
+      # Make sure class in app/portlets are in the load_path
+      portlets_dir = File.join("..", "..", "app", "portlets")
+      base.config.autoload_paths << portlets_dir
+    end
+
+    # This is a bit of a hack, but we need to store the current namespaces so that module developers can just write:
+    #
+    # BcmsZoo::Engine.routes.draw do
+    #   <tt>content_blocks :bear</tt>
+    # end
+    #
+    # And have it correctly find the right namespaced class model (i.e. BcmsZoo::Bear)
+    def routes
+      Module.current_namespace = ::Cms::EngineAware.module_name(self.class)
+      super
+    end
+  end
+end

data/lib/cms/module_installation.rb

@@ -0,0 +1,31 @@
+require 'cms/installation_actions'
+
+# Provides a base class for Module installation generators.
+#
+# Usage:
+#
+#   require 'cms/module_installation'
+#   class MyModule::InstallGenerator < Cms::ModuleInstallation
+#     add_migrations_directory_to_source_root __FILE__
+#   end
+#
+class Cms::ModuleInstallation < Rails::Generators::Base
+  include Cms::InstallationActions
+
+  # This will be relative to the gem
+  # e.g. add_migrations_directory_to_source_root __FILE__
+  def self.add_migrations_directory_to_source_root(generator_file_object)
+    source_root File.expand_path('../../../../../db/migrate/', generator_file_object)
+  end
+
+  protected
+
+  # Adds a typical route for a Engine to a project.
+  #
+  # @param [String] module_name i.e. BcmsWhatever
+  # @param [String] path i.e. /bcms_whatever (Optional - Will be generated based off the module if not specified)
+  def mount_engine(module_name, path_name=nil)
+    path_name = default_engine_path(module_name) unless path_name
+    route "mount #{module_name}::Engine => '#{path_name}'"
+  end
+end

data/lib/cms/polymorphic_single_table_inheritance.rb

@@ -0,0 +1,19 @@
+module Cms
+  # Allows STI classes to be handled by a single resource controller
+  # i.e. LoginPortlet can be handled by the Cms::PortletController as a resource.
+  #
+  #
+  # This is a simpler version of this solution: https://gist.github.com/sj26/5843855
+  module PolymorphicSingleTableInheritance
+
+    # Override model_name to return base_class Name.
+    def model_name
+      if self == base_class
+        super
+      else
+        base_class.model_name
+      end
+    end
+
+  end
+end

data/lib/cms/publish_workflow.rb

@@ -0,0 +1,26 @@
+module Cms
+  # Can be added to controllers that allow for SaveDraft/Publish
+  module PublishWorkflow
+
+    def self.included(klass)
+      klass.send(:include, AllowPublishing)
+    end
+
+    module AllowPublishing
+      def self.included(klass)
+        klass.before_action :only => [:create, :update] do
+          params[resource_param][:publish_on_save] = false if save_draft?
+          params[resource_param][:publish_on_save] = true if publish?
+        end
+      end
+
+      def save_draft?
+        params[:commit] == "Save Draft"
+      end
+
+      def publish?
+        params[:commit] == "Publish"
+      end
+    end
+  end
+end

data/lib/cms/responders/content_responder.rb

@@ -0,0 +1,14 @@
+module Cms
+  class ContentResponder < ActionController::Responder
+
+    def initialize(controller, resources, options={})
+      @page = resources[0]
+      @page_layout = resources[1]
+      super(controller, resources, options)
+    end
+
+    def to_html
+      render :layout => @page_layout, :action => 'show'
+    end
+  end
+end

data/lib/cms/route_extensions.rb

@@ -0,0 +1,157 @@
+module Cms::RouteExtensions
+
+
+  # Adds all necessary routes to manage a new content type. Works very similar to the Rails _resources_ method, adding basic CRUD routes, as well as additional ones
+  #   for CMS specific routes (like versioning)
+  #
+  # @param [Symbol] content_block_name - The plural name of a new Content Type. Should match the name of the model_class, like :dogs or :donation_statuses
+  def content_blocks(content_block_name, options={}, & block)
+    model_class = guess_model_class(content_block_name)
+
+    resources content_block_name do
+      member do
+        put :publish if model_class.publishable?
+        if model_class.versioned?
+          get :versions
+          get 'version/:version', to: "#{content_block_name}#version", as: 'version'
+          put 'revert_to/:version', to: "#{content_block_name}#revert_to", as: 'revert'
+        end
+      end
+      collection do
+        put :update, to: "#{content_block_name}#bulk_update"
+      end
+    end
+  end
+
+  # Adds the routes required for BrowserCMS to function to a routes.rb file. Should be the last route in the file, as
+  # all following routes will be ignored.
+  #
+  # Usage:
+  #   YourAppName::Application.routes.draw do
+  #      match '/some/path/in/your/app' :to=>"controller#action''
+  #      mount_browsercms
+  #   end
+  #
+  def mount_browsercms
+
+    mount Cms::Engine => "/cms", :as => "cms"
+
+    add_page_routes_defined_in_database
+
+    # Add User management features
+    devise_for :cms_user,
+               class_name: Cms.user_class_name,
+               path: '',
+               skip: :password,
+               path_names: {sign_in: 'login'},
+               controllers: {sessions: 'cms/sites/sessions'}
+
+    devise_scope :cms_user do
+      get '/forgot-password' => "cms/sites/passwords#new", :as => 'forgot_password'
+      post '/forgot-password' => "cms/sites/passwords#create", as: 'cms_user_password'
+      get '/passwords/:id/edit' => "cms/sites/passwords#edit", as: 'edit_password'
+      put '/forgot-password' => "cms/sites/passwords#update", as: 'update_password'
+    end
+
+    # Handle 'stock' attachments
+    get "/attachments/:id/:filename", :to => "cms/attachments#download"
+    get "/", :to => "cms/content#show"
+
+    # Only need :POST to support  portlets that are acting like controllers.
+    # Ideally we could get rid of this need.
+    match "*path", :to => "cms/content#show", via: [:get, :post]
+  end
+
+  # Preserving for backwards compatibility with bcms-3.3.x and earlier.
+  # @deprecated
+  alias :routes_for_browser_cms :mount_browsercms
+
+  private
+
+  def guess_model_class(content_block_name)
+    content_name = content_block_name.to_s.classify
+    prefix = determine_model_prefix
+    begin
+      namespaced_model_name = "#{Cms::Module.current_namespace}::#{content_name}"
+      model_class = namespaced_model_name.constantize
+    rescue NameError
+      model_class = "#{prefix}#{content_name}".constantize
+    end
+    model_class
+  end
+
+  def determine_model_prefix
+    if @scope && @scope[:module]
+      "#{@scope[:module].camelize}::"
+    else
+      ""
+    end
+  end
+
+
+  # Define additional routes (in the main_app) that addressable content types need.
+  def add_routes_for_addressable_content_blocks
+    classes = Cms::Concerns::Addressable.classes_that_require_custom_routes
+    classes.each do |klass|
+      base_route_name = klass.name.demodulize.underscore.gsub("/", "_")
+      add_show_via_slug_route(base_route_name, klass)
+      add_inline_content_route(base_route_name, klass)
+    end
+  end
+
+  # I.e. /cms/forms/:id/inline
+  def add_inline_content_route(base_route_name, klass)
+    denamespaced_controller = klass.name.demodulize.pluralize.underscore
+    module_name = klass.name.deconstantize.underscore
+    inline_route_name = "#{base_route_name}_inline"
+    unless route_exists?(inline_route_name)
+      klass.content_type.engine_class.routes.prepend do
+        if klass.content_type.main_app_model?
+          namespace module_name do
+            inline_route(denamespaced_controller, inline_route_name, klass)
+          end
+        else
+          inline_route(denamespaced_controller, inline_route_name, klass)
+        end
+      end
+    end
+  end
+
+  def inline_route(denamespaced_controller, inline_route_name, klass)
+    begin
+      get "#{klass.path}/:id/inline", to: "#{denamespaced_controller}#inline", as: inline_route_name
+    rescue ArgumentError
+      # Because when you prepend a route, you can't easily determine if it has already been defined.
+      # This avoids the error when Cms::PageRoute.reload_routes is called.
+      Rails.logger.debug "Skipping readding existing route (probably during a route reload): get \"#{klass.path}/:id/inline\", to: \"#{denamespaced_controller}#inline\", as: #{inline_route_name}"
+    end
+  end
+
+  # I.e. /forms/:slug
+  def add_show_via_slug_route(base_route_name, klass)
+    slug_path = "#{klass.path}/:slug"
+    namespaced_controller = klass.name.underscore.pluralize
+    slug_path_name = "#{base_route_name}_slug"
+    # Add route to main application (By doing this here, we ensure all ContentBlock constants have already been load)
+    # Engines don't process their routes until after the main routes are created.
+    unless route_exists?(slug_path_name)
+      Rails.application.routes.prepend do
+        get slug_path, to: "#{namespaced_controller}#show_via_slug", as: slug_path_name
+      end
+    end
+  end
+
+  # Determine if a named route already exists, since Rails 4 will object if a duplicate named route is defined now.
+  # Otherwise in development, when routes are reloaded the CMS would throw errors.
+  def route_exists?(route_name)
+    Rails.application.routes.named_routes[route_name]
+  end
+
+  def add_page_routes_defined_in_database
+    if Cms::PageRoute.can_be_loaded?
+      Cms::PageRoute.order("#{Cms::PageRoute.table_name}.name").each do |r|
+        match r.pattern, :to => r.to, :as => r.route_name, :_page_route_id => r.page_route_id, :via => r.via, :constraints => r.constraints
+      end
+    end
+  end
+end

data/lib/cms/users_service.rb

@@ -0,0 +1,208 @@
+class Cms::UsersService
+
+  GUEST_LOGIN = 'guest'
+  GUEST_NAME  = 'Anonymous'
+
+  # dirty trick needed for compatibility issues
+  # https://amitrmohanty.wordpress.com/2014/01/20/how-to-get-current_user-in-model-and-observer-rails/
+  def self.current
+    Thread.current[:cms_user]
+  end
+
+  def self.current=(user)
+    Thread.current[:cms_user] = user
+  end
+
+  class << self
+    delegate :use_user, :use_guest_user, :guest_user, to: :service
+  end
+
+  def self.service
+    @service || reload_service
+  end
+
+  def self.reload_service
+    @service = new
+  end
+
+  def use_user(login)
+    self.class.current = user(login)
+  end
+
+  def use_guest_user
+    self.class.current = guest_user
+  end
+
+  def guest_user
+    guest_user.tap { |u| extend_user u }
+  end
+
+  private
+  def user(login)
+    load_user(login).tap do |user|
+      extend_user(user)
+    end
+  end
+
+  def extend_user(user)
+    user.send :extend, CmsUserCompatibilityModule unless user.try :cms_user_compatible?
+  end
+
+  def load_user(login)
+    Cms.user_class.where(Cms.user_key_field => login).first!
+  end
+
+  def load_guest_user
+    params = {
+      Cms.user_key_field  => GUEST_LOGIN,
+      Cms.user_name_field => GUEST_NAME
+    }
+
+    Cms.user_class.new(params).tap do |guest_user|
+      guest_user.send :extend, GuestUserModule
+    end
+  end
+
+  class GuestUserModule
+    def guest?
+      true
+    end
+
+    def readonly?
+      true
+    end
+
+    def cms_access?
+      false
+    end
+  end
+
+  module CmsUserCompatibilityModule
+
+    def cms_user_compatible?
+      true
+    end
+
+    def enable_able?
+      false
+    end
+
+    def disable_able?
+      false
+    end
+
+    def password_changeable?
+      false
+    end
+
+    def expired?
+      false
+    end
+
+    # add expected columns
+    def self.extended(base)
+      unless base.respond_to? :login
+        base.send :alias_method, :login, Cms.user_key_field.to_sym
+      end
+
+      unless base.respond_to? :full_name
+        base.send :alias_method, :full_name, Cms.user_name_field.to_sym
+      end
+    end
+
+    def guest?
+      false
+    end
+
+    # COLUMN based
+
+    def full_name_with_login
+      "#{full_name} (#{login})"
+    end
+
+    def full_name_or_login
+      if full_name.strip.present?
+        full_name
+      else
+        login
+      end
+    end
+
+
+    def permissions
+      @permissions ||= Cms::Permission.where(["#{self.class.table_name}.id = ?", id]).includes({ :groups => :users }).references(:users)
+    end
+
+    def viewable_sections
+      @viewable_sections ||= Cms::Section.where(["#{self.class.table_name}.id = ?", id]).includes(:groups => :users).references(:users)
+    end
+
+    def modifiable_sections
+      @modifiable_sections ||= Cms::Section.where(["#{self.class.table_name}.id = ? and #{GroupType.table_name}.cms_access = ?", id, true]).includes(:groups => [:group_type, :users]).references(:users, :groups)
+    end
+
+    # 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
+
+    # 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.parent
+      end
+      viewable_sections.include?(section) || cms_access?
+    end
+
+    def able_to_modify?(object)
+      case object
+      when Cms::Section
+        modifiable_sections.include?(object)
+      when Cms::Page, Cms::Link
+        modifiable_sections.include?(object.section)
+      else
+        if object.class.respond_to?(:connectable?) && object.class.connectable?
+          object.connected_pages.all? { |page| able_to_modify?(page) }
+        else
+          true
+        end
+      end
+    end
+
+    # Expects node to be a Section, Page or Link
+    # Returns true if the specified node, or any of its ancestor sections, is editable by any of
+    # the user's 'CMS User' groups.
+    def able_to_edit?(object)
+      able_to?(:edit_content) && able_to_modify?(object)
+    end
+
+    def able_to_publish?(object)
+      able_to?(:publish_content) && able_to_modify?(object)
+    end
+
+    def able_to_edit_or_publish_content?
+      able_to?(:edit_content, :publish_content)
+    end
+
+    def cms_access?
+      groups.cms_access.count > 0
+    end
+  end
+end

data/lib/cms/version.rb

@@ -0,0 +1,11 @@
+##
+# Allows the precise version of BrowserCMS to be determined programatically.
+#
+module Cms
+  VERSION = "4.0.0.rc1.art4"
+
+  # Return the current version of the CMS.
+  def self.version
+    VERSION
+  end
+end