browsercms 3.0.0

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; 236 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 =  /[A-Z\\A]:\//    # 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/fckeditor/**/*",
+  "public/site/**/*",   
+  "public/stylesheets/cms/**/*",
+  "public/images/cms/**/*",
+  "db/migrate/[0-9]*_*.rb")

data/lib/cms/routes.rb

@@ -0,0 +1,129 @@
+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.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
+      }
+      
+    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 '*path', :controller => 'cms/content', :action => 'show'    
+  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,83 @@
+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
+
+namespace :cms do
+  
+  desc "DEPRECATED"
+  task :install do
+    puts "This task has been deprecated, please use 'rake install' instead"
+  end
+  
+  desc "Bumps the build number in lib/cms/init.rb"
+  task :bump_build_number do
+    init_file = Rails.root.join("lib/cms/init.rb")
+    s = File.read(init_file)
+    open(init_file, 'w') do |f| 
+      f << s.sub(/def build_number; (\d+) end/) do |s|
+        new_build_number = $1.to_i + 1
+        puts "Build number bumped to #{new_build_number}"
+        "def build_number; #{new_build_number} end"
+      end
+    end
+  end
+  
+  desc "Generate guides for the CMS"
+  task :guides do
+    require 'mizuho/generator'
+
+    source = "doc/guides/source/"
+    html   = "doc/guides/html/"
+    FileUtils.rm_r(html) if File.directory?(html)
+    FileUtils.mkdir(html)
+
+    template = File.expand_path("doc/guides/source/templates/guides.html.erb")
+
+    ignore = ['..', 'icons', 'images', 'templates', 'stylesheets', '.svn']
+    ignore << 'active_record_basics.txt'
+
+    indexless = ['index.txt', 'authors.txt']
+
+    # Traverse all entries in doc/guides/source/
+    Dir.entries(source).each do |entry|
+      next if ignore.include?(entry)
+
+      if File.directory?(File.join(source, entry))
+        # If the current entry is a directory, then we will want to compile
+        # the 'index.txt' file inside this directory.
+        if entry == '.'
+          input  = File.join(source, 'index.txt')
+          output = File.join(html, "index.html")
+        else
+          input  = File.join(source, entry, 'index.txt')
+          output = File.join(html, "#{entry}.html")
+        end
+      else
+        # If the current entry is a file, then we will want to compile this file.
+        input  = File.join(source, entry)
+        output = File.join(html, entry).sub(/\.txt$/, '.html')
+      end
+
+      begin
+        puts "GENERATING => #{output}"
+        ENV['MANUALSONRAILS_TOC'] = 'no' if indexless.include?(entry)
+        Mizuho::Generator.new(input, :output => output, :template => template).start
+      rescue Mizuho::GenerationError
+        STDERR.puts "*** ERROR"
+        exit 2
+      ensure
+        ENV.delete('MANUALSONRAILS_TOC')
+      end
+    end
+
+    # Copy images and css files to html directory. These dirs are in .gitigore and shouldn't be source controlled.
+    FileUtils.cp_r File.join(source, 'images'), File.join(html, 'images')
+    FileUtils.cp_r File.join(source, 'stylesheets'), File.join(html, 'stylesheets')
+  end    
+    
+end

data/lib/tasks/db.rake

@@ -0,0 +1,67 @@
+require 'find'
+
+namespace :db do
+  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.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