browsercmsi 3.1.0

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,118 @@
+module Cms
+  class << self
+    __root__ = File.expand_path(File.join(File.dirname(__FILE__), "..", ".."))
+
+    define_method(:root) { __root__ }
+
+    ::SPEC = eval(File.read(__root__ + '/browsercmsi.gemspec'))
+
+    attr_accessor :attachment_file_permission
+
+    def version
+      @version = SPEC.version.version
+    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
+      
+      # ActiveRecord JDBC adapter depends on no database connection having
+      # been established to work properly.
+      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?
+    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 add_to_routes(route)
+      routes << route
+    end
+    def routes
+      @routes ||=[]
+    end
+
+    def wysiwig_js
+      @wysiwig_js ||= ['/bcms/ckeditor/ckeditor.js', '/bcms/ckeditor/editor.js']
+    end
+
+    def wysiwig_js=(path_array)
+      @wysiwig_js = path_array
+    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",
+  "config/locales/bcms/**/*")

data/lib/cms/routes.rb

@@ -0,0 +1,140 @@
+module Cms::Routes
+
+  #
+  # 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)
+    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.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}
+      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"
+      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
+      end
+      
+      cms.locale "/locale", :controller => "locales" if Rails.env.development?
+      
+    end
+
+    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 "/jslocales", :controller => "cms/locales", :action => "jslocales"
+
+    connect '*path', :controller => 'cms/content', :action => 'show'    
+  end
+end

data/lib/cms/version.rb

@@ -0,0 +1,6 @@
+##
+# Allows the precise version of BrowserCMS to be determined programmatically.
+#
+module Cms
+  VERSION = "3.1.0"
+end

data/lib/command_line.rb

@@ -0,0 +1,39 @@
+class CommandLine
+
+  # Sets the correct Rails application to use.
+  # -m demo -> Becomes the /path/to/browsercms/gem/templates/demo.rb
+  # -m module -> Becomes the /path/to/browsercms/gem/templates/modeule.rb
+  # If blank, becomes the /path/to/browsercms/gem/templates/blank.rb
+  def self.set_template(args)
+    if args.include?("-m")
+      index = args.index("-m")
+      if args[index + 1] == "demo"
+        args[index + 1] = template("demo.rb")
+      elsif args[index+1] == "module"
+        args[index + 1] = template("module.rb")
+      end
+    elsif args.include?("--template")
+      index = args.index("--template")
+      if args[index + 1] == "demo"
+        args[index + 1] = template("demo.rb")
+      elsif args[index+1] == "module"
+        args[index + 1] = template("module.rb")
+      end
+    else
+      args << "-m" << template("blank.rb")
+    end
+
+  end
+
+  # Return the directory where the BrowserCMS templates reside.
+  def self.template_dir
+    current_file = File.expand_path(File.dirname(__FILE__))
+    gem_dir = File.join(current_file, "..")
+    template_dir = File.join(gem_dir, "templates")
+  end
+
+  # Return the file for the given template.
+  def self.template(file_name)
+    File.join(template_dir, file_name)
+  end
+end

data/lib/initial_data.rb

@@ -0,0 +1,30 @@
+class InitialData
+  
+  extend Cms::DataLoader
+  
+  #Fixture-like way of creating initial data, except that it actually calls the real model methods
+  #This way things like acts_as_list and versioning get setup properly for these records
+  #The syntax is that you call create_whatever(:something, ...), where whatever is the model name,
+  #something is the identifier you give this record, and the ... is the hash of options to pass
+  #to the model constructor.  By calling the create_ method, you can then refer to the record later
+  #in the same way you would with fixtures, by saying whatevers(:something)
+  def self.load_demo
+    eval open("#{Rails.root}/db/demo/data.rb"){|f| f.read}
+    
+    Dir["#{Rails.root}/db/demo/page_partials/*.erb"].map do |f|
+      name, format, handler = File.basename(f).split('.')
+      create_page_partial(name.to_sym, 
+        :name => name, :format => format, :handler => handler,
+        :body => open(f){|f| f.read})
+    end
+    
+    Dir["#{Rails.root}/db/demo/page_templates/*.erb"].map do |f|
+      name, format, handler = File.basename(f).split('.')
+      create_page_template(name.to_sym, 
+        :name => name, :format => format, :handler => handler,
+        :body => open(f){|f| f.read})
+    end
+    
+  end
+  
+end

data/lib/sequence.rb

@@ -0,0 +1,6 @@
+class Sequence
+  @current_value = 0
+  def self.next
+    @current_value += 1
+  end
+end

data/lib/tasks/cms.rake

@@ -0,0 +1,41 @@
+namespace :test do
+  Rake::TestTask.new(:all => "db:test:prepare") do |t|
+    t.libs << "test"
+    t.pattern = 'test/**/*_test.rb'
+    t.verbose = true
+  end
+  Rake::Task['test:all'].comment = "Run all tests at once"
+end
+
+# When Jeweler builds the gem, make sure the guides are also rebuilt.
+task :build => ['cms:guides']
+
+namespace :cms do
+  
+  desc "Generate guides for the CMS"
+  task :guides do
+    require 'rubygems'
+
+    gem "actionpack", '>= 2.3'
+    require "action_controller"
+    require "action_view"
+
+    gem 'RedCloth', '>= 4.1.1'
+    require 'redcloth'
+
+    $: << File.join(File.dirname(__FILE__), '../../doc/guides')
+
+    module CmsGuides
+      autoload :Generator, "cms_guides/generator"
+      autoload :Indexer, "cms_guides/indexer"
+      autoload :Helpers, "cms_guides/helpers"
+      autoload :TextileExtensions, "cms_guides/textile_extensions"
+      autoload :Levenshtein, "cms_guides/levenshtein"
+    end
+
+    RedCloth.send(:include, CmsGuides::TextileExtensions)
+
+    CmsGuides::Generator.new.generate
+
+  end
+end

data/lib/tasks/db.rake

@@ -0,0 +1,71 @@
+require 'find'
+
+namespace :db do
+
+  desc "Drop, create and migrate the database"
+  task :redo => ["db:drop", "db:create", "db:migrate"]
+  
+  namespace :fixtures do
+    desc 'Dumps all models into fixtures.'
+    task :dump => :environment do
+      models = []
+      Find.find(RAILS_ROOT + '/app/models') do |path|
+        unless File.directory?(path) then models << path.match(/(\w+).rb/)[1] end
+      end
+  
+      models -= %w[content_observer guest_user file_block image_block email_message_mailer]
+  
+      puts "Models: " + models.join(', ')
+      
+      models.each do |m|
+        model = m.tableize.classify.constantize
+        create_fixture(model)
+        create_fixture(model.version_class) if model.versioned?
+      end
+    end
+    
+    def create_fixture(model)
+      puts "Creating fixture for #{model.table_name}"
+      entries = model.find(:all, :order => 'id ASC')
+      
+      formatted, increment, tab = '', 1, '  '
+      entries.each do |a|
+        formatted += model.table_name.singularize + '_' + increment.to_s + ':' + "\n"
+        increment += 1
+        
+        a.attributes.each do |column, value|
+          formatted += tab
+          
+          match = value.to_s.match(/\n/)
+          if match
+            formatted += column + ': |' + "\n"
+            
+            value.to_a.each do |v|
+              formatted += tab + tab + v
+            end
+          else
+            formatted += column + ': ' + value.to_s
+          end
+          
+          formatted += "\n"
+        end
+                  
+        formatted += "\n"
+      end
+    
+      model_file = RAILS_ROOT + '/test/fixtures/' + model.table_name + '.yml'
+      
+      # Final munging of file
+      formatted = "# auto-generated by rake db:fixtures:dump, DO NOT EDIT BY HAND!\n#{formatted}"
+      
+      # Scrub ERB
+      formatted.gsub!('<% ', ',<%% ')
+      formatted.gsub!('<%= ', ',<%%= ')
+      formatted.gsub!(' %>', ' %%>')
+      
+      File.exists?(model_file) ? File.delete(model_file) : nil
+      File.open(model_file, 'w') {|f| f << formatted}      
+    end
+    
+  end
+end

data/lib/tasks/dev.rake

@@ -0,0 +1,20 @@
+#These are tasks used for the development of CMS as a standalone rails app, not to be included into a CMS project
+
+desc "Reset the DB, run the migrations, load the fixtures, run the specs"
+task :reset => ["db:reload_demo_data", "test:all"]
+
+namespace :db do
+  # This task needs to somehow be packaged as part of the CMS gem, so that users can use the demo.rb template to install the data.
+  
+  desc "Installs sample data for a demo site, including several templates and sample pages."
+  task :load_demo_data => :environment do
+    t0 = Time.now
+    puts "== Demo Data: creating ====================================================="    
+    InitialData.load_demo
+    puts "== Demo Data: created (%0.4fs) ============================================\n" % (Time.now - t0)    
+  end
+  
+  
+  desc "Wipes database, and reinstalls the demo data."
+  task :reload_demo_data => ["db:migrate:reset", "db:load_demo_data"]
+end