aslakjo-aslakjo-comatose 2.0.5.1

data/lib/comatose.rb

@@ -0,0 +1,33 @@
+
+module Comatose
+
+  # DEPRECATED
+  # Loads extensions from RAILS_ROOT/lib/comatose/*.rb
+  def self.load_extensions
+    Dir[File.join(RAILS_ROOT, 'lib', 'comatose', '*.rb')].each do |path|
+      require "comatose/#{File.basename(path)}"
+    end
+  end
+
+end
+
+require 'acts_as_versioned'
+require 'redcloth' unless defined?(RedCloth)
+require 'liquid' unless defined?(Liquid)
+
+require 'support/class_options'
+require 'text_filters'
+
+require 'comatose/configuration'
+require 'comatose/comatose_drop'
+require 'comatose/processing_context'
+require 'comatose/page_wrapper'
+require 'comatose/version'
+
+require 'support/inline_rendering'
+require 'support/route_mapper'
+
+require 'dispatcher' unless defined?(::Dispatcher)
+::Dispatcher.to_prepare :comatose do
+    Comatose.config.after_setup.call
+end

data/lib/comatose/comatose_drop.rb

@@ -0,0 +1,79 @@
+module Comatose
+
+  class ComatoseDrop < ::Liquid::Drop
+
+    private :initialize
+    
+    def before_method(method)
+      self.send(method.to_sym)
+    rescue
+      ComatoseController.logger.debug "Error calling #{method}: #{$!}"
+      raise $!
+    end
+  
+    class << self
+      # Define a new ComatoseDrop by name
+      def define( name, &block )
+        d = ComatoseDrop.new
+        d.instance_eval(&block)
+        Comatose.registered_drops[name] = d
+      rescue
+        ComatoseController.logger.debug "Drop '#{name}' was not included: #{$!}"
+      end
+    end
+  end
+
+  class << self
+
+    # Returns/initializes a hash for storing ComatoseDrops
+    def registered_drops
+      @registered_drops ||= {}
+    end
+  
+    # Simple wrapper around the ProcessingContext.define method
+    # I think Comatose.define_drop is probably simpler to remember too
+    def define_drop(name, &block)
+      ComatoseDrop.define(name, &block)
+    end
+    
+    # Registers a 'filter' for Liquid use
+    def register_filter(module_name)
+      Liquid::Template.register_filter(module_name)
+    end
+  
+  end
+end
+
+
+#
+# Some Default Filters/Drops
+#
+
+module IncludeFilter
+  def include(input)
+    page = ComatosePage.find_by_path(input)
+    params = @context['params']
+    # TODO: Add more of the context into the included page's context...
+    page.to_html( { 'params' => params  } )
+  rescue
+    "Page at <tt>#{input}</tt> could not be found. <pre>#{$!}</pre>"
+  end
+end
+
+Comatose.register_filter IncludeFilter
+
+
+module TimeagoFilter
+  class Helpers
+    extend ActionView::Helpers::DateHelper
+  end
+  
+  def time_ago(input)
+    TimeagoFilter::Helpers.distance_of_time_in_words_to_now( input, true )
+  rescue
+    #puts "Oops! -- #{$!}"
+    input
+  end
+end
+
+Comatose.register_filter TimeagoFilter

data/lib/comatose/configuration.rb

@@ -0,0 +1,69 @@
+module Comatose
+
+  def self.config
+    @@config ||= Configuration.new
+  end
+
+  def self.configure(&block)
+    raise "#configure must be sent a block" unless block_given?
+    yield config
+    config.validate!
+  end
+  
+  # All of the 'mount' points for Comatose
+  def self.mount_points
+    @@mount_points ||= []
+  end
+
+  # Adds a 'mount' point to the list of known roots...
+  def self.add_mount_point(path, info={:index=>''})
+    path = "/#{path}" unless path.starts_with? '/'
+    info[:root]=path
+    mount_points << info
+  end
+
+  class Configuration
+
+    attr_accessor_with_default :admin_title,          'Comatose'
+    attr_accessor_with_default :admin_includes,       []
+    attr_accessor_with_default :admin_helpers,        []
+    attr_accessor_with_default :admin_sub_title,      'The Micro CMS'
+    attr_accessor_with_default :content_type,         'utf-8'
+    attr_accessor_with_default :default_filter,       'Textile'
+    attr_accessor_with_default :default_processor,    :liquid
+    attr_accessor_with_default :default_tree_level,   2
+    attr_accessor_with_default :disable_caching,      false
+    attr_accessor_with_default :hidden_meta_fields,   []
+    attr_accessor_with_default :helpers,              []
+    attr_accessor_with_default :includes,             []
+    attr_accessor_with_default :allow_import_export,  true
+
+    # 'Blockable' setters
+    blockable_attr_accessor    :authorization
+    blockable_attr_accessor    :admin_authorization
+    blockable_attr_accessor    :admin_get_author
+    blockable_attr_accessor    :admin_get_root_page
+    blockable_attr_accessor    :after_setup
+
+    def initialize
+      # Default procs for blockable attrs....
+      @authorization       = Proc.new { true }
+      @admin_authorization = Proc.new { true }
+      @admin_get_author    = Proc.new { request.env['REMOTE_ADDR'] }
+      @admin_get_root_page = Proc.new { ComatosePage.root }
+      @after_setup         = Proc.new { true }
+    end
+    
+    def validate!
+      # Rips through the config and validates it's, er, valid
+      raise ConfigurationError.new( "admin_get_author must be a Proc or Symbol" ) unless @admin_get_author.is_a? Proc or @admin_get_author.is_a? Symbol
+      raise ConfigurationError.new( "admin_authorization must be a Proc or Symbol" ) unless @admin_authorization.is_a? Proc or @admin_authorization.is_a? Symbol
+      raise ConfigurationError.new( "authorization must be a Proc or Symbol" ) unless @authorization.is_a? Proc or @authorization.is_a? Symbol
+      true
+    end
+    
+    class ConfigurationError < StandardError; end
+    
+  end
+
+end

data/lib/comatose/page_wrapper.rb

@@ -0,0 +1,119 @@
+# Giving direct access to the AR model is disconcerting, so this wraps the AR
+# Model to prevent access to certain, destructive behavior
+class Comatose::PageWrapper
+  
+  @@allowed_methods = %w(id full_path uri slug keywords title to_html filter_type author updated_on created_on)
+  @@custom_methods = %w(link content parent next previous children rchildren first_child last_child has_keyword)
+  
+  attr_accessor :page
+  private :page 
+
+  def initialize( page, locals={} )
+    @page = page
+    @keyword_lst = []
+    @keyword_hsh = {}
+    unless page.nil?
+      @keyword_lst = (page.keywords || '').downcase.split(',').map {|k| k.strip }
+      @keyword_lst.each {|kw| @keyword_hsh[kw] = true}
+    end
+    @locals = locals
+  end
+  
+  def has_keyword?(keyword)
+    @page.has_keyword?(keyword)
+  end
+
+  def has_keyword
+    @keyword_hsh
+  end
+  
+  def next
+    @next_page ||= begin
+      if @page.lower_item.nil?
+        nil
+      else
+        Comatose::PageWrapper.new( @page.lower_item )
+      end
+    end
+  end
+  
+  def previous
+    @prev_page ||= begin
+      if @page.higher_item.nil?
+        nil
+      else
+        Comatose::PageWrapper.new( @page.higher_item )
+      end
+    end
+  end
+  
+  def first_child
+    children.first
+  end
+  
+  def def last_child
+    children.last
+  end
+  
+  # Generates a link to this page... You can pass in the link text, 
+  # otherwise it will default to the page title.
+  def link( title=nil )
+    title = @page.title if title.nil?
+    TextFilters[@page.filter_type].create_link(title, @page.uri)
+  end
+  
+  def content
+    @page.to_html( @locals )
+  end
+
+  def parent
+    @parent ||= begin
+      if @page.parent.nil?
+        nil
+      else
+        Comatose::PageWrapper.new( @page.parent )
+      end
+    end
+  end
+  
+  def children
+    # Cache the results so that you can have multiple calls to #children without a penalty
+    @children ||= @page.children.to_a.collect {|child| Comatose::PageWrapper.new( child, @locals )}
+  end
+  
+  # Children, in reverse order
+  def rchildren
+    children.reverse
+  end
+  
+  def [](key)
+    if @@allowed_methods.include? key.to_s #or page.attributes.has_key? key.to_s
+      page.send( key )
+    elsif @@custom_methods.include? key
+      self.send(key.to_sym)
+    end
+  end
+  
+  def has_key?(key)
+    @@allowed_methods.include? key or @@custom_methods.include? key
+  end
+  
+  def to_s
+    @page.title
+  end
+  
+  def to_liquid
+    self
+  end
+  
+  def method_missing(method_id, *args)
+    #STDERR.puts "Looking for method: #{method_id} (#{method_id.class.to_s}) in [#{@@allowed_methods.join(', ')}] or [#{page.attributes.keys.join(', ')}]"
+    if @@allowed_methods.include? method_id.to_s or page.attributes.has_key? method_id.to_s
+      page.send( method_id, *args)
+    else
+      # Access nazi says: NO ACCESS FOR YOU!!
+      # but he says it silently...
+    end
+  end
+
+end

data/lib/comatose/processing_context.rb

@@ -0,0 +1,69 @@
+# This is the rendering context object you have access to in text processing...
+class Comatose::ProcessingContext
+  @@supported_methods = %w(page include)
+
+  def initialize( page, locals={} )
+    @locals = locals.stringify_keys if locals.respond_to? :stringify_keys
+    @page = Comatose::PageWrapper.new(page, @locals)
+  end
+
+  def page
+    @page
+  end
+
+  def include(path, locals={})
+    begin
+      page = ComatosePage.find_by_path(path)
+      page.to_html( @locals.merge(locals) )
+    rescue
+      "<p>Page at <tt>#{path}</tt> could not be found.</p>"
+    end
+  end
+
+  def find_by_path(path)
+    begin
+      page = ComatosePage.find_by_path(path)
+      Comatose::PageWrapper.new(page, @locals)
+    rescue
+      "<p>Page at <tt>#{path}</tt> could not be found.</p>"
+    end
+  end
+
+  def [](key)
+    if key.to_s.downcase == 'page'
+      @page
+    elsif @locals.has_key? key
+      @locals[key]
+    elsif Comatose.registered_drops.has_key? key
+      Comatose.registered_drops[key]
+    end
+  end
+
+  def has_key?(key)
+    @@supported_methods.include?(key) or @locals.has_key?(key) or Comatose.registered_drops.has_key?(key)
+  end
+
+  def to_liquid
+    self
+  end
+
+  def get_binding
+    binding
+  end
+
+  def method_missing(method_id, *args)
+    method_name = method_id.to_s
+    if @locals.has_key? method_name
+      @locals[method_name]
+    elsif Comatose.registered_drops.has_key? method_name
+      Comatose.registered_drops[method_name].context = self
+      Comatose.registered_drops[method_name]
+    else
+      "<!-- ProcessingContext: Couldn't find #{method_id} -->"
+    end
+  end
+
+end
+
+
+

data/lib/comatose/tasks/admin.rb

@@ -0,0 +1,60 @@
+require 'rake'
+require 'rake/tasklib'
+
+namespace :comatose do
+  #
+  # Customization Tasks
+  #
+  namespace :admin do
+
+    desc "Create Comatose views, layouts, and public files..."
+    task :customize do
+      puts "Copying public files..."
+      plugin_dir = File.join(File.dirname(__FILE__), '../../..')
+      FileUtils.cp( 
+        Dir[File.join(plugin_dir, 'resources', 'public', 'stylesheets', '*.css')], 
+        File.join(RAILS_ROOT, 'public', 'stylesheets'),
+        :verbose => true
+      )
+      FileUtils.cp( 
+        Dir[File.join(plugin_dir, 'resources', 'public', 'javascripts', '*.js')], 
+        File.join(RAILS_ROOT, 'public', 'javascripts'),
+        :verbose => true
+      )
+      puts "Copying application views..."
+      FileUtils.mkdir_p(File.join(RAILS_ROOT, 'app', 'views', 'comatose_admin'))
+      FileUtils.cp( 
+        Dir[File.join(plugin_dir, 'views', 'comatose_admin', '*.html.erb')], 
+        File.join(RAILS_ROOT, 'app', 'views', 'comatose_admin'),
+        :verbose => true
+      )
+      puts "Copying application layout..."
+      FileUtils.cp( 
+        File.join(plugin_dir, 'views', 'layouts', 'comatose_admin_customize.html.erb'), 
+        File.join(RAILS_ROOT, 'app', 'views', 'layouts', 'comatose_admin.html.erb'),
+        :verbose => true
+      )
+      puts "Finished."
+    end
+
+
+    desc "Removes the customized files... It doesn't ask for any confirmation, nor is it Subversion-safe -- so be warned!"
+    task :teardown do
+      puts "Removing public files..."
+      FileUtils.rm(
+        File.join(RAILS_ROOT, 'public', 'stylesheets', 'comatose_admin.css')
+      )
+      FileUtils.rm(
+        File.join(RAILS_ROOT, 'public', 'javascripts', 'comatose_admin.js')
+      )
+    
+      puts "Removing application views..."
+      FileUtils.rm_rf(
+        File.join(RAILS_ROOT, 'app', 'views', 'comatose_admin')
+      )
+      FileUtils.rm(
+        File.join(RAILS_ROOT, 'app', 'views', 'layouts', 'comatose_admin.html.erb')
+      )
+    end
+  end
+end

data/lib/comatose/tasks/data.rb

@@ -0,0 +1,82 @@
+require 'rake'
+require 'rake/tasklib'
+
+namespace :comatose do
+  #
+  # Data Migration Tasks
+  #
+  namespace :data do
+    
+    def page_to_hash(page)
+      data = page.attributes.clone
+      # Pull out the specific, or unnecessary fields
+      %w(id parent_id updated_on author position version created_on 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)
+      child_ary = hsh.delete 'children'
+      page.update_attributes(hsh)
+      page.save
+      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
+
+    desc "Saves a page tree from page FROM or '' to file TO_FILE or db/comatose-pages.yml"
+    task :export do 
+      require "#{RAILS_ROOT}/config/environment"
+
+      root = ENV['FROM'] || ''
+      target = ENV['TO_FILE'] || 'db/comatose-pages.yml'
+      # Nested hash of the page tree...
+      from = ComatosePage.find_by_path(root)
+      if from
+        data = page_to_hash( from ) 
+        File.open(target, 'w') {|f| f.write data.to_yaml }
+      else
+        puts "Could not find the page at '#{root}', export aborted!"      
+      end
+
+      puts "Finished."
+    end
+
+    desc "Loads page tree data FROM_FILE or db/comatose-pages.yml in to TO or ComatosePage.root"
+    task :import do 
+      require "#{RAILS_ROOT}/config/environment"
+
+      src = ENV['FROM_FILE'] || 'db/comatose-pages.yml'
+      root = ENV['TO'] || ''
+      target = (root == '') ? ComatosePage.root : ComatosePage.find_by_path(root)
+      data = YAML::load( File.open(src) )
+      #hash_to_page(data, target)
+      if target
+        if root == ''
+          hash_to_page_tree(data, target)
+        else
+          if page = target.children.find_by_slug(data['slug'])
+            hash_to_page_tree(data, page)
+          else
+            hash_to_page_tree(data, target.children.create)
+          end
+        end
+      else
+        puts "Could not find the page at '#{root}', import aborted!"
+        # TODO: Ask to create the specified path if it doesn't exist?
+      end
+      puts "Finished."
+    end
+
+  end
+
+end