merb_comatose 0.0.2

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 YOUR NAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,4 @@
+merb_comatose
+=============
+
+A plugin for the Merb framework that provides ...

data/Rakefile

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+
+require 'merb-core'
+require 'merb-core/tasks/merb'
+
+GEM_NAME = "merb_comatose"
+GEM_VERSION = "0.0.2"
+AUTHOR = "Jacques Crocker"
+EMAIL = "merbjedi@gmail.com"
+HOMEPAGE = "http://merbjedi.com/"
+SUMMARY = "Partial Port of Comatose with focus on rendering from Comatose Pages (no admin yet)"
+
+spec = Gem::Specification.new do |s|
+  s.rubyforge_project = 'merb'
+  s.name = GEM_NAME
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+
+  # s.add_dependency('merb', '>= 1.0')
+
+  s.require_path = 'lib'
+  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,spec}/**/*")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the plugin as a gem"
+task :install do
+  Merb::RakeHelper.install(GEM_NAME, :version => GEM_VERSION)
+end
+
+desc "Uninstall the gem"
+task :uninstall do
+  Merb::RakeHelper.uninstall(GEM_NAME, :version => GEM_VERSION)
+end
+
+desc "Create a gemspec file"
+task :gemspec do
+  File.open("#{GEM_NAME}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end

data/TODO

@@ -0,0 +1,5 @@
+TODO:
+Fix LICENSE with your name
+Fix Rakefile with your name and contact info
+Add your code to lib/merb_comatose.rb
+Add your Merb rake tasks to lib/merb_comatose/merbtasks.rb

data/lib/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/comatose/comatose_drop.rb

@@ -0,0 +1,64 @@
+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
+

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,       '[No Filter]'
+    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/version.rb

@@ -0,0 +1,4 @@
+module Comatose
+  VERSION = "2.0.5"
+  VERSION_STRING = "#{VERSION}  (beta)"
+end

data/lib/liquid/block.rb

@@ -0,0 +1,96 @@
+module Liquid
+  
+  class Block < Tag
+    def parse(tokens)
+      @nodelist ||= []
+      @nodelist.clear
+
+      while token = tokens.shift 
+
+        case token
+        when /^#{TagStart}/                   
+          if token =~ /^#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}$/
+
+            # if we found the proper block delimitor just end parsing here and let the outer block
+            # proceed                               
+            if block_delimiter == $1
+              end_tag
+              return
+            end
+
+            # fetch the tag from registered blocks
+            if tag = Template.tags[$1]
+              @nodelist << tag.new($2, tokens)
+            else
+              # this tag is not registered with the system 
+              # pass it to the current block for special handling or error reporting
+              unknown_tag($1, $2, tokens)
+            end              
+          else
+            raise SyntaxError, "Tag '#{token}' was not properly terminated with regexp: #{TagEnd.inspect} "
+          end
+        when /^#{VariableStart}/
+          @nodelist << create_variable(token)
+        when ''
+          # pass
+        else
+          @nodelist << token
+        end
+      end       
+      
+      # Make sure that its ok to end parsing in the current block. 
+      # Effectively this method will throw and exception unless the current block is 
+      # of type Document 
+      assert_missing_delimitation!
+    end                     
+    
+    def end_tag      
+    end
+
+    def unknown_tag(tag, params, tokens)
+      case tag 
+      when 'else'
+        raise SyntaxError, "#{block_name} tag does not expect else tag"
+      when 'end'
+        raise SyntaxError, "'end' is not a valid delimiter for #{block_name} tags. use #{block_delimiter}"
+      else
+        raise SyntaxError, "Unknown tag '#{tag}'"
+      end
+    end
+
+    def block_delimiter
+      "end#{block_name}"
+    end                           
+
+    def block_name
+      self.class.name.scan(/\w+$/).first.downcase
+    end
+
+    def create_variable(token)
+      token.scan(/^#{VariableStart}(.*)#{VariableEnd}$/) do |content|
+        return Variable.new(content.first)
+      end
+      raise SyntaxError.new("Variable '#{token}' was not properly terminated with regexp: #{VariableEnd.inspect} ")
+    end
+
+    def render(context)
+      render_all(@nodelist, context)
+    end
+
+    protected
+
+    def assert_missing_delimitation!
+      raise SyntaxError.new("#{block_name} tag was never closed")
+    end
+
+    def render_all(list, context)
+      list.collect do |token|
+        if token.respond_to?(:render)
+          token.render(context)
+        else
+          token.to_s
+        end
+      end      
+    end
+  end  
+end