browsercms 3.5.7 → 4.0.0.alpha

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/module.rb

@@ -19,12 +19,6 @@ module Cms
       # Make sure class in app/portlets are in the load_path
       portlets_dir = File.join("..", "..", "app", "portlets")
       base.config.autoload_paths << portlets_dir
-
-      base.initializer "browsercms.enable_serving_static_assets" do |app|
-        # Ensures it is loaded earlier, to avoid blank assets problem listed here: http://jonswope.com/2010/07/25/rails-3-engines-plugins-and-static-assets/
-        app.middleware.insert_before ::Rack::Lock, ::ActionDispatch::Static, "#{root}/public"
-      end
-
     end
 
     # This is a bit of a hack, but we need to store the current namespaces so that module developers can just write:
@@ -35,7 +29,7 @@ module Cms
     #
     # And have it correctly find the right namespaced class model (i.e. BcmsZoo::Bear)
     def routes
-      Module.current_namespace = ::Cms::EngineHelper.module_name(self.class)
+      Module.current_namespace = ::Cms::EngineAware.module_name(self.class)
       super
     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

@@ -4,26 +4,22 @@ 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 content_block, like :dogs or :donation_statuses
+  # @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)
-    content_name = content_block_name.to_s.classify
-    begin
-      content_block = "#{Cms::Module.current_namespace}::#{content_name}".constantize
-    rescue NameError
-      content_block = content_name.constantize
-    end
+    model_class = guess_model_class(content_block_name)
 
     resources content_block_name do
       member do
-        put :publish if content_block.publishable?
-        get :versions if content_block.versioned?
-        get :usages if content_block.connectable?
+        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
-
-    if content_block.versioned?
-      send("get", "/#{content_block_name}/:id/version/:version", :to=>"#{content_block_name}#version", :as=>"version_cms_#{content_block_name}".to_sym)
-      send("put", "/#{content_block_name}/:id/revert_to/:version", :to=>"#{content_block_name}#revert_to", :as=>"revert_to_cms_#{content_block_name}".to_sym)
     end
   end
 
@@ -37,14 +33,31 @@ module Cms::RouteExtensions
   #   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',
+               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'
+    end
+
     # Handle 'stock' attachments
-    match "/attachments/:id/:filename", :to=>"cms/attachments#download"
-    match "/", :to=>"cms/content#show"
-    match "*path", :to=>"cms/content#show"
+    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.
@@ -53,10 +66,89 @@ module Cms::RouteExtensions
 
   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.all(: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
+      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

data/lib/cms/version.rb

@@ -2,7 +2,7 @@
 # Allows the precise version of BrowserCMS to be determined programatically.
 #
 module Cms
-  VERSION = "3.5.7"
+  VERSION = "4.0.0.alpha"
 
   # Return the current version of the CMS.
   def self.version

data/lib/generators/browser_cms/demo_site/templates/demo.seeds.rb

@@ -128,7 +128,6 @@ create_page_template(:home_page,
   </style>
   </head>
   <body>
-  <%= cms_toolbar %>
     <%= render :partial => "partials/header"%>
       <div id="main">
   <div id="broad" class="wrapper">
@@ -172,7 +171,6 @@ create_page_template(:sub_page,
     <%= stylesheet_link_tag "/themes/blue_steel/stylesheets/style" %>
   </head>
   <body>
-    <%= cms_toolbar %>
       <%= render :partial => "partials/header"%>
       <div id="main">
         <div id="sub_nav" class="nav wrapper">

data/lib/generators/cms/content_block/content_block_generator.rb

@@ -1,4 +1,4 @@
-require 'rails/generators/active_record/migration'
+require 'rails/generators/migration'
 require 'rails/generators/resource_helpers'
 
 module Cms
@@ -12,22 +12,27 @@ module Cms
       include Rails::Generators::Migration
       include Rails::Generators::ResourceHelpers
 
+      def set_classpath
+        @in_core_application = false
+        unless namespaced?
+          cms_engine_module_name = Cms::EngineAware.module_name(Rails.application.class).constantize
+          Rails::Generators.namespace = cms_engine_module_name
+          @in_core_application = true
+        end
+      end
+
       hook_for :orm, :in => :rails, :required => true, :as => :model
 
       def alter_the_model
         model_file = File.join('app/models', class_path, "#{file_name}.rb")
         spaces = namespaced? ? 4 : 2
         insert_into_file model_file, indent("acts_as_content_block\n", spaces), :after => "ActiveRecord::Base\n"
+        insert_into_file model_file, indent("content_module :#{file_name.pluralize}\n", spaces), :after => "acts_as_content_block\n"
       end
 
       def alter_the_migration
         migration = self.class.migration_exists?(File.absolute_path("db/migrate"), "create_#{table_name}")
         gsub_file migration, "create_table", "create_content_table"
-        insert_into_file migration, :after => "def change\n" do
-          <<-RUBY
-    Cms::ContentType.create!(:name => "#{class_name}", :group_name => "#{group_name}")
-          RUBY
-        end
 
         # Attachments do not require a FK from this model to attachments.
         self.attributes.select { |attr| attr.type == :attachment }.each do |attribute|
@@ -36,9 +41,6 @@ module Cms
         self.attributes.select { |attr| attr.type == :attachments }.each do |attribute|
           gsub_file migration, "t.attachments :#{attribute.name}", ""
         end
-        unless class_name.starts_with?("Cms::")
-          gsub_file migration, " do |t|", ", :prefix=>false do |t|"
-        end
         self.attributes.select { |attr| attr.type == :category }.each do
           gsub_file migration, "t.category", "t.belongs_to"
         end
@@ -47,21 +49,22 @@ module Cms
         end
       end
 
-      hook_for :resource_controller, :in => :rails, :as => :controller, :required => true do |controller|
-        invoke controller, [namespaced_controller_name, options[:actions]]
+      hook_for :resource_controller, :in => :rails, :as => :controller, :required => true do |instance, controller|
+        instance.invoke controller, [instance.name.pluralize]
       end
 
+
       def create_controller_and_views
-        gsub_file File.join('app/controllers', cms_or_class_path, "#{file_name.pluralize}_controller.rb"), /ApplicationController/, "Cms::ContentBlockController"
-        template '_form.html.erb', File.join('app/views', cms_or_class_path, file_name.pluralize, "_form.html.erb")
-        template 'render.html.erb', File.join('app/views', cms_or_class_path, file_name.pluralize, "render.html.erb")
+        gsub_file File.join('app/controllers', class_path, "#{file_name.pluralize}_controller.rb"), /ApplicationController/, "Cms::ContentBlockController"
+        template '_form.html.erb', File.join('app/views', class_path, file_name.pluralize, "_form.html.erb")
+        template 'render.html.erb', File.join('app/views', class_path, file_name.pluralize, "render.html.erb")
       end
 
       def create_routes
-        if namespaced?
+        if namespaced? && !@in_core_application
           route "content_blocks :#{file_name.pluralize}"
         else
-          route "namespace :cms  do content_blocks :#{file_name.pluralize} end"
+          route "namespace :#{namespace.name.underscore} do content_blocks :#{file_name.pluralize} end"
         end
       end
 
@@ -74,36 +77,6 @@ module Cms
       def attachment_attributes
         self.attributes.select { |attr| attr.type == :attachment }
       end
-
-
-      def group_name
-        if namespaced?
-          class_name.split("::").first
-        else
-          class_name
-        end
-      end
-
-      def namespaced_controller_name
-        unless namespaced?
-          "cms/#{@controller_name}"
-        else
-          @controller_name
-        end
-      end
-
-      # Modules want to put classes under their namespace folders, i.e
-      #   - app/controllers/bcms_widgets/widget_controller
-      #
-      # while projects want to put it under cms
-      #   - app/controllers/cms/widget_controller
-      def cms_or_class_path
-        if namespaced?
-          class_path
-        else
-          ["cms"]
-        end
-      end
     end
   end
 end