aslakjo-comatose 2.0.5.2

data/lib/support/class_options.rb

@@ -0,0 +1,36 @@
+class Class
+  def define_option(name, default=nil)
+    sym = name.to_sym
+    cattr_reader(sym)
+    cattr_writer(sym)
+    send("#{name.to_s}=", default)
+  end
+  
+  def blockable_attr_accessor(sym)
+    module_eval(<<-EVAL, __FILE__, __LINE__)
+      def #{sym}(&block)
+        if block_given?
+          @#{sym} = block
+        else
+          @#{sym}
+        end
+      end
+      def #{sym}=(value)
+        @#{sym} = value
+      end
+    EVAL
+  end
+end
+
+class Module
+  def attr_accessor_with_default(sym, default = nil, &block)
+    raise 'Default value or block required' unless !default.nil? || block
+    define_method(sym, block_given? ? block : Proc.new { default })
+    module_eval(<<-EVAL, __FILE__, __LINE__)
+      def #{sym}=(value)
+        class << self; attr_reader :#{sym} end
+        @#{sym} = value
+      end
+    EVAL
+  end
+end

data/lib/support/inline_rendering.rb

@@ -0,0 +1,48 @@
+# Extends the view to support rendering inline comatose pages...
+ActionView::Base.class_eval do
+  alias_method :render_otherwise, :render
+  
+  def render(options = {}, old_local_assigns = {}, &block) #:nodoc:
+    if options.is_a?(Hash) && page_name = options.delete(:comatose)
+      render_comatose(page_name, options[:params] || options)
+    else
+      render_otherwise(options, old_local_assigns, &block)
+    end
+  end
+  
+  def render_comatose(page_path, params = {})
+    params = {
+      :silent => false,
+      :use_cache => true,
+      :locals => {}
+    }.merge(params)
+    if params[:use_cache] and params[:locals].empty?
+      render_cached_comatose_page(page_path, params)
+    else
+      render_comatose_page(page_path, params)
+    end
+  end
+  
+protected
+  
+  def render_cached_comatose_page(page_path, params)
+    key = page_path.gsub(/\//, '+')
+    unless html = controller.read_fragment(key)
+      html = render_comatose_page( page_path, params )
+      controller.write_fragment(key, html) unless Comatose.config.disable_caching
+    end
+    html
+  end
+  
+  def render_comatose_page(page_path, params)
+    if page = ComatosePage.find_by_path(page_path)
+      # Add the request params to the context...
+      params[:locals]['params'] = controller.params
+      html = page.to_html( params[:locals] )
+    else
+      html = params[:silent] ? '' : "<p><tt>#{page_path}</tt> not found</p>"
+    end
+  end
+  
+end
+

data/lib/support/route_mapper.rb

@@ -0,0 +1,50 @@
+# For use with 'Edge Rails'
+class ActionController::Routing::RouteSet::Mapper
+
+  # For mounting a page to a path
+  def comatose_root( path, options={} )
+    opts = {
+      :index      => '',
+      :layout     => 'comatose_content.html.erb',
+      :use_cache  => 'true',
+      :cache_path => nil,
+      :named_route=> nil
+    }.merge(options)
+    # Ensure the controller is aware of the mount point...
+    Comatose.add_mount_point(path, opts)
+    # Add the route...
+    opts[:controller] = 'comatose'
+    opts[:action] ='show'
+    route_name = opts.delete(:named_route)
+    unless route_name.nil?
+      named_route( route_name, "#{path}/*page", opts )
+    else
+      if opts[:index] == '' # if it maps to the root site URI, name it comatose_root
+        named_route( 'comatose_root', "#{path}/*page", opts )
+      else
+        connect( "#{path}/*page", opts )
+      end
+    end
+  end
+
+  # For mounting the admin
+  def comatose_admin( path='comatose_admin', options={} )
+    opts = {
+      :controller  => 'comatose_admin',
+      :named_route => 'comatose_admin'
+    }.merge(options)
+    route_name = opts.delete(:named_route)
+    named_route( route_name, "#{path}/:action/:id", opts )
+  end
+    
+  def method_missing( name, *args, &proc )
+    if name.to_s.starts_with?( 'comatose_' )
+      opts = (args.last.is_a?(Hash)) ? args.pop : {}
+      opts[:named_route] = name.to_s #[9..-1]
+      comatose_root( *(args << opts) )
+    else
+      super unless args.length >= 1 && proc.nil?
+      @set.add_named_route(name, *args)
+    end
+  end
+end

data/lib/text_filters/markdown.rb

@@ -0,0 +1,14 @@
+#
+# MARKDOWN
+#
+TextFilters.define :markdown, "Markdown" do
+  require 'bluecloth'
+  
+  def render_text(text)
+    BlueCloth.new(text).to_html
+  end
+  
+  def create_link(title, url)
+    "[#{title}](#{url})"
+  end
+end

data/lib/text_filters/markdown_smartypants.rb

@@ -0,0 +1,15 @@
+#
+# MARKDOWN + SMARTYPANTS
+#
+TextFilters.define :markdown_smartypants, "Markdown + SmartyPants" do
+  require 'bluecloth'
+  require 'rubypants'
+  
+  def render_text(text)
+    RubyPants.new( BlueCloth.new(text).to_html ).to_html
+  end
+  
+  def create_link(title, url)
+    "[#{title}](#{url})"
+  end
+end

data/lib/text_filters/none.rb

@@ -0,0 +1,8 @@
+#
+# NONE
+#
+TextFilters.define :none, "[No Filter]" do
+  def render_text(text)
+    text
+  end
+end

data/lib/text_filters/rdoc.rb

@@ -0,0 +1,13 @@
+#
+# RDOC
+#
+TextFilters.define :rdoc, "RDoc" do
+  require 'rdoc/markup/simple_markup'
+  require 'rdoc/markup/simple_markup/to_html'
+
+  def render_text(text)
+    p = SM::SimpleMarkup.new
+    h = SM::ToHtml.new
+    p.convert(text, h)  
+  end
+end

data/lib/text_filters/simple.rb

@@ -0,0 +1,8 @@
+#
+# SIMPLE
+#
+TextFilters.define :simple, "Simple" do
+  def render_text(text)
+    text.gsub("\n", '<br/>')
+  end
+end

data/lib/text_filters/textile.rb

@@ -0,0 +1,15 @@
+#
+# TEXTILE
+#
+TextFilters.define :textile, "Textile" do
+  require 'redcloth'
+  
+  def render_text(text)
+    RedCloth.new(text).to_html(:refs_markdown, :textile, :markdown)
+  end
+  
+  def create_link(title, url)
+    %Q|"#{title}":#{url}|
+  end
+  
+end

data/lib/text_filters.rb

@@ -0,0 +1,140 @@
+require 'support/class_options'
+
+class TextFilters
+  
+  define_option :default_processor, :liquid
+  define_option :default_filter,    "Textile"
+  define_option :logger,            nil
+  
+  @registered_filters = {}
+  @registered_titles  = {}
+
+  attr_reader :name
+  attr_reader :title
+  def initialize(name, title)
+    @name = name
+    @title = title
+  end
+
+  # The default create_link method...
+  # Override for your specific filter, if needed, in the #define block
+  def create_link(title, url)
+    %Q|<a href="#{url}">#{title}</a>|
+  end
+  
+  # Process the text with using the specified context
+  def process_text(text, context, processor=nil)
+    case (processor || TextFilters.default_processor)
+    when :erb then process_with_erb(text, context)
+    when :liquid then process_with_liquid(text, context)
+    else raise "Unknown Text Processor '#{processor.to_s}'"
+    end
+  end
+  
+  class << self
+    private :new
+    attr_reader :registered_filters
+    attr_reader :registered_titles
+    
+    # Use this to create and register your TextFilters
+    def define(name, title, &block)
+      begin
+        p = new(name, title)
+        p.instance_eval(&block)
+        if p.respond_to? :render_text
+          registered_titles[title] = name
+          registered_filters[name] = p
+        else
+          raise "#render_text isn't implemented in this class"
+        end
+      rescue LoadError
+        TextFilters.logger.debug "Filter '#{name}' was not included: #{$!}" unless TextFilters.logger.nil?
+      rescue
+        TextFilters.logger.debug "Filter '#{name}' was not included: #{$!}" unless TextFilters.logger.nil?
+      end
+    end
+    
+    def get_filter(name)
+      name = TextFilters.default_filter if name.nil?
+      name = registered_titles[name] if name.is_a? String
+      filter = registered_filters[name]
+      raise "No filter found for '#{name}' in registered_titles: #{registered_titles.inspect} or registered_filters: #{registered_filters.inspect}" unless filter
+      filter
+    end
+
+    def [](name)
+      get_filter(name)
+    end
+    
+    def all
+      registered_filters
+    end
+    
+    def all_titles
+      registered_titles.keys
+    end
+
+    def render_text(text, name=nil)
+      get_filter(name).render_text(text)
+    end
+
+    def process_text(text, context=nil, name=nil, processor=nil)
+      get_filter(name).process_text(text, context, processor)
+    end
+
+    # Call
+    def transform(text, context=nil, name=nil, processor=nil)
+      render_text( process_text(text, context, name, processor), name )
+    end
+  end
+  
+private
+
+  # This is an instance method so that it won't puke on requiring
+  # a non-existant library until it's being registered -- the only
+  # place I can really capture the LoadError
+  def require(name)
+    Kernel.require name
+  end
+
+  # Use ERB to process text...
+  def process_with_erb(text, context)
+    begin
+      ERB.new( text ).result( context.get_binding )
+    rescue
+      raise "ERB Error: #{$!}"
+    end
+  end
+
+  # Use Liquid to process text...
+  def process_with_liquid(text, context={})
+    begin
+      context = context.stringify_keys if context.respond_to? :stringify_keys
+      Liquid::Template.parse(text).render(context)
+    rescue
+      raise "Liquid Error: #{$!}"
+    end
+  end
+  
+end
+
+class Hash
+  # Having the method_missing catchall in conjunction with get_binding 
+  # allows us to use the hash as a Context for ERB
+  def method_missing(meth, *arg)
+    if self.has_key? meth.to_s
+      self[meth.to_s]
+    else
+      super
+    end
+  end
+  # Gets the binding object for use with ERB
+  def get_binding
+    binding
+  end
+end
+
+
+Dir[File.join(File.dirname(__FILE__), 'text_filters', '*.rb')].each do |path|
+  require "text_filters/#{File.basename(path)}"
+end

data/rails/init.rb

@@ -0,0 +1,3 @@
+# Init for gem version of Comatose
+
+require 'comatose'

data/resources/layouts/comatose_admin_template.html.erb

@@ -0,0 +1,28 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html class="noscript" xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=<%%= Comatose.config.content_type %>"/>
+    <title>Comatose Admin</title>
+    <%= style_contents %>
+    <%%= javascript_include_tag :defaults %>
+    <%= script_contents %>
+  </head>
+  <body>
+    <div id="page-container">
+      <div id="header">
+        <h1><%%= link_to Comatose.config.admin_title, :controller=>controller.controller_name, :action=>'index' %></h1>
+        <div id="flash">
+          <span id="flash-content"><%%= flash[:notice] %></span>
+        </div>
+        <h5><%%= Comatose.config.admin_sub_title %></h5>
+      </div>
+      <div id="content">
+        <%%= yield %>
+      </div>
+      <div id="footer">
+        Powered by <a href="http://comatose.rubyforge.org" target="_new_window">Comatose <%%= Comatose::VERSION_STRING %></a>, created by <a href="http://www.mattmccray.com"  target="_new_window">M@ McCray</a>.
+      </div>
+    </div>
+  </body>
+</html>