comatose-rubyisbeautiful 3.0.0

data/README.markdown

@@ -0,0 +1,113 @@
+# Comatose
+
+* Version: 3.0.0 (beta)
+* Author:  Bryan Taylor (originally written by Matt McCray)
+* Website: github.com/rubyisbeautiful/comatose
+* Email: artofobjects at gmail dot com
+
+
+*Comatose* is a micro CMS designed for being embedded into existing Rails 
+applications.
+
+It's intended for simple CMS support. Comatose supports 
+
+ * Nested pages
+ * Versioning
+ * Page markup in Textile, Markdown, RDoc, or easily add your own 
+ * Page processing through Liquid or ERb
+ * Generators for easy installation/migration
+ * Self-contained gem containing a Rails::Engine
+ * Code Editor for mark, designed by scienco.de (http://blog.scienceco.de/2011/06/19/einfacher-javascript-code-editor/)
+
+It's meant to be lean, mean, easily embedded, and easy to re-skin for 
+existing applications. If you need something more, I would recommend 
+looking into Radiant, Mephisto, Refinery, BrowserCMS, or Locomotive.
+
+For more information, see the [Getting Started][] guide.
+
+### Requirements
+
+ * Rails 3.0.x (3.0.9)
+ * `acts_as_list-rails3`, `acts_as_tree_rails3`, and `liquid` gems are required (at the moment)
+
+
+### Development Notes
+
+*NOTE*: This is a port of Comatose, which was last maintained in 2008.  This
+        branch of Comatose is built specifically for Rails 3.
+        There is no legacy support.
+
+ * Make comatose fully self-contained, which means removing `acts_as_(tree|list)`
+ * Improve `ComatoseAdminController` to reduce number of DB calls for building the page tree
+ * `Comatose.configure` needs to be an initializer (update docs)
+ * Give access to all the default rails helpers to Comatose Pages by default?
+ * UI refresh (nothing major, just some cleanup).
+ * RESTful goodness.
+ * Support XML/JSON responses from `ComatoseController` and `ComatoseAdminController`.
+ * Support for static rendering (for generating sites like this blog).
+
+### Installation
+
+*Note*: See the 'Upgrading' section if you already have an older version of 
+        the comatose plugin installed.
+
+    $ gem install comatose
+    $ rails generate comatose
+    $ rake db:migrate
+    $ rails server
+
+Open your `routes.rb` and add the following:
+
+    routes_for_comatose
+
+That's it, you're ready to go! You should be able to browse to 
+http://127.0.0.1:3000/en/comatose and start adding pages to your CMS.
+Browsing to http://127.0.0.1:3000/en will render your comatose pages if
+routing doesn't match any of your controllers. 
+
+
+### Configuration
+
+You configure Comatose in your `config/intializers/comatose.rb` file. Here is an example
+configuration block:
+
+    Comatose.configure do |config|
+      # Sets the text in the Admin UI's title area
+      config.admin_title = "Site Content"
+      config.admin_sub_title = "Content for the rest of us..."
+    end
+
+
+### Extra Credit
+
+This gem is based on the work of Matt McCray, and other original Comatose contributers,
+as well as the following individuals, to whom Matt gave credit in the original README.markdown.
+Following are the specific libraries that are distributed with Comatose. If I've
+missed someone/something please let me know.
+
+ * [Liquid][] by [Tobias Luetke][] 
+ * [RedCloth][] by [_why][]
+ * [Acts as Versioned][]  by [Rick Olsen][]
+ * [Behaviors][] by Atomic Object LLC -- very nice BDD-like testing library
+
+### Feedback
+
+I’ve released Comatose under the MIT license. Which basically means you 
+can use it however you want.
+
+Don't forget to read the [Getting Started][] guide located on the RubyForge
+project site.
+
+If you like it, hate it, or have some ideas for new features, let me know!
+
+artofobjects at gmail dot com
+
+
+[Getting Started]: http://github.com/rubyisbeautiful/comatose
+[Liquid]: http://home.leetsoft.com/liquid
+[Tobias Luetke]: http://blog.leetsoft.com
+[RedCloth]: http://whytheluckystiff.net/ruby/redcloth
+[_why]: http://whytheluckystiff.net
+[Acts as Versioned]: http://ar-versioned.rubyforge.org
+[Rick Olsen]: http://weblog.techno-weenie.net
+[Behaviors]: http://behaviors.rubyforge.org

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rake'
+require 'rails/all'
+require File.expand_path('../lib/comatose/engine.rb', __FILE__)
+
+Comatose::Engine.load_tasks

data/SPECS

@@ -0,0 +1,61 @@
+Comatose Admin Controller should:
+ - show the index action
+ - show the new action
+ - successfully create pages
+ - create a page with an empty body
+ - not create a page with a missing title
+ - not create a page associated to an invalid parent
+ - contain all the correct options for filter_type
+ - show the edit action
+ - update pages with valid data
+ - not update pages with invalid data
+ - delete a page
+ - reorder pages
+ - set runtime mode
+
+Comatose Controller should:
+ - show pages based on path_info
+
+Class Options should:
+ - allow nil as a default
+ - allow boolean defaults
+ - allow string defaults
+ - allow numeric defaults
+ - allow symbolic defaults
+ - allow array literals as defaults
+ - allow hash literals as defaults
+
+Comatose Page should:
+ - create page
+ - create a new version of an updated page
+ - render content through textile and liquid processors
+ - not allow creation of page when missing a title
+ - have good fixtures for this to work out
+ - generate slugs correctly
+ - generate page paths correctly
+ - update page paths when pages are moved
+ - set an AR error with processor syntax error info
+ - render body text accurately
+ - render data from parameterized calls too
+ - render data from a Drop
+
+Processing Context should:
+ - process liquid tags with no filters correctly
+ - process erb tags correctly
+ - support text translation and processing with ERB
+ - support text translation and processing with Liquid
+ - allow access to safe properties and methods when processing with ERB
+ - prevent access to protected properties and methods when processing with ERB
+ - allow access to safe properties and methods when processing with Liquid
+ - prevent access to protected properties and methods when processing with Liquid
+ - allow referenceing of defined ComatoseDrops
+ - let ComatoseDrop errors bubble upward
+
+Text Filters should:
+ - not alter output when using filter :none
+ - convert newlines into <br/>s when using :simple filter
+ - support Textile, if it's available, using :textile or 'Textile' as a key
+ - support Markdown, if it's available, using :markdown or 'Markdown' as a key
+ - support RDoc, if it's available, using :rdoc or 'RDoc' as a key
+ - support transformation of parameters via ERB
+ - support transformation of parameters via Liquid

data/app/controllers/application_controller.rb

@@ -0,0 +1,3 @@
+class ApplicationController < ActionController::Base
+  protect_from_forgery
+end

data/app/controllers/comatose/admin_controller.rb

@@ -0,0 +1,425 @@
+module Comatose
+  class AdminController < Comatose::ApplicationController
+    unloadable
+
+    define_option :original_template_root, nil
+    define_option :plugin_layout_path, File.join( '..', '..', '..', 'vendor', 'plugins', 'comatose', 'views', 'layouts' )
+
+    before_filter :handle_authorization
+    before_filter :set_content_type
+    layout 'comatose/admin'
+
+    # Shows the page tree
+    def index
+      @root_pages = [fetch_root_page].flatten
+      Comatose.logger.debug "current_user: #{current_user}"
+    end
+
+    # Edit a specific page
+    def edit
+      # Clear the page cache for this page... ?
+      @page = Page.find params[:id]
+      @root_pages = [fetch_root_page].flatten
+    end
+
+
+    def update
+      @page = Page.find params[:id]
+      @root_pages = [fetch_root_page].flatten
+
+      @page.update_attributes(params[:page].merge(:author => fetch_author_name))
+      Comatose.logger.debug "Saved #{@page}"
+      expire_cms_page     @page
+      expire_cms_fragment @page
+      flash[:notice] = "Saved changes to '#{@page.title}'"
+      redirect_to comatose_pages_path and return false
+    rescue => e
+      Comatose.logger.info e.message
+      Comatose.logger.debug e.backtrace
+    end
+
+    # Create a new page (posts back)
+    def new
+      @root_pages = [fetch_root_page].flatten
+      @page = Page.new :title=>'New Page', :parent_id => params[:parent]
+    end
+
+
+    def create
+      @root_pages = [fetch_root_page].flatten
+      @page = Page.new params[:page]
+      @page.author = fetch_author_name
+      if @page.save
+        flash[:notice] = "Created page '#{@page.title}'"
+        redirect_to comatose_pages_path
+      end
+    end
+
+    # Saves position of child pages
+    def reorder
+      # If it's AJAX, do our thing and move on...
+      if request.xhr?
+        params["page_list_#{params[:id]}"].each_with_index { |id,idx| Page.update(id, :position => idx) }
+        expire_cms_page Page.find(params[:id])
+        render :text=>'Updated sort order', :layout=>false
+      else
+        @page = Page.find params[:id]
+        if params.has_key? :cmd
+          @target = Page.find params[:page]
+          case params[:cmd]
+            when 'up' then @target.move_higher
+            when 'down' then @target.move_lower
+          end
+          redirect_to :action=>'reorder', :id=>@page
+        end
+      end
+    end
+
+    # Allows comparing between two versions of a page's content
+    def versions
+      @page = Page.find params[:id]
+      @version_num = (params[:version] || @page.versions.length).to_i
+      @version = @page.find_version(@version_num)
+    end
+
+    # Reverts a page to a specific version...
+    def set_version
+      if request.post?
+        @page = Page.find params[:id]
+        @version_num = params[:version]
+        @page.revert_to!(@version_num)
+      end
+      redirect_to :controller=>self.controller_name, :action=>'index'
+    end
+
+    # Deletes the specified page
+    def delete
+      @page = Page.find params[:id]
+      if request.post?
+        expire_cms_pages_from_bottom @page
+        expire_cms_fragments_from_bottom @page
+        @page.destroy
+        flash[:notice] = "Deleted page '#{@page.title}'"
+        redirect_to :controller=>self.controller_name, :action=>'index'
+      end
+    end
+
+    # Returns a preview of the page content...
+    def preview
+      begin
+        page = Page.new(params[:page])
+        page.author = fetch_author_name
+        if params.has_key? :version
+          content = page.to_html( {'params'=>params.stringify_keys, 'version'=>params[:version]} )
+        else
+          content = page.to_html( {'params'=>params.stringify_keys} )
+        end
+      rescue SyntaxError
+        content = "<p>There was an error generating the preview.</p><p><pre>#{$!.to_s.gsub(/\</, '&lt;')}</pre></p>"
+      rescue
+        content = "<p>There was an error generating the preview.</p><p><pre>#{$!.to_s.gsub(/\</, '&lt;')}</pre></p>"
+      end
+      render :text=>content, :layout => false
+    end
+
+    # Expires the entire page cache
+    def expire_page_cache
+      expire_cms_pages_from_bottom( fetch_root_page )
+      expire_cms_fragments_from_bottom( fetch_root_page )
+      flash[:notice] = "Page cache has been flushed"
+      redirect_to :controller=>self.controller_name, :action=>'index'
+    end
+
+    # Walks the page tree and generates HTML files in your /public
+    # folder... It will skip pages that have a 'nocache' keyword
+    # TODO: Make page cache generation work when in :plugin mode
+    def generate_page_cache
+      if runtime_mode == :plugin
+        @errors = ["Page cache cannot be generated in plugin mode"]
+      else
+        @errors = generate_all_pages_html(params)
+      end
+      if @errors.length == 0
+        flash[:notice] = "Pages Cached Successfully"
+      else
+        flash[:notice] = "Pages Cache Error(s): #{@errors.join(', ')}"
+        flash[:cache_errors] = @errors
+      end
+      redirect_to :controller=>self.controller_name, :action=>'index'
+    end
+
+    def export
+      if Comatose.config.allow_import_export
+        send_data(page_to_hash(Page.root).to_yaml, :disposition => 'attachment', :type => 'text/yaml', :filename => "comatose-pages.yml")
+      else
+        flash[:notice] = "Export is not allowed"
+        redirect_to :controller=>self.controller_name, :action=>'index'
+      end
+    end
+
+    def import
+      if Comatose.config.allow_import_export
+        data = YAML::load(params[:import_file])
+        hash_to_page_tree(data, Page.root)
+        flash[:notice] = "Pages Imported Successfully"
+      else
+        flash[:notice] = "Import isn't allowed"
+      end
+      redirect_to :controller=>self.controller_name, :action=>'index'
+    end
+
+  protected
+
+    def handle_authorization
+      Comatose.logger.debug Comatose.config.admin_authorization.to_s
+      case Comatose.config.admin_authorization
+      when Proc
+        instance_eval &Comatose.config.admin_authorization
+      when Symbol
+        send(Comatose.config.admin_authorization)
+      when NilClass
+        @_current_user = "placeholder"
+        return true
+      when Module
+      else
+        if defined? authorize
+          authorize
+        else
+          @_current_user = "placeholder"
+          return true
+        end
+      end
+    end
+
+
+    def fetch_author_name
+      if Comatose.config.admin_get_author.is_a? Proc
+        instance_eval &Comatose.config.admin_get_author
+      elsif Comatose.config.admin_get_author.is_a? Symbol
+        send(Comatose.config.admin_get_author)
+      elsif defined? get_author
+        get_author
+      end
+    end
+
+
+    # Can be overridden -- return your root comtase page
+    def fetch_root_page
+      if Comatose.config.admin_get_root_page.is_a? Proc
+        instance_eval &Comatose.config.admin_get_root_page
+      elsif Comatose.config.admin_get_root_page.is_a? Symbol
+        send(Comatose.config.admin_get_root_page)
+      elsif defined? get_root_page
+        get_root_page
+      end
+    end
+
+    def get_root_page
+      Page.find(:first, :conditions => { :parent_id => nil })
+    end
+
+    # Sets the HTTP content-type header based on what's configured
+    # in Comatose.config.content_type
+    def set_content_type
+      response.headers["Content-Type"] = "text/html; charset=#{Comatose.config.content_type}" unless Comatose.config.content_type.nil?
+    end
+
+    # Calls generate_page_html for each mount point..
+    def generate_all_pages_html(params={})
+      @errors = []
+      @been_cached = []
+      Comatose.mount_points.each do |root_info|
+        Page.active_mount_info = root_info
+        generate_page_html(Page.find_by_path( root_info[:index] ), root_info, params)
+      end
+      @errors
+    end
+
+    # Accepts a Comatose Page and a root_info object to generate
+    # the page as a static HTML page -- using the layout that was
+    # defined on the mount point
+    def generate_page_html(page, root_info, params={})
+      @been_cached ||= []
+      unless page.has_keyword? :nocache or @been_cached.include? page.id
+        uri = page.uri
+        uri = "#{uri}/index".split('/').flatten.join('/') if page.full_path == root_info[:index]
+        @page = Comatose::PageWrapper.new(page)
+        begin
+          page_layout = get_page_layout(root_info)
+          #puts "mode = #{runtime_mode}, layout = #{page_layout}, template_root = #{template_root}, original_template_root = #{original_template_root}"
+          html = render_to_string( :text=>page.to_html({'params'=>params.stringify_keys}), :layout=>page_layout )
+          cache_page( html, uri )
+        rescue
+          logger.error "Comatose CMS Page Cache Exception: #{$!}"
+          @errors << "(#{page}/#{page.slug}) - #{$!}"
+        end
+        @been_cached << page.id
+        # recurse...
+        page.children.each do |child|
+          generate_page_html(child, root_info)
+        end
+      end
+    end
+
+    # Calls the class methods of the same name...
+    def expire_cms_page(page)
+      self.class.expire_cms_page(page)
+    end
+    def expire_cms_pages_from_bottom(page)
+      self.class.expire_cms_pages_from_bottom(page)
+    end
+
+
+    # expire the page from the fragment cache
+    def expire_cms_fragment(page)
+      key = page.full_path.gsub(/\//, '+')
+      expire_fragment(key)
+    end
+
+    # expire pages starting at a specific node
+    def expire_cms_fragments_from_bottom(page)
+      pages = page.is_a?(Array) ? page : [page]
+      pages.each do |page|
+        page.children.each {|c| expire_cms_fragments_from_bottom( c ) } if !page.children.empty?
+        expire_cms_fragment( page )
+      end
+    end
+
+    # Class Methods...
+    class << self
+
+
+      # Walks all the way down, and back up the tree -- the allows the expire_cms_page
+      # to delete empty directories better
+      def expire_cms_pages_from_bottom(page)
+        pages = page.is_a?(Array) ? page : [page]
+        pages.each do |page|
+          page.children.each {|c| expire_cms_pages_from_bottom( c ) } if !page.children.empty?
+          expire_cms_page( page )
+        end
+      end
+
+      # Expire the page from all the mount points...
+      def expire_cms_page(page)
+        Comatose.mount_points.each do |path_info|
+          Page.active_mount_info = path_info
+          expire_page(page.uri)
+          # If the page is the index page for the root, expire it too
+          if path_info[:root] == page.uri
+            expire_page("#{path_info[:root]}/index")
+          end
+          begin # I'm not sure this matters too much -- but it keeps things clean
+            dir_path = File.join(Rails.root, 'public', page.uri[1..-1])
+            Dir.delete( dir_path ) if FileTest.directory?( dir_path ) and !page.parent.nil?
+          rescue
+            # It probably isn't empty -- just as well we leave it be
+            #STDERR.puts " - Couldn't delete dir #{dir_path} -> #{$!}"
+          end
+        end
+      end
+
+      # Returns a path to plugin layout, if it's unspecified, otherwise
+      # a path to an application layout...
+      def get_page_layout(params)
+        if params[:layout] == 'comatose_content'
+          File.join(plugin_layout_path, params[:layout])
+        else
+          params[:layout]
+        end
+      end
+
+      def configure_template_root
+        if self.runtime_mode == :unknown
+          if FileTest.exist? File.join(Rails.root, 'public', 'javascripts', 'admin.js')
+            self.runtime_mode = :application
+          else
+            self.runtime_mode = :plugin
+          end
+        end
+      end
+
+      def runtime_mode
+        @@runtime_mode ||= :unknown
+      end
+
+      def runtime_mode=(mode)
+        admin_view_path = File.expand_path(File.join( File.dirname(__FILE__), '..', 'views'))
+        if self.respond_to?(:template_root)
+          case mode
+          when :plugin
+            self.original_template_root = self.template_root
+            self.template_root = admin_view_path
+          when :application
+            self.template_root = self.original_template_root if self.original_template_root
+          end
+        else
+          ActionController::Base.append_view_path(admin_view_path) unless ActionController::Base.view_paths.include?(admin_view_path)
+        end
+        @@runtime_mode = mode
+      end
+
+    end
+
+    # Check to see if we are in 'embedded' mode, or are being 'customized'
+    #  embedded   = runtime_mode of :plugin
+    #  customized = runtime_mode of :application
+    configure_template_root
+
+    #
+    # Include any modules...
+    Comatose.config.admin_includes.each do |mod|
+      if mod.is_a? String
+        include mod.constantize
+      elsif mod.is_a? Symbol
+        include mod.to_s.classify.constantize
+      else
+        include mod
+      end
+    end
+
+    # Include any helpers...
+    Comatose.config.admin_helpers.each do |mod|
+      if mod.is_a? String
+        helper mod.constantize
+      elsif mod.is_a? Symbol
+        helper mod.to_s.classify.constantize
+      else
+        helper mod
+      end
+    end
+
+    private
+
+    def page_to_hash(page)
+      data = page.attributes.clone
+      # Pull out the specific, or unnecessary fields
+      %w(id parent_id updated_at author position version created_at full_path).each {|key| data.delete(key)}
+      if !page.children.empty?
+        data['children'] = []
+        page.children.each do |child|
+          data['children'] << page_to_hash(child)
+        end
+      end
+      data
+    end
+
+    def hash_to_page_tree(hsh, page=nil)
+      child_ary = hsh.delete 'children'
+
+      if page.blank?
+        page = Comatose::Page.create_root(hsh)
+      else
+        page.update_attributes(hsh)
+      end
+
+      child_ary.each do |child_hsh|
+        if child_pg = page.children.find_by_slug( child_hsh['slug'] )
+          hash_to_page_tree( child_hsh, child_pg )
+        else
+          hash_to_page_tree( child_hsh, page.children.create )
+        end
+      end if child_ary
+    end
+
+  end
+end

data/app/controllers/comatose/application_controller.rb

@@ -0,0 +1,30 @@
+module Comatose
+  class ApplicationController < ActionController::Base
+
+    before_filter :set_locale
+
+
+    def comatose_current_user
+      @_current_user
+    end
+
+
+    def set_locale
+      locale_language, locale_country = params[:locale].to_s.split('-')
+      locale_language ||= 'en'
+      locale_country  ||= 'US'
+      locale_language.downcase.to_sym
+      locale_country.upcase!
+      I18n.locale = locale_language
+      logger.debug "Locale set to #{locale_language} from param #{params[:locale]}"
+    end
+
+
+    def find_page(*args)
+      Comatose::Page.send(Comatose.config.page_finder, *args)
+    end
+
+
+
+  end
+end