comatose-rubyisbeautiful 3.0.0

data/lib/comatose/text_filters.rb

@@ -0,0 +1,148 @@
+require 'support/class_options'
+module Comatose
+  class TextFilters
+
+    define_option :default_processor, :erb
+    define_option :default_filter, :none
+    define_option :logger, Comatose.logger
+
+    @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=TextFilters.default_processor)
+      processed_text = nil
+      #Comatose.logger.debug "text before process: #{text}"
+      case
+      when processor == :erb
+        processed_text = process_with_erb(text, context)
+      when processor == :liquid
+        processed_text = process_with_liquid(text, context)
+      else
+        raise "Unknown Text Processor '#{processor.to_s}'"
+      end
+      #Comatose.logger.debug "text after process: #{processed_text}"
+      return processed_text
+    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
+          #Comatose.logger.debug "Filter '#{name}' was not included: #{$!}" unless TextFilters.logger.nil?
+        rescue
+          #Comatose.logger.debug "Filter '#{name}' was not included: #{$!}" unless TextFilters.logger.nil?
+        end
+      end
+
+
+      def get_filter(name)
+        #Comatose.logger.debug "get_filter: #{name}"
+        name = TextFilters.default_filter if name.nil?
+        name = registered_titles[name] if name.is_a? String
+        registered_filters[name]
+      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)
+        #Comatose.logger.debug "transform with text #{text}"
+        #Comatose.logger.debug "transform with context #{context}"
+        #Comatose.logger.debug "transform with name #{name}"
+        #Comatose.logger.debug "transform with processor #{processor}"
+        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
+
+
+
+    def process_with_erb(text, context)
+      Comatose.logger.debug "process erb before: #{text}"
+      output = ERB.new(text).result(context.get_binding)
+      Comatose.logger.debug "process erb after: #{output}"
+      return output
+    rescue => e
+      Comatose.logger.debug e.backtrace.join("\n")
+      raise "ERB Error: #{$!}"
+    end
+
+
+
+    def process_with_liquid(text, context={})
+      #Comatose.logger.debug "process liquid before: text: #{text}"
+      #Comatose.logger.debug "process liquid before: context: #{context}"
+      #context = context.stringify_keys if context.respond_to? :stringify_keys
+      Liquid::Template.parse(text).render(context)
+    rescue => e
+      Comatose.logger.debug e.backtrace.join("\n")
+      raise "Liquid Error: #{$!}"
+    end
+
+
+  end
+end

data/lib/comatose/version.rb

@@ -0,0 +1,9 @@
+module Comatose
+  VERSION = "3.0.0"
+  VERSION_STRING = "#{VERSION}  (beta)"
+
+  def self.version
+    VERSION
+  end
+
+end

data/lib/comatose.rb

@@ -0,0 +1,88 @@
+require 'acts_as_versioned'
+require 'acts_as_list'
+require 'acts_as_tree_rails3'
+require 'redcloth'
+require 'liquid'
+require 'i18n'
+
+
+require 'comatose/logger'
+
+module Comatose
+
+  class <<self
+
+    def logger
+      comatose_logger = nil
+      begin
+        comatose_logger = Rails.logger
+      rescue
+      end
+
+      if comatose_logger.blank?
+        comatose_logger = Comatose::Logger.new(File.join(self.root, 'comatose.log'))
+        comatose_logger.level = Logger::DEBUG
+        comatose_logger.formatter = Logger::Formatter.new
+      end
+      return comatose_logger
+    end
+
+
+    def gem_root
+      gem_root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+    end
+
+
+    def root
+      comatose_root = nil
+      begin
+        comatose_root = Rails.root
+      rescue
+      end
+
+      if comatose_root.blank?
+        comatose_root = Comatose.gem_root
+      end
+      return comatose_root
+    end
+
+  end
+
+  class ConfigurationError < StandardError; end
+
+end
+
+require 'comatose/engine'
+require 'comatose/locale_constraint'
+require 'comatose/routes'
+
+require 'support/class_options'
+
+require 'comatose/configuration'
+require 'comatose/drop'
+require 'comatose/page_wrapper'
+require 'comatose/processing_context'
+require 'comatose/text_filters'
+require 'comatose/version'
+
+require 'support/inline_rendering'
+
+Dir[File.join(File.dirname(__FILE__), 'text_filters', '*.rb')].each do |path|
+  require "text_filters/#{File.basename(path)}"
+end
+
+Dir[File.join(File.dirname(__FILE__), 'comatose/filters', '*.rb')].each do |path|
+  require "comatose/filters/#{File.basename(path)}"
+end
+
+
+
+
+#require 'support/route_mapper'
+#
+#
+#
+## BCT - TODO: some hook into the greater Rails events it seems
+##::Dispatcher.to_prepare :comatose do
+#    Comatose.config.after_setup.call
+##end

data/lib/generators/comatose/USAGE

@@ -0,0 +1,7 @@
+Description:
+    The comatose generator creates a migration for the comatose model and adds routes.
+
+    The generator creates a migration class in db/migrate.
+
+Example:
+    ./script/generate comatose

data/lib/generators/comatose/comatose_generator.rb

@@ -0,0 +1,37 @@
+require 'rails/generators/base'
+require 'rails/generators/active_record'
+require 'rails/generators/migration'
+
+module Comatose
+  module Generators
+    class ComatoseGenerator < Rails::Generators::NamedBase
+
+      namespace :comatose
+      source_root File.expand_path("../templates", __FILE__)
+
+      include Rails::Generators::Migration
+      extend ActiveRecord::Generators::Migration
+
+
+      def create_migration_file
+        migration_template "migration.erb", "db/migrate/add_comatose_support.rb"
+      end
+
+
+      def create_init_file
+        template "comatose.rb", "config/initializers/comatose.rb"
+      end
+
+
+      def copy_rake_files
+        # TODO
+      end
+
+
+      def copy_assets
+        # TODO
+      end
+
+    end
+  end
+end

data/lib/generators/comatose/templates/comatose.rb

@@ -0,0 +1,33 @@
+Comatose.configure do |config|
+  config.admin_title         = 'Comatose'
+  config.admin_includes      = []
+  config.admin_helpers       = []
+  config.admin_sub_title     = 'The Micro CMS'
+  config.content_type        = 'utf-8'
+  config.default_filter      = 'None'
+  config.default_processor   = :erb
+  config.default_tree_level  = 2
+  config.disable_caching     = false
+  config.hidden_meta_fields  = []
+  config.helpers             = []
+  config.includes            = []
+  config.allow_import_export = true
+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

data/lib/generators/comatose/templates/migration.erb

@@ -0,0 +1,32 @@
+# class Comatose::Page < ActiveRecord::Base
+#   set_table_name 'comatose_pages'
+#   acts_as_versioned :table_name =>'comatose_page_versions', :if_changed => [ :title, :slug, :keywords, :body ]
+# end
+
+class AddComatoseSupport < ActiveRecord::Migration
+
+    # Schema for Comatose version 3.0.0+
+    def self.up
+      create_table :comatose_pages do |t|
+        t.integer   "parent_id"
+        t.text      "full_path",   :default => ''
+        t.string    "title",       :limit => 255
+        t.string    "slug",        :limit => 255
+        t.string    "keywords",    :limit => 255
+        t.string    "layout"
+        t.text      "body"
+        t.string    "filter_type", :limit => 25, :default => "Textile"
+        t.string    "author",      :limit => 255
+        t.integer   "position",    :default => 0
+        t.integer   "version"
+        t.timestamps
+      end
+
+      Comatose::Page.create_versioned_table rescue "Skipping Comatose::Page.create_versioned_table"
+    end
+
+    def self.down
+      Comatose::Page.drop_versioned_table rescue "Skipping Comatose::Page.drop_versioned_table"
+      drop_table :comatose_pages
+    end
+end

data/lib/generators/comatose/templates/seeds.erb

@@ -0,0 +1,2 @@
+puts "Creating the default 'Home Page'..."
+Comatose::Page.create( :title=>'Home Page', :body=>"h1. Welcome\n\nYour content goes here...", :author=>'System' )

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 = Comatose::Page.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,51 @@
+#class ActionController::Routing::RouteSet::Mapper
+#
+#  # For mounting a page to a path
+#  def comatose_root(path, options={ })
+#    opts = {
+#        :index        => '',
+#        :layout       => 'base.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?
+#      #Rails.routes.add_named_route(name, *args)
+#    end
+#  end
+#end

data/lib/tasks/comatose.rake

@@ -0,0 +1,9 @@
+begin
+  require 'comatose/version'
+rescue LoadError
+  $: << File.join(File.dirname(__FILE__), '..', 'lib')
+end
+
+require 'comatose/tasks/admin'
+require 'comatose/tasks/setup'
+require 'comatose/tasks/data'

data/lib/text_filters/markdown.rb

@@ -0,0 +1,14 @@
+#
+# MARKDOWN
+#
+Comatose::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
+#
+Comatose::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
+#
+Comatose::TextFilters.define :none, "[No Filter]" do
+  def render_text(text)
+    text
+  end
+end

data/lib/text_filters/rdoc.rb

@@ -0,0 +1,13 @@
+#
+# RDOC
+#
+Comatose::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
+#
+Comatose::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
+#
+Comatose::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/public/404.html

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>The page you were looking for doesn't exist (404)</title>
+  <style type="text/css">
+    body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
+    div.dialog {
+      width: 25em;
+      padding: 0 4em;
+      margin: 4em auto 0 auto;
+      border: 1px solid #ccc;
+      border-right-color: #999;
+      border-bottom-color: #999;
+    }
+    h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
+  </style>
+</head>
+
+<body>
+  <!-- This file lives in public/404.html -->
+  <div class="dialog">
+    <h1>The page you were looking for doesn't exist.</h1>
+    <p>You may have mistyped the address or the page may have moved.</p>
+  </div>
+</body>
+</html>

data/public/422.html

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>The change you wanted was rejected (422)</title>
+  <style type="text/css">
+    body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
+    div.dialog {
+      width: 25em;
+      padding: 0 4em;
+      margin: 4em auto 0 auto;
+      border: 1px solid #ccc;
+      border-right-color: #999;
+      border-bottom-color: #999;
+    }
+    h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
+  </style>
+</head>
+
+<body>
+  <!-- This file lives in public/422.html -->
+  <div class="dialog">
+    <h1>The change you wanted was rejected.</h1>
+    <p>Maybe you tried to change something you didn't have access to.</p>
+  </div>
+</body>
+</html>

data/public/500.html

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>We're sorry, but something went wrong (500)</title>
+  <style type="text/css">
+    body { background-color: #fff; color: #666; text-align: center; font-family: arial, sans-serif; }
+    div.dialog {
+      width: 25em;
+      padding: 0 4em;
+      margin: 4em auto 0 auto;
+      border: 1px solid #ccc;
+      border-right-color: #999;
+      border-bottom-color: #999;
+    }
+    h1 { font-size: 100%; color: #f00; line-height: 1.5em; }
+  </style>
+</head>
+
+<body>
+  <!-- This file lives in public/500.html -->
+  <div class="dialog">
+    <h1>We're sorry, but something went wrong.</h1>
+    <p>We've been notified about this issue and we'll take a look at it shortly.</p>
+  </div>
+</body>
+</html>