browsercms 3.1.5 → 3.3.0.beta

data/lib/cms/content_rendering_support.rb

@@ -14,18 +14,18 @@ module Cms
 
     def handle_not_found_on_page(exception)
       logger.warn "Page Not Found"
-      handle_error_with_cms_page(Cms::ErrorPages::NOT_FOUND_PATH, exception, :not_found)
+      handle_error_with_cms_page('/system/not_found', exception, :not_found)
     end
 
     def handle_access_denied_on_page(exception)
       logger.warn "Access Denied"
-      handle_error_with_cms_page(Cms::ErrorPages::FORBIDDEN_PATH, exception, :forbidden)
+      handle_error_with_cms_page('/system/access_denied', exception, :forbidden)
     end
 
     def handle_server_error_on_page(exception)
       logger.warn "Exception: #{exception.message}\n"
       logger.warn "#{exception.backtrace.join("\n")}\n"
-      handle_error_with_cms_page(Cms::ErrorPages::SERVER_ERROR_PATH, exception, :internal_server_error)
+      handle_error_with_cms_page('/system/server_error', exception, :internal_server_error)
     end
 
     private

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

@@ -0,0 +1,46 @@
+#puts 'load engine'
+require 'rails'
+require 'cms/module'
+require 'cms/init'
+require 'browsercms'
+
+module Cms
+
+  # Configuring BrowserCMS as an engine. This seems to work, but could probably be cleaned up.
+  #
+  class Engine < Rails::Engine
+    include Cms::Module
+
+    Cms.add_generator_paths(Cms.root,
+                              "public/site/**/*",
+                              "db/seeds.rb")
+
+    config.action_view.javascript_expansions[:bcms_core] = ['jquery', 'jquery-ui', 'jquery.cookie.js', 'jquery.selectbox-0.5.js', 'jquery.taglist.js', Cms.wysiwig_js, 'cms/application']
+
+    initializer 'browsercms.add_core_routes', :after=>'action_dispatch.prepare_dispatcher' do |app|
+      Rails.logger.debug "Adding Cms::Routes to ActionDispatch"
+      ::Cms::Engine.add_cms_routes_method
+    end
+
+    initializer 'browsercms.add_load_paths', :after=>'action_controller.deprecated_routes' do |app|
+      Rails.logger.debug "Add Cms::Dependencies and other load_path configurations."
+      ::Cms::Engine.add_cms_load_paths
+    end
+
+    def self.add_cms_routes_method
+      ActionDispatch::Routing::Mapper.send :include, Cms::Routes
+    end
+
+    def self.add_cms_load_paths
+      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/portlets/helpers )
+      ActionController::Base.append_view_path DynamicView.base_path
+      ActionController::Base.append_view_path %W( #{self.root}/app/views)
+
+      ActionView::Base.default_form_builder = Cms::FormBuilder
+      require 'jdbc_adapter' if defined?(JRUBY_VERSION)
+    end
+  end
+end

data/lib/cms/extensions.rb

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

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

@@ -1,6 +1,6 @@
 module Cms
   module Extensions
-    module ActiveRecord
+    module ActiveModel
       module Errors
         def add_from_hash(errors)
           errors.each{|k,v| add(k, v) } unless errors.blank?
@@ -9,4 +9,4 @@ module Cms
     end
   end
 end
-ActiveRecord::Errors.send(:include, Cms::Extensions::ActiveRecord::Errors)
+ActiveModel::Errors.send(:include, Cms::Extensions::ActiveModel::Errors)

data/lib/cms/extensions/hash.rb

@@ -9,12 +9,14 @@ module Cms
       # 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
-      def extract!(*keys)
+      #
+      # 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
 end

data/lib/cms/extensions/string.rb

@@ -9,8 +9,13 @@ module Cms
       end 
       def to_slug
         gsub(/\W+/, ' ').strip.downcase.gsub(/\ +/, '-')
-      end  
-      def pluralize(count=nil)
+      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

data/lib/cms/init.rb

@@ -1,6 +1,4 @@
-# This avoids throwing Deprecation warnings for Rails 3 related issues which have already been fixed in the Rails 3 branch.
-# Remove when merged into BrowserCMS 3.3.x
-ActiveSupport::Deprecation.silenced = true
+require 'cms/version'
 
 module Cms
   class << self
@@ -19,38 +17,58 @@ module Cms
     end
 
     # This is called after the environment is ready
+    # This all needs to be moved to the Engine
     def init
-      ActionController::Routing::RouteSet::Mapper.send :include, Cms::Routes
-      ActiveSupport::Dependencies.load_paths += %W( #{RAILS_ROOT}/app/portlets )
-      ActiveSupport::Dependencies.load_paths += %W( #{RAILS_ROOT}/app/portlets/helpers )      
-      ActionController::Base.append_view_path DynamicView.base_path
-      ActionView::Base.default_form_builder = Cms::FormBuilder
+      puts "BrowserCMS init has been called!!!!!!!"
+
+      # ToDo: This is how we are adding new methods to the routes.rb file. Rails 3 might provide more direct way.
+     # ActionDispatch::Routing::Mapper.send :include, Cms::Routes
+
+      #need to add gem's app directories to the load path - 
+      #the list is taken from what rails has automagically added to $: for the Rails.root dirs
+#      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/portlets/helpers )
+#      ActionController::Base.append_view_path DynamicView.base_path
+#      ActionController::Base.append_view_path %W( #{self.root}/app/views)
+
+#      ActionView::Base.default_form_builder = Cms::FormBuilder
       
       # ActiveRecord JDBC adapter depends on no database connection having
       # been established to work properly.
-      require 'jdbc_adapter' if defined?(JRUBY_VERSION)
+#      require 'jdbc_adapter' if defined?(JRUBY_VERSION)
       
       # This is just to be safe
       # dynamic views are stored in a tmp dir
       # so they could be blown away on a server restart or something
       # so this just makes sure they get written out
-      DynamicView.write_all_to_disk! if DynamicView.table_exists?
+
+      # Commenting out, as the app/model files don't seem to have been loaded yet at this point, so
+      # we are getting class errors w/ STI.
+
+#      DynamicView.write_all_to_disk! if DynamicView.table_exists?
     end
     
     # This is used by CMS modules to register with the CMS generator
     # which files should be copied over to the app when the CMS generator is run.
     # src_root is the absolute path to the root of the files,
     # then each argument after that is a Dir.glob pattern string.
+    #
+    # @param [String] src_root The root directory of the gem
+    # @param [Array of String] files A list of all file names to be copied
     def add_generator_paths(src_root, *files)
       generator_paths << [src_root, files]
     end
-    
+
+    alias_method :add_paths_to_copied_into_project, :add_generator_paths
+
     def generator_paths
       @generator_paths ||= []
     end   
     
     def add_to_rails_paths(path)
-      ActiveSupport::Dependencies.load_paths << File.join(path, "app", "portlets")
+      ActiveSupport::Dependencies.autoload_paths << File.join(path, "app", "portlets")
     end
 
     def add_to_routes(route)
@@ -104,16 +122,9 @@ module Cms
   end
 end
 
-ActiveSupport::CoreExtensions::Time::Conversions::DATE_FORMATS.merge!(
+Time::DATE_FORMATS.merge!(
 	:year_month_day => '%Y/%m/%d',
 	:date => '%m/%d/%Y'	
 )
 
-Cms.add_generator_paths(Cms.root, 
-  "public/javascripts/jquery*",
-  "public/javascripts/cms/**/*",
-  "public/bcms/ckeditor/**/*",
-  "public/site/**/*",   
-  "public/stylesheets/cms/**/*",
-  "public/images/cms/**/*",
-  "db/migrate/[0-9]*_*.rb")
+

data/lib/cms/module.rb

@@ -0,0 +1,22 @@
+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.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
+
+      base.initializer "browsercms.enable_serving_static_assets" do |app|
+        app.middleware.use ::ActionDispatch::Static, "#{root}/public"
+      end
+
+    end
+
+
+  end
+end

data/lib/cms/module_installation.rb

@@ -0,0 +1,38 @@
+# Provides a base class for Module installation generators.
+#
+# This strategy assumes that modules will subclass this, and copy files from their db/migrate directory.
+# Usage:
+#
+#   require 'cms/module_installation'
+#   class MyModule::InstallGenerator < Cms::ModuleInstallation
+#     add_migrations_directory_to_source_root __FILE__
+#     copy_migration_file 'DATE_STAMP_create_some_block_name.rb'
+#   end
+#
+class Cms::ModuleInstallation < Rails::Generators::Base
+
+  # 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
+
+  # Add a migration file to the list of files to be copied from this gem into the project.
+  def self.copy_migration_file(name_of_file)
+    @migration_files = [] unless @migration_files
+    @migration_files << name_of_file
+  end
+
+  def self.migration_files
+    @migration_files
+  end
+
+  def copy_migrations_to_project
+    if self.class.migration_files
+      self.class.migration_files.each do |file_name|
+        copy_file file_name, "db/migrate/#{file_name}"
+      end
+    end
+  end
+
+end

data/lib/cms/routes.rb

@@ -1,136 +1,148 @@
 module Cms::Routes
 
+
+  # 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)
   #
-  # content_block_name - Should be a plural symbol matching the name of the content_block, like :dogs or donation_statuses
-  #
-  def content_blocks(content_block_name, options={}, &block)
+  # @params [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
+  def content_blocks(content_block_name, options={}, & block)
     content_block = content_block_name.to_s.classify.constantize
-    resources(*[content_block_name, default_routes_for_content_block(content_block).deep_merge(options)], &block)
+    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?
+      end
+    end
     if content_block.versioned?
-      # I'm not sure why, but these named routes 
-      # don't end up getting nested in the CMS namepace.
-      # So for now I'm just hard-coding the stuff related to the CMS namespace
-      send("version_cms_#{content_block_name}".to_sym, 
-        "/cms/#{content_block_name}/:id/version/:version",
-        :controller => "cms/#{content_block_name}",
-        :action => "version",
-        :conditions => {:method => :get})
-      send("revert_to_cms_#{content_block_name}".to_sym, 
-        "/cms/#{content_block_name}/:id/revert_to/:version",
-        :controller => "cms/#{content_block_name}",
-        :action => "revert_to",
-        :conditions => {:method => :put})
+      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
-  
-  def default_routes_for_content_block(content_block)
-    member_routes = {}
-    member_routes[:publish] = :put if content_block.publishable?
-    member_routes[:versions] = :get if content_block.versioned?
-    member_routes[:usages] = :get if content_block.connectable?    
-    {:member => member_routes}
-  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''
+  #      routes_for_browser_cms
+  #   end
+  #
   def routes_for_browser_cms
 
-    namespace(:cms) do |cms|
-      
-      cms.home '/', :controller => 'home'
-      
-      cms.logout '/logout', :controller => 'sessions', :action => 'destroy'
-      cms.login '/login', :controller => 'sessions', :action => 'new', :conditions => { :method => :get }
-      cms.connect '/login', :controller => 'sessions', :action => 'create', :conditions => { :method => :post }      
-      cms.dashboard '/dashboard', :controller => 'dashboard'
-      cms.sitemap '/sitemap', :controller => 'section_nodes'
-
-      cms.content_types '/content_types', :controller => 'content_types'
-      cms.resources :connectors, :member => {
-        :move_up => :put,
-        :move_down => :put,
-        :move_to_bottom => :put,
-        :move_to_top => :put
-      }
-      cms.resources :links
-
-      cms.resources :pages, :member => {
-        :archive => :put,
-        :hide => :put,
-        :publish => :put,
-        :versions => :get
-      }, :collection => {
-        :publish => :put
-      }, :has_many => [:tasks]
-      version_cms_page '/cms/pages/:id/version/:version', :controller => 'cms/pages', :action => 'version', :conditions => {:method => :get}
-      revert_to_cms_page '/cms/pages/:id/revert_to/:version', :controller => 'cms/pages', :action => 'revert_to', :conditions => {:method => :put}
-
-      cms.file_browser '/sections/file_browser.xml', :controller => 'sections', :action => 'file_browser', :format => "xml"
-      cms.resources :sections, :has_many => [:links, :pages]
-
-      cms.resources :section_nodes, :member => {
-        :move_before => :put,
-        :move_after => :put,
-        :move_to_beginning => :put,
-        :move_to_end => :put,
-        :move_to_root => :put
-      }
-      cms.attachment '/attachments/:id', :controller => 'attachments', :action => 'show'
-
-      cms.resources :tasks, :member => {:complete => :put}, :collection => {:complete => :put}
-      cms.toolbar '/toolbar', :controller => 'toolbar'
-      
-      # TODO: Make an actual content library controller 
-      # that redirects to the last content type you were working on
-      cms.content_library '/content_library', :controller => 'html_blocks' 
-      
-      cms.content_blocks :html_blocks
-      cms.content_blocks :portlets, :member => {:usages => :get}
-      cms.handler "/portlet/:id/:handler", 
-        :controller => "portlet", 
-        :action => "execute_handler", 
-        :conditions => {:method => :post}
-      
-      cms.content_blocks :file_blocks
-      cms.content_blocks :image_blocks
-      cms.content_blocks :category_types
-      cms.content_blocks :categories
-      cms.content_blocks :tags
-      
-      cms.administration '/administration', :controller => 'users'
-      
-      cms.with_options :controller => "cache" do |cache|
-          cache.cache "/cache", :action => "show", :conditions => {:method => :get}
-        cache.connect "/cache", :action => "destroy", :conditions => {:method => :delete}
+    namespace :cms do
+
+      match '/dashboard', :to=>"dashboard#index", :as=>'dashboard'
+      match '/', :to => 'home#index', :as=>'home'
+      match '/sitemap', :to=>"section_nodes#index", :as=>'sitemap'
+      match '/content_library', :to=>"html_blocks#index", :as=>'content_library'
+      match '/administration', :to=>"users#index", :as=>'administration'
+      match '/logout', :to=>"sessions#destroy", :as=>'logout'
+      get '/login', :to=>"sessions#new", :as=>'login'
+      post '/login', :to=>"sessions#create"
+
+      match '/toolbar', :to=>"toolbar#index", :as=>'toolbar'
+      match '/content_types', :to=>"content_types#index", :as=>'content_types'
+
+      resources :connectors do
+        member do
+          put :move_up
+          put :move_down
+          put :move_to_bottom
+          put :move_to_top
+        end
+      end
+      resources :links
+
+      resources :pages do
+        member do
+          put :archive
+          put :hide
+          put :publish
+          get :versions
+        end
+        collection do
+          put :publish
+        end
+        resources :tasks
       end
-            
-      cms.resources :email_messages
-      cms.resources :groups
-      cms.resources :redirects
-      cms.resources :page_partials, :controller => 'dynamic_views'
-      cms.resources :page_templates, :controller => 'dynamic_views'
-      cms.resources :page_routes do |pr|
-        pr.resources :conditions, :controller => "page_route_conditions"
-        pr.resources :requirements, :controller => "page_route_requirements"
+      get '/pages/:id/version/:version', :to=>'pages#version', :as=>'version_cms_page'
+      put '/pages/:id/revert_to/:version', :to=>'pages#revert_to', :as=>'revert_to_cms_page'
+      resources :tasks do
+        member do
+          put :complete
+        end
+        collection do
+          put :complete
+        end
       end
-      cms.routes "/routes", :controller => "routes"
-      cms.resources :users, :member => {
-        :change_password => :get, 
-        :update_password => :put,
-        :disable => :put, 
-        :enable => :put
-      }
-      
-      if RAILS_ENV == "test" && File.expand_path(RAILS_ROOT) == File.expand_path(File.dirname(__FILE__) + "/../..")
-        cms.content_blocks :content_block
+      match '/sections/file_browser.xml', :to => 'sections#file_browser', :format => "xml", :as=>'file_browser'
+      resources :sections do
+        resources :links, :pages
       end
-      
+
+      resources :section_nodes do
+        member do
+          put :move_before
+          put :move_after
+          put :move_to_beginning
+          put :move_to_end
+          put :move_to_root
+        end
+      end
+      match '/attachments/:id', :to => 'attachments#show', :as=>'attachment'
+
+      match '/content_library', :to=>'html_blocks#index', :as=>'content_library'
+      content_blocks :html_blocks
+      content_blocks :portlets
+      post '/portlet/:id/:handler', :to=>"portlet#execute_handler"
+
+      content_blocks :file_blocks
+      content_blocks :image_blocks
+      content_blocks :category_types
+      content_blocks :categories
+      content_blocks :tags
+
+      match '/administration', :to => 'users#index', :as=>'administration'
+
+      resources :users do
+        member do
+          get :change_password
+          put :update_password
+          put :disable
+          put :enable
+        end
+      end
+      resources :email_messages
+      resources :groups
+      resources :redirects
+      resources :page_partials, :controller => 'dynamic_views'
+      resources :page_templates, :controller => 'dynamic_views'
+      resources :page_routes do
+        resources :conditions, :controller => "page_route_conditions"
+        resources :requirements, :controller => "page_route_requirements"
+      end
+      get 'cache', :to=>'cache#show', :as=>'cache'
+      delete 'cache', :to=>'cache#destroy'
+
+      # This is only for testing, and should be moved to the config/routes.rb file eventually.
+#      content_blocks :sample_blocks
+
+      match  "/routes", :to => "routes#index", :as=>'routes'
+
     end
 
+    # Loads all Cms PageRoutes from the database
+    # TODO: Needs a integration/functional level test to verify that a page route w/ constraints will be correctly mapped.
     if PageRoute.table_exists?
       PageRoute.all(:order => "page_routes.name").each do |r|
-        send((r.route_name || 'connect').to_sym, r.pattern, r.options_map)
+        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
 
-    connect '*path', :controller => 'cms/content', :action => 'show'    
+    match "/", :to=>"cms/content#show"
+    match "*path", :to=>"cms/content#show"
   end
+
 end