nate-browsercms 3.0.210

data/lib/cms/behaviors/versioning.rb

@@ -0,0 +1,172 @@
+module Cms
+  module Behaviors
+    module Versioning
+      def self.included(model_class)
+        model_class.extend(MacroMethods)
+      end
+      module MacroMethods      
+        def versioned?
+          !!@is_versioned
+        end
+        def is_versioned(options={})
+          @is_versioned = true
+
+          @version_foreign_key = (options[:version_foreign_key] || "#{name.underscore}_id").to_s
+          @version_table_name = (options[:version_table_name] || "#{table_name.singularize}_versions").to_s
+        
+          extend ClassMethods
+          include InstanceMethods
+        
+          attr_accessor :version_comment        
+        
+          has_many :versions, :class_name  => version_class_name, :foreign_key => version_foreign_key
+        
+          before_save :build_new_version      
+        
+          #Define the version class
+          const_set("Version", Class.new(ActiveRecord::Base)).class_eval do 
+            class << self; attr_accessor :versioned_class end
+          
+            def versioned_class
+              self.class.versioned_class
+            end
+            def versioned_object_id
+              send("#{versioned_class.name.underscore}_id")
+            end
+            def versioned_object
+              send(versioned_class.name.underscore.to_sym)
+            end                 
+          end
+        
+          version_class.versioned_class = self
+        
+          version_class.belongs_to(name.underscore.to_sym, :foreign_key => version_foreign_key)
+        
+          version_class.is_userstamped if userstamped?
+        
+        end
+      end
+      module ClassMethods        
+        def version_class
+          const_get "Version"
+        end
+
+        def version_class_name
+          "#{name}::Version"
+        end        
+
+        def version_foreign_key
+          @version_foreign_key
+        end
+
+        def version_table_name        
+          @version_table_name
+        end
+
+        def versioned_columns
+          @versioned_columns ||= (version_class.new.attributes.keys - 
+            (%w[id lock_version position version_comment created_at updated_at created_by_id updated_by_id type] + [version_foreign_key]))
+        end                   
+      end
+      module InstanceMethods
+        def build_new_version
+          if build_new_version?
+            increment_version            
+            attrs = versioned_attributes
+            attrs[:version_comment] = @version_comment || default_version_comment
+            @version_comment = nil            
+            new_version = versions.build(attrs)
+
+            after_build_new_version(new_version) if respond_to?(:after_build_new_version)
+          end          
+          true
+        end
+
+        def build_new_version?
+          !!(new_record? || !@version_comment.blank? || self.class.versioned_columns.detect{|c| __send__ "#{c}_changed?" })
+        end    
+
+        def increment_version
+          self.version = version.to_i + 1
+        end            
+
+        def versioned_attributes
+          self.class.versioned_columns.inject({}){|attrs, col| attrs[col] = send(col); attrs }
+        end 
+
+        def default_version_comment
+          if new_record?
+            "Created"
+          else
+            "Changed #{(changes.keys - %w[version created_by_id updated_by_id]).sort.join(', ')}"
+          end
+        end          
+
+        def current_version?
+          self.class.find(id).version == version
+        end
+
+        def current_version
+          find_version(version)
+        end    
+
+        def find_version(number)
+          versions.first(:conditions => { :version => number })
+        end
+
+        def live_version
+          if self.class.publishable?    
+            live_version = versions.first(:conditions => {:published => true}, :order => "version desc, id desc")
+            live_version ? as_of_version(live_version.version) : nil
+          else
+            self
+          end
+        end        
+
+        def live_version?
+          live_version && version == live_version.version
+        end
+
+        def as_of_version(version)
+          v = find_version(version)
+          raise ActiveRecord::RecordNotFound.new("version #{version.inspect} does not exist for <#{self.class}:#{id}>") unless v
+          obj = self.class.new
+
+          (self.class.versioned_columns + [:version, :updated_at]).each do |a|
+            obj.send("#{a}=", v.send(a))
+          end
+          obj.id = id
+          obj.lock_version = lock_version
+          
+          #Need to do this so associations can be loaded
+          obj.instance_variable_set("@new_record", false)
+
+          #Callback to allow us to load other data when an older version is loaded
+          obj.after_as_of_version if obj.respond_to?(:after_as_of_version)
+
+          obj      
+        end
+
+        def revert
+          revert_to(version - 1) unless version == 1
+        end
+
+        def revert_to_without_save(version)
+          raise "Version parameter missing" if version.blank?
+          revert_to_version = find_version(version)
+          raise "Could not find version #{version}" unless revert_to_version
+          (self.class.versioned_columns - ["version"]).each do |a|
+            send("#{a}=", revert_to_version.send(a))
+          end  
+          self.version_comment = "Reverted to version #{version}"
+          self            
+        end    
+
+        def revert_to(version)
+          revert_to_without_save(version)
+          save
+        end                         
+      end
+    end
+  end
+end

data/lib/cms/behaviors.rb

@@ -0,0 +1,33 @@
+# Behaviors are used in CMS to add features to a model. 
+# They are very similar to the various "acts_as_*" or "*_fu" plugins/gems 
+# that have been created for Rails.  
+#
+# Generally, each behavior has three modules in it.  They are:
+# * MacroMethods
+# * ClassMethods
+# * InstanceMethods
+#
+# When the CMS starts up, all of the Behaviors are included into ActiveRecord::Base.
+# The MacroMethods module of each Behavior is also included into ActiveRecord::Base.
+# The MacroMethods module contains Class methods that you can call within your model
+# in order to enable that Behavior for that Class.  For example, if you want to have
+# an Article module that is taggable, you would do this:
+#
+#     class Article < ActiveRecord::Base
+#       is_taggable
+#     end
+#
+# So in this case, you are calling the `is_taggable` macro method, which enables the 
+# taggable behavior for the Article model.  It enables the behavior by extending the
+# ClassMethods module and including the InstanceMethods module into the Article class.
+# Each Behavior typically has one macro method which takes an options Hash, which of course
+# varies from Behavior to Behavior.  The macro method will also sometimes call other
+# macro methods, like before_fitler, named_scope, etc. to modify the model.
+# Consult the documentation for each module for specific details as to what
+# the Behavior does.
+module Cms::Behaviors; end
+
+Dir["#{File.dirname(__FILE__)}/behaviors/*.rb"].each do |b| 
+  require File.join("cms", "behaviors", File.basename(b, ".rb"))
+  ActiveRecord::Base.send(:include, "Cms::Behaviors::#{File.basename(b, ".rb").camelize}".constantize)
+end

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/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/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,63 @@
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module SchemaStatements
+      def create_versioned_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
+
+        t.integer :version
+        t.integer :lock_version, :default => 0
+        yield t
+        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)
+
+        #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    
+        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   
+         
+      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
+      
+    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/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/init.rb

@@ -0,0 +1,85 @@
+module Cms
+  class << self
+    __root__ = File.expand_path(File.join(File.dirname(__FILE__), "..", ".."))
+    define_method(:root) { __root__ }
+    
+    load File.join(__root__, "browsercms.gemspec")
+
+    def spec_version
+      SPEC.version.respond_to?(:parts) ? SPEC.version.parts : SPEC.version.ints
+    end
+
+    def version
+      @version = spec_version[0,3].join('.')
+    end
+    
+    def build_number
+      @build_number = spec_version.last
+    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
+    
+  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/fckeditor/**/*", 
+  "public/site/**/*",   
+  "public/stylesheets/cms/**/*", 
+  "public/images/cms/**/*",
+  "db/migrate/[0-9]*_*.rb") 

data/lib/cms/routes.rb

@@ -0,0 +1,131 @@
+module Cms::Routes
+  
+  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)
+    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})
+    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
+  
+  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.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}
+      end
+      
+      cms.email_page_portlet "/email_page_portlet/:id/deliver", 
+        :controller => "email_page_portlet", :action => "deliver", :conditions => {:method => :post}
+      
+      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"
+      end
+      cms.routes "/routes", :controller => "routes"
+      cms.resources :users, :member => {
+        :change_password => :get, 
+        :update_password => :put,
+        :disable => :put, 
+        :enable => :put
+      }
+      
+    end
+
+    image_missing '/images/*path', :controller => 'cms/missing_asset'
+    stylesheet_missing '/stylesheets/*path', :controller => 'cms/missing_asset'
+    javascript_missing '/javascripts/*path', :controller => 'cms/missing_asset'
+
+    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)
+      end
+    end
+
+    connect '*path', :controller => 'cms/content', :action => 'show'    
+  end
+end