bf4-browsercms 3.1.0

data/lib/cms/caching.rb

@@ -0,0 +1,20 @@
+module Cms
+  module Caching
+    def caching_enabled?
+      ActionController::Base.perform_caching
+    end
+    def flush_cache
+      #Hmmm...this is kinda scary.  What if page cache directory is
+      #set to the the default, which is /public?
+      #So we are going to check that the directory is not called "public"
+      if File.exists?(ActionController::Base.page_cache_directory) && 
+          File.basename(ActionController::Base.page_cache_directory) != "public"
+        FileUtils.rm_rf Dir.glob("#{ActionController::Base.page_cache_directory}/*")
+        Rails.logger.info "Cache Flushed"
+      end
+    end   
+  end
+  class << self
+    include Caching
+  end
+end

data/lib/cms/content_rendering_support.rb

@@ -0,0 +1,96 @@
+#
+# 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 Cms::Errors::AccessDenied, :with => :handle_access_denied_on_page
+      base.rescue_from ActiveRecord::RecordNotFound, :with => :handle_not_found_on_page
+    end
+
+    def handle_not_found_on_page(exception)
+      logger.warn "Page 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('/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('/system/server_error', 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) if cms_site?
+      else
+        return handle_server_error(exception) 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 = Page.find_live_by_path(error_page_path)
+        logger.info "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
+        render :layout => @page.layout, :template => 'cms/content/show', :status => status
+      else
+        handle_server_error(exception)
+      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.connectors.for_page_version(@page.version)
+      @_connectables = @_connectors.map(&:connectable_with_deleted)
+      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/data_loader.rb

@@ -0,0 +1,28 @@
+module Cms
+  module DataLoader
+    def method_missing(method_name, *args)
+      if md = method_name.to_s.match(/^create_(.+)$/)
+        begin
+          #Make sure this is an active record class
+          super unless md[1].classify.constantize.ancestors.include?(ActiveRecord::Base)
+        rescue NameError => e
+          super
+        end
+        self.create(md[1], 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
+    def create(model_name, record_name, data={})
+      puts "-- create_#{model_name}(:#{record_name})"
+      @data ||= {}
+      @data[model_name.pluralize.to_sym] ||= {}
+      model = model_name.classify.constantize.new(data)
+      model.save!
+      @data[model_name.pluralize.to_sym][record_name] = model
+    end
+  end
+end

data/lib/cms/domain_support.rb

@@ -0,0 +1,20 @@
+#
+# 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 cms_site?
+      subdomains = request.subdomains
+      subdomains.shift if subdomains.first == "www"
+      subdomains.first == cms_domain_prefix
+    end
+  end
+end

data/lib/cms/extensions.rb

@@ -0,0 +1,4 @@
+Dir["#{File.join(File.dirname(__FILE__), "extensions")}/**/*.rb"].each do |f| 
+  Rails.logger.info "~~ Loading extensions from #{f}"
+  require f
+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_record/base.rb

@@ -0,0 +1,16 @@
+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
+    end
+  end
+end
+ActiveRecord::Base.send(:include, Cms::Extensions::ActiveRecord::Base)

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

@@ -0,0 +1,88 @@
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module SchemaStatements
+
+      # Pass in ":versioned => false" in the options hash to create a non-versioned table.
+      def create_content_table(table_name, options={}, &block)
+
+        #Do the primary table
+        t = TableDefinition.new(self)
+        t.primary_key(options[:primary_key] || Base.get_primary_key(table_name)) unless options[:id] == false
+
+        unless options[:versioned] == false
+          t.integer :version
+          t.integer :lock_version, :default => 0
+        end
+
+        yield t
+
+        # Blocks currently must have a name column, otherwise the UI fails in several places.
+        # Some migrations may have already specified a name attribute, so we don't want to overwrite it here.
+        t.string :name unless t[:name]
+
+        t.boolean :published, :default => false
+        t.boolean :deleted, :default => false
+        t.boolean :archived, :default => false
+        t.integer :created_by_id
+        t.integer :updated_by_id
+        t.timestamps
+        
+        create_table_from_definition(table_name, options, t)
+
+        unless options[:versioned] == false
+          #Do the versions table
+          vt = TableDefinition.new(self)
+          vt.primary_key(options[:primary_key] || Base.get_primary_key(table_name)) unless options[:id] == false
+
+          vt.integer "#{table_name.to_s.singularize}_id".to_sym
+          vt.integer :version
+          yield vt
+
+          # Create implicit name column in version table as well.
+          vt.string :name unless vt[:name]
+
+          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
+
+          create_table_from_definition("#{table_name.to_s.singularize}_versions".to_sym, options, vt)
+        end
+        
+      end   
+
+      #
+      # @deprecated - create_versioned_table should be considered deprecated and may be removed in a future version.
+      # Use create_content_table instead in your migrations
+      #
+      alias :create_versioned_table :create_content_table
+
+      def create_table_from_definition(table_name, options, table_definition)
+        if options[:force] && table_exists?(table_name)
+         drop_table(table_name, options)
+        end
+
+        create_sql = "CREATE#{' TEMPORARY' if options[:temporary]} TABLE "
+        create_sql << "#{quote_table_name(table_name)} ("
+        create_sql << table_definition.to_sql
+        create_sql << ") #{options[:options]}"
+        execute create_sql            
+      end
+      
+      def drop_versioned_table(table_name)
+        drop_table "#{table_name.singularize}_versions".to_sym
+        drop_table table_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 "#{table_name.to_s.singularize}_versions".to_sym, column_name, type, options
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Cms
+  module Extensions
+    module ActiveRecord
+      module Errors
+        def add_from_hash(errors)
+          errors.each{|k,v| add(k, v) } unless errors.blank?
+        end
+      end
+    end
+  end
+end
+ActiveRecord::Errors.send(:include, Cms::Extensions::ActiveRecord::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,21 @@
+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
+      
+      # 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)
+        keys.inject({}) do |hash, key|
+          hash[key] = delete(key) if has_key?(key)
+          hash
+        end
+      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,19 @@
+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  
+      def pluralize(count=nil)
+        count == 1 ? self : ActiveSupport::Inflector.pluralize(self)
+      end
+    end
+  end
+end
+String.send(:include, Cms::Extensions::String)

data/lib/cms/init.rb

@@ -0,0 +1,100 @@
+module Cms
+  class << self
+    __root__ = File.expand_path(File.join(File.dirname(__FILE__), "..", ".."))
+
+    define_method(:root) { __root__ }
+
+    ::SPEC = eval(File.read(__root__ + '/browsercms.gemspec'))
+
+    attr_accessor :attachment_file_permission
+
+    def version
+      @version = SPEC.version.version
+    end
+    
+    def build_number; 252 end
+    
+    def load_rake_tasks
+      load "#{Cms.root}/lib/tasks/cms.rake"
+    end
+
+    # This is called after the environment is ready
+    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
+      
+      # This is jsut 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?
+    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.
+    def add_generator_paths(src_root, *files)
+      generator_paths << [src_root, files]
+    end
+    
+    def generator_paths
+      @generator_paths ||= []
+    end   
+    
+    def add_to_rails_paths(path)
+      ActiveSupport::Dependencies.load_paths << File.join(path, "app", "portlets")
+    end
+    
+    def markdown?
+      Object.const_defined?("Markdown")
+    end
+    
+    def reserved_paths
+      @reserved_paths ||= ["/cms", "/cache"]
+    end
+    
+    # This next 'hack' is to allow script/generate browser_cms to work on Windows machines. I'm not sure why this is necessary.
+    #
+    # This Generator is adding an absolute file path to the manifest, which is file (like a .js or migration) in
+    # the gem directory on the developers's machine, rather
+    # than just a relative path with the rails_generator directory. On windows, this will mean you are basically doing this.
+    #
+    # m.file "C:/Ruby/lib/ruby/gems/1.8/gems/browsercms-3.0.0/public/javascripts/jquery-ui.js", "testing/jquery-ui.js"
+    #
+    # When the generator hits this command during playback, it will throw an error like this:
+    #   Pattern 'c' matches more than one generator: content_block, controller
+    # The generator then fails and stops copying. Stripping the C: off the front seems to fix this problem.
+    # I.e. This command correctly copies the file on Windows XP.
+    #   m.file "/Ruby/lib/ruby/gems/1.8/gems/browsercms-3.0.0/public/javascripts/jquery-ui.js", "testing/jquery-ui.js"
+    #
+    def scrub_path(path)
+      windows_drive_pattern =  /\b[A-Za-z]:\//    # Works on drives labeled A-Z:
+      scrubbed_source_file_name = path.gsub(windows_drive_pattern, "/")
+    end
+  end
+  module Errors
+    class AccessDenied < StandardError
+      def initialize
+        super("Access Denied")
+      end
+    end
+  end
+end
+
+ActiveSupport::CoreExtensions::Time::Conversions::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")