comfypress 0.1.3

data/lib/comfypress/extensions/is_categorized.rb

@@ -0,0 +1,49 @@
+module ComfyPress::IsCategorized
+  
+  def self.included(base)
+    base.send :extend, ClassMethods
+  end
+  
+  module ClassMethods
+    def cms_is_categorized
+      include ComfyPress::IsCategorized::InstanceMethods
+      
+      has_many :categorizations,
+        :as         => :categorized,
+        :class_name => 'Cms::Categorization',
+        :dependent  => :destroy
+      has_many :categories,
+        :through    => :categorizations,
+        :class_name => 'Cms::Category'
+        
+      attr_accessor :category_ids
+      
+      after_save :sync_categories
+      
+      scope :for_category, lambda { |*categories|
+        if (categories = [categories].flatten.compact).present?
+          select("DISTINCT #{table_name}.*").
+            joins(:categorizations => :category).
+            where('cms_categories.label' => categories)
+        end
+      }
+    end
+  end
+  
+  module InstanceMethods
+    def sync_categories
+      (self.category_ids || {}).each do |category_id, flag|
+        case flag.to_i
+        when 1
+          if category = Cms::Category.find_by_id(category_id)
+            category.categorizations.create(:categorized => self)
+          end
+        when 0
+          self.categorizations.where(:category_id => category_id).destroy_all
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, ComfyPress::IsCategorized

data/lib/comfypress/extensions/is_mirrored.rb

@@ -0,0 +1,85 @@
+module ComfyPress::IsMirrored
+  
+  def self.included(base)
+    base.send :extend, ClassMethods
+  end
+  
+  module ClassMethods
+    def cms_is_mirrored
+      include ComfyPress::IsMirrored::InstanceMethods
+      
+      attr_accessor :is_mirrored
+      
+      after_save    :sync_mirror
+      after_destroy :destroy_mirror
+    end
+  end
+  
+  module InstanceMethods
+    
+    # Mirrors of the object found on other sites
+    def mirrors
+      return [] unless self.site.is_mirrored?
+      (Cms::Site.mirrored - [self.site]).collect do |site|
+        case self
+          when Cms::Layout  then site.layouts.find_by_identifier(self.identifier)
+          when Cms::Page    then site.pages.find_by_full_path(self.full_path)
+          when Cms::Snippet then site.snippets.find_by_identifier(self.identifier)
+        end
+      end.compact
+    end
+    
+    # Creating or updating a mirror object. Relationships are mirrored
+    # but content is unique. When updating need to grab mirrors based on
+    # self.slug_was, new objects will use self.slug.
+    def sync_mirror
+      return if self.is_mirrored || !self.site.is_mirrored?
+      
+      (Cms::Site.mirrored - [self.site]).each do |site|
+        mirror = case self
+        when Cms::Layout
+          m = site.layouts.find_by_identifier(self.identifier_was || self.identifier) || site.layouts.new
+          m.attributes = {
+            :identifier => self.identifier,
+            :parent_id  => site.layouts.find_by_identifier(self.parent.try(:identifier)).try(:id)
+          }
+          m
+        when Cms::Page
+          m = site.pages.find_by_full_path(self.full_path_was || self.full_path) || site.pages.new
+          m.attributes = {
+            :slug       => self.slug,
+            :label      => self.slug.blank?? self.label : m.label,
+            :parent_id  => site.pages.find_by_full_path(self.parent.try(:full_path)).try(:id),
+            :layout     => site.layouts.find_by_identifier(self.layout.try(:identifier))
+          }
+          m
+        when Cms::Snippet
+          m = site.snippets.find_by_identifier(self.identifier_was || self.identifier) || site.snippets.new
+          m.attributes = {
+            :identifier => self.identifier
+          }
+          m
+        end
+        
+        mirror.is_mirrored = true
+        begin
+          mirror.save!
+        rescue ActiveRecord::RecordInvalid
+          logger.detailed_error($!)
+        end
+      end
+    end
+    
+    # Mirrors should be destroyed
+    def destroy_mirror
+      return if self.is_mirrored || !self.site.is_mirrored?
+      mirrors.each do |mirror|
+        mirror.is_mirrored = true
+        mirror.destroy
+      end
+    end
+  end
+  
+end
+
+ActiveRecord::Base.send :include, ComfyPress::IsMirrored

data/lib/comfypress/extensions/rails.rb

@@ -0,0 +1,24 @@
+class String
+  # Converts string to something suitable to be used as an element id
+  def slugify
+    self.strip.gsub(/\W|_/, '-').gsub(/\s|^_*|_*$/, '').squeeze('-')
+  end
+end
+
+module Enumerable
+  # Like a normal collect, only with index
+  def collect_with_index
+    result = []
+    self.each_with_index do |elt, idx|
+      result << yield(elt, idx)
+    end
+    result
+  end
+end
+
+class ActiveSupport::BufferedLogger
+  def detailed_error(e)
+    error(e.message)
+    e.backtrace.each{|line| error line }
+  end
+end

data/lib/comfypress/fixtures.rb

@@ -0,0 +1,289 @@
+module ComfyPress::Fixtures
+  
+  def self.import_all(to_site, from_folder = nil, force_import = false)
+    import_layouts  to_site, from_folder, nil, true, nil, [], force_import
+    import_pages    to_site, from_folder, nil, true, nil, [], force_import
+    import_snippets to_site, from_folder, force_import
+  end
+  
+  def self.export_all(from_site, to_folder = nil)
+    export_layouts  from_site, to_folder
+    export_pages    from_site, to_folder
+    export_snippets from_site, to_folder
+  end
+  
+  def self.import_layouts(to_site, from_folder = nil, path = nil, root = true, parent = nil, layout_ids = [], force_import = false)
+    site = Cms::Site.find_or_create_by_identifier(to_site)
+    unless path ||= find_fixtures_path((from_folder || to_site), 'layouts')
+      ComfyPress.logger.warn('Cannot find Layout fixtures')
+      return []
+    end
+    
+    Dir.glob("#{path}/*").select{|f| File.directory?(f)}.each do |path|
+      identifier = path.split('/').last
+      layout = site.layouts.find_by_identifier(identifier) || site.layouts.new(:identifier => identifier)
+      
+      # updating attributes
+      if File.exists?(file_path = File.join(path, "_#{identifier}.yml"))
+        if layout.new_record? || File.mtime(file_path) > layout.updated_at || force_import
+          attributes = YAML.load_file(file_path).try(:symbolize_keys!) || { }
+          layout.label      = attributes[:label] || identifier.titleize
+          layout.app_layout = attributes[:app_layout] || parent.try(:app_layout)
+          layout.position   = attributes[:position] if attributes[:position]
+        end
+      elsif layout.new_record?
+        layout.label      = identifier.titleize
+        layout.app_layout = parent.try(:app_layout) 
+      end
+      
+      # updating content
+      if File.exists?(file_path = File.join(path, 'content.html'))
+        if layout.new_record? || File.mtime(file_path) > layout.updated_at || force_import
+          layout.content = File.open(file_path).read
+        end
+      end
+      if File.exists?(file_path = File.join(path, 'css.css'))
+        if layout.new_record? || File.mtime(file_path) > layout.updated_at || force_import
+          layout.css = File.open(file_path).read
+        end
+      end
+      if File.exists?(file_path = File.join(path, 'js.js'))
+        if layout.new_record? || File.mtime(file_path) > layout.updated_at || force_import
+          layout.js = File.open(file_path).read
+        end
+      end
+      
+      # saving
+      layout.parent = parent
+      if layout.changed?
+        if layout.save
+          ComfyPress.logger.warn("[Fixtures] Saved Layout {#{layout.identifier}}")
+        else
+          ComfyPress.logger.error("[Fixtures] Failed to save Layout {#{layout.errors.inspect}}")
+          next
+        end
+      end
+      layout_ids << layout.id
+      
+      # checking for nested fixtures
+      layout_ids += import_layouts(to_site, from_folder, path, false, layout, layout_ids)
+    end
+    
+    # removing all db entries that are not in fixtures
+    if root
+      site.layouts.where('id NOT IN (?)', layout_ids.uniq).each{ |l| l.destroy } 
+      ComfyPress.logger.warn('Imported Layouts!')
+    end
+    
+    # returning ids of layouts in fixtures
+    layout_ids.uniq
+  end
+  
+  def self.import_pages(to_site, from_folder = nil, path = nil, root = true, parent = nil, page_ids = [], force_import = false)
+    site = Cms::Site.find_or_create_by_identifier(to_site)
+    unless path ||= find_fixtures_path((from_folder || to_site), 'pages')
+      ComfyPress.logger.warn('Cannot find Page fixtures')
+      return []
+    end
+    
+    Dir.glob("#{path}/*").select{|f| File.directory?(f)}.each do |path|
+      slug = path.split('/').last
+      page = if parent
+        parent.children.find_by_slug(slug) || site.pages.new(:parent => parent, :slug => slug)
+      else
+        site.pages.root || site.pages.new(:slug => slug)
+      end
+      
+      # updating attributes
+      if File.exists?(file_path = File.join(path, "_#{slug}.yml"))
+        if page.new_record? || File.mtime(file_path) > page.updated_at || force_import
+          attributes = YAML.load_file(file_path).try(:symbolize_keys!) || { }
+          page.label = attributes[:label] || slug.titleize
+          page.layout = site.layouts.find_by_identifier(attributes[:layout]) || parent.try(:layout)
+          page.target_page = site.pages.find_by_full_path(attributes[:target_page])
+          page.is_published = attributes[:is_published].nil?? true : attributes[:is_published]
+          page.position = attributes[:position] if attributes[:position]
+        end
+      elsif page.new_record?
+        page.label = slug.titleize
+        page.layout = parent.try(:layout)
+      end
+      
+      # updating content
+      blocks_to_clear = page.blocks.collect(&:identifier)
+      blocks_attributes = [ ]
+      Dir.glob("#{path}/*.html").each do |file_path|
+        identifier = file_path.split('/').last.gsub(/\.html$/, '')
+        blocks_to_clear.delete(identifier)
+        if page.new_record? || File.mtime(file_path) > page.updated_at || force_import
+          blocks_attributes << {
+            :identifier => identifier,
+            :content    => File.open(file_path).read
+          }
+        end
+      end
+      
+      # clearing removed blocks
+      blocks_to_clear.each do |identifier|
+        blocks_attributes << {
+          :identifier => identifier,
+          :content    => nil
+        }
+      end
+      
+      # saving
+      page.blocks_attributes = blocks_attributes if blocks_attributes.present?
+      if page.changed? || blocks_attributes.present?
+        if page.save
+          ComfyPress.logger.warn("[Fixtures] Saved Page {#{page.full_path}}")
+        else
+          ComfyPress.logger.warn("[Fixtures] Failed to save Page {#{page.errors.inspect}}")
+          next
+        end
+      end
+      page_ids << page.id
+      
+      # checking for nested fixtures
+      page_ids += import_pages(to_site, from_folder, path, false, page, page_ids)
+    end
+    
+    # removing all db entries that are not in fixtures
+    if root
+      site.pages.where('id NOT IN (?)', page_ids.uniq).each{ |p| p.destroy }
+      ComfyPress.logger.warn('Imported Pages!')
+    end
+    
+    # returning ids of layouts in fixtures
+    page_ids.uniq
+  end
+  
+  def self.import_snippets(to_site, from_folder = nil, force_import = false)
+    site = Cms::Site.find_or_create_by_identifier(to_site)
+    unless path = find_fixtures_path((from_folder || to_site), 'snippets')
+      ComfyPress.logger.warn('Cannot find Snippet fixtures')
+      return []
+    end
+    
+    snippet_ids = []
+    Dir.glob("#{path}/*").select{|f| File.directory?(f)}.each do |path|
+      identifier = path.split('/').last
+      snippet = site.snippets.find_by_identifier(identifier) || site.snippets.new(:identifier => identifier)
+      
+      # updating attributes
+      if File.exists?(file_path = File.join(path, "_#{identifier}.yml"))
+        if snippet.new_record? || File.mtime(file_path) > snippet.updated_at || force_import
+          attributes = YAML.load_file(file_path).try(:symbolize_keys!) || { }
+          snippet.label = attributes[:label] || identifier.titleize
+        end
+      elsif snippet.new_record?
+        snippet.label = identifier.titleize
+      end
+      
+      # updating content
+      if File.exists?(file_path = File.join(path, 'content.html'))
+        if snippet.new_record? || File.mtime(file_path) > snippet.updated_at || force_import
+          snippet.content = File.open(file_path).read
+        end
+      end
+      
+      # saving
+      if snippet.changed?
+        if snippet.save
+          ComfyPress.logger.warn("[Fixtures] Saved Snippet {#{snippet.identifier}}")
+        else
+          ComfyPress.logger.warn("[Fixtures] Failed to save Snippet {#{snippet.errors.inspect}}")
+          next
+        end
+      end
+      snippet_ids << snippet.id
+    end
+    
+    # removing all db entries that are not in fixtures
+    site.snippets.where('id NOT IN (?)', snippet_ids).each{ |s| s.destroy }
+    ComfyPress.logger.warn('Imported Snippets!')
+  end
+  
+  def self.export_layouts(from_site, to_folder = nil)
+    return unless site = Cms::Site.find_by_identifier(from_site)
+    path = File.join(ComfyPress.config.fixtures_path, (to_folder || site.identifier), 'layouts')
+    FileUtils.rm_rf(path)
+    FileUtils.mkdir_p(path)
+    
+    site.layouts.each do |layout|
+      layout_path = File.join(path, layout.ancestors.reverse.collect{|l| l.identifier}, layout.identifier)
+      FileUtils.mkdir_p(layout_path)
+      
+      open(File.join(layout_path, "_#{layout.identifier}.yml"), 'w') do |f|
+        f.write({
+          'label'       => layout.label,
+          'app_layout'  => layout.app_layout,
+          'parent'      => layout.parent.try(:identifier),
+          'position'    => layout.position
+        }.to_yaml)
+      end
+      open(File.join(layout_path, 'content.html'), 'w') do |f|
+        f.write(layout.content)
+      end
+      open(File.join(layout_path, 'css.css'), 'w') do |f|
+        f.write(layout.css)
+      end
+      open(File.join(layout_path, 'js.js'), 'w') do |f|
+        f.write(layout.js)
+      end
+    end
+  end
+  
+  def self.export_pages(from_site, to_folder = nil)
+    return unless site = Cms::Site.find_by_identifier(from_site)
+    path = File.join(ComfyPress.config.fixtures_path, (to_folder || site.identifier), 'pages')
+    FileUtils.rm_rf(path)
+    FileUtils.mkdir_p(path)
+    
+    site.pages.each do |page|
+      page.slug = 'index' if page.slug.blank?
+      page_path = File.join(path, page.ancestors.reverse.collect{|p| p.slug.blank?? 'index' : p.slug}, page.slug)
+      FileUtils.mkdir_p(page_path)
+      
+      open(File.join(page_path, "_#{page.slug}.yml"), 'w') do |f|
+        f.write({
+          'label'         => page.label,
+          'layout'        => page.layout.try(:identifier),
+          'parent'        => page.parent && (page.parent.slug.present?? page.parent.slug : 'index'),
+          'target_page'   => page.target_page.try(:slug),
+          'is_published'  => page.is_published,
+          'position'      => page.position
+        }.to_yaml)
+      end
+      page.blocks_attributes.each do |block|
+        open(File.join(page_path, "#{block[:identifier]}.html"), 'w') do |f|
+          f.write(block[:content])
+        end
+      end
+    end
+  end
+  
+  def self.export_snippets(from_site, to_folder = nil)
+    return unless site = Cms::Site.find_by_identifier(from_site)
+    path = File.join(ComfyPress.config.fixtures_path, (to_folder || site.identifier), 'snippets')
+    FileUtils.rm_rf(path)
+    FileUtils.mkdir_p(path)
+    
+    site.snippets.each do |snippet|
+      FileUtils.mkdir_p(snippet_path = File.join(path, snippet.identifier))
+      open(File.join(snippet_path, "_#{snippet.identifier}.yml"), 'w') do |f|
+        f.write({'label' => snippet.label}.to_yaml)
+      end
+      open(File.join(snippet_path, 'content.html'), 'w') do |f|
+        f.write(snippet.content)
+      end
+    end
+  end
+  
+protected
+  
+  def self.find_fixtures_path(identifier, dir)
+    path = File.join(ComfyPress.config.fixtures_path, identifier, dir)
+    File.exists?(path) ? path : nil
+  end
+  
+end

data/lib/comfypress/form_builder.rb

@@ -0,0 +1,97 @@
+class ComfyPress::FormBuilder < FormattedForm::FormBuilder
+  
+  # -- Tag Field Fields -----------------------------------------------------
+  def default_tag_field(tag, index, method = :text_field_tag, options = {})
+    
+    label     = tag.page.class.human_attribute_name(tag.identifier.to_s)
+    css_class = tag.class.to_s.demodulize.underscore
+    content   = ''
+    
+    case method
+    when :file_field_tag
+      input_params = {:id => nil}
+      name = "page[blocks_attributes][#{index}][content]"
+      
+      if options.delete(:multiple)
+        input_params.merge!(:multiple => true)
+        name << '[]'
+      end
+      
+      content << @template.send(method, name, input_params)
+      content << @template.render(:partial => 'cms_admin/files/page_form', :object => tag.block)
+    else
+      content << @template.send(method, "page[blocks_attributes][#{index}][content]", tag.content, options)
+    end
+    content << @template.hidden_field_tag("page[blocks_attributes][#{index}][identifier]", tag.identifier, :id => nil)
+    
+    element(label, content.html_safe)
+  end
+  
+  def field_date_time(tag, index)
+    default_tag_field(tag, index, :text_field_tag, :data => {:datetime => true})
+  end
+  
+  def field_integer(tag, index)
+    default_tag_field(tag, index, :number_field_tag)
+  end
+  
+  def field_string(tag, index)
+    default_tag_field(tag, index)
+  end
+  
+  def field_text(tag, index)
+    default_tag_field(tag, index, :text_area_tag, :data => {:cm_mode => 'text/html'})
+  end
+  
+  def field_rich_text(tag, index)
+    default_tag_field(tag, index, :text_area_tag, :data => {:rich_text => true})
+  end
+  
+  def page_date_time(tag, index)
+    default_tag_field(tag, index, :text_field_tag, :data => {:datetime => true})
+  end
+  
+  def page_integer(tag, index)
+    default_tag_field(tag, index, :number_field_tag)
+  end
+  
+  def page_string(tag, index)
+    default_tag_field(tag, index)
+  end
+  
+  def page_text(tag, index)
+    default_tag_field(tag, index, :text_area_tag, :data => {:cm_mode => 'text/html'})
+  end
+  
+  def page_rich_text(tag, index)
+    default_tag_field(tag, index, :text_area_tag, :data => {:rich_text => true})
+  end
+  
+  def page_file(tag, index)
+    default_tag_field(tag, index, :file_field_tag)
+  end
+  
+  def page_files(tag, index)
+    default_tag_field(tag, index, :file_field_tag, :multiple => true)
+  end
+  
+  def page_markdown(tag, index)
+    default_tag_field(tag, index, :text_area_tag, :data => {:cm_mode => 'text/x-markdown'})
+  end
+  
+  def collection(tag, index)
+    options = [["---- Select #{tag.collection_class.titleize} ----", nil]] + 
+      tag.collection_objects.collect do |m| 
+        [m.send(tag.collection_title), m.send(tag.collection_identifier)]
+      end
+      
+    content = @template.select_tag(
+      "page[blocks_attributes][#{index}][content]",
+      @template.options_for_select(options, :selected => tag.content),
+      :id => nil
+    )
+    content << @template.hidden_field_tag("page[blocks_attributes][#{index}][identifier]", tag.identifier, :id => nil)
+    element(tag.identifier.titleize, content, :class => tag.class.to_s.demodulize.underscore )
+  end
+  
+end

data/lib/comfypress/render_methods.rb

@@ -0,0 +1,85 @@
+module ComfyPress::RenderMethods
+  
+  def self.included(base)
+    
+    # If application controller doesn't have template associated with it
+    # CMS will attempt to find one. This is so you don't have to explicitly
+    # call render :cms_page => '/something'
+    base.rescue_from 'ActionView::MissingTemplate' do |e|
+      begin
+        render :cms_page => request.path
+      rescue ComfyPress::MissingPage
+        raise e
+      end
+    end
+    
+    # Now you can render cms_page simply by calling:
+    #   render :cms_page => '/path/to/page'
+    # This way application controllers can use CMS content while populating
+    # instance variables that can be used in partials (that are included by
+    # by the cms page and/or layout)
+    #
+    # Or how about not worrying about setting up CMS pages and rendering 
+    # application view using a CMS layout?
+    #   render :cms_layout => 'layout_slug', :cms_blocks => {
+    #     :block_label_a => 'content text',
+    #     :block_label_b => { :template => 'path/to/template' },
+    #     :block_label_c => { :partial  => 'path/to/partial' }
+    #   }
+    #
+    # This way you are populating page block content and rendering
+    # an instantialized CMS page.
+    #
+    # Site is loaded automatically based on the request. However you can force
+    # it by passing :cms_site parameter with site's slug. For example:
+    #   render :cms_page => '/path/to/page', :cms_site => 'default'
+    # 
+    def render(options = {}, locals = {}, &block)
+      
+      if options.is_a?(Hash) && identifier = options.delete(:cms_site)
+        unless @cms_site = Cms::Site.find_by_identifier(identifier)
+          raise ComfyPress::MissingSite.new(identifier)
+        end
+      end
+      
+      if options.is_a?(Hash) && path = options.delete(:cms_page)
+        @cms_site ||= Cms::Site.find_site(request.host.downcase, request.fullpath)
+        if @cms_page = @cms_site && @cms_site.pages.find_by_full_path(path)
+          @cms_layout = @cms_page.layout
+          cms_app_layout = @cms_layout.try(:app_layout)
+          options[:layout] ||= cms_app_layout.blank?? nil : cms_app_layout
+          options[:inline] = @cms_page.content
+          super(options, locals, &block)
+        else
+          raise ComfyPress::MissingPage.new(path)
+        end
+        
+      elsif options.is_a?(Hash) && identifier = options.delete(:cms_layout)
+        @cms_site ||= Cms::Site.find_site(request.host.downcase, request.fullpath)
+        if @cms_layout = @cms_site && @cms_site.layouts.find_by_identifier(identifier)
+          cms_app_layout = @cms_layout.try(:app_layout)
+          cms_page = @cms_site.pages.build(:layout => @cms_layout)
+          cms_blocks = options.delete(:cms_blocks) || { :content => render_to_string({ :layout => false }.merge(options)) }
+          cms_blocks.each do |identifier, value|
+            content = if value.is_a?(Hash)
+              render_to_string(value.keys.first.to_sym => value[value.keys.first], :layout => false)
+            else
+              value.to_s
+            end
+            cms_page.blocks.build(:identifier => identifier.to_s, :content => content)
+          end
+          options[:layout] ||= cms_app_layout.blank?? nil : cms_app_layout
+          options[:inline] = cms_page.content(true)
+          super(options, locals, &block)
+        else
+          raise ComfyPress::MissingLayout.new(identifier)
+        end
+        
+      else
+        super(options, locals, &block)
+      end
+    end
+  end
+end
+
+ActionController::Base.send :include, ComfyPress::RenderMethods

data/lib/comfypress/routing.rb

@@ -0,0 +1,62 @@
+module ComfyPress::Routing
+  
+  def self.admin(options = {})
+    options[:path] ||= 'cms-admin'
+    
+    Rails.application.routes.draw do
+      namespace :cms_admin, :path => options[:path], :except => :show do
+        get '/', :to => 'base#jump'
+        resources :sites do
+          resources :pages do
+            get  :form_blocks,    :on => :member
+            get  :toggle_branch,  :on => :member
+            put :reorder,         :on => :collection
+            resources :revisions, :only => [:index, :show, :revert] do
+              put :revert, :on => :member
+            end
+          end
+          resources :files do
+            put :reorder, :on => :collection
+          end
+          resources :layouts do
+            put :reorder, :on => :collection
+            resources :revisions, :only => [:index, :show, :revert] do
+              put :revert, :on => :member
+            end
+          end
+          resources :snippets do
+            put :reorder, :on => :collection
+            resources :revisions, :only => [:index, :show, :revert] do
+              put :revert, :on => :member
+            end
+          end
+          resources :categories
+          resources :menus do
+            resources :menu_items
+          end
+          get 'dialog/:type' => 'dialogs#show', :as => 'dialog'
+        end
+      end
+    end
+  end
+  
+  def self.content(options = {})
+    
+    Rails.application.routes.draw do
+      namespace :cms_content, :path => options[:path] do
+        get 'cms-css/:site_id/:identifier' => :render_css,  :as => 'css'
+        get 'cms-js/:site_id/:identifier'  => :render_js,   :as => 'js'
+        
+        if options[:sitemap]
+          get '(:cms_path)/sitemap' => :render_sitemap,
+            :as           => 'sitemap',
+            :constraints  => {:format => /xml/},
+            :format       => :xml
+        end
+        
+        get '/' => :render_html, :as => 'html', :path => "(*cms_path)"
+      end
+    end
+  end
+  
+end