aslakjo-comatose 2.0.5.2

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

data/lib/comatose/tasks/setup.rb

@@ -0,0 +1,52 @@
+require 'rake'
+require 'rake/tasklib'
+
+namespace :comatose do
+  #
+  # Setup Task...
+  #
+  namespace :setup do
+    
+    desc "If the installation didn't add the images correctly, use this task"
+    task :copy_images do
+      plugin_dir = File.join(File.dirname(__FILE__), '..')
+      unless FileTest.exist? File.join(RAILS_ROOT, 'public', 'images', 'comatose')
+        FileUtils.mkdir( File.join(RAILS_ROOT, 'public', 'images', 'comatose') )
+      end
+      FileUtils.cp( 
+        Dir[File.join(plugin_dir, 'resources', 'public', 'images', '*.gif')], 
+        File.join(RAILS_ROOT, 'public', 'images', 'comatose'),
+        :verbose => true
+      )
+      puts "Finished."
+    end
+    
+    # For use when upgrading...
+    
+    def move(args)
+      if ENV['USE_SVN'] == 'true'
+        `svn move #{args}`
+      else
+        `mv #{args}`
+      end
+    end
+    
+    def delete(args)
+      if ENV['USE_SVN'] == 'true'
+        `svn delete #{args}`
+      else
+        `rm -rf #{args}`
+      end
+    end
+    
+    # TODO: Test the setup:restructure_customization task...
+    desc "[EXPERIMENTAL] Restructures customized admin folder to version 0.6 from older version -- Only run this if you have customized the admin. USE_SVN=true if you want to update subversion"
+    task :restructure_customization do
+      ENV['USE_SVN'] ||= 'false'
+      move 'public/javscripts/comatose.js public/javscripts/comatose_admin.js' 
+      move 'public/stylesheets/comatose.css public/stylesheets/comatose_admin.css' 
+      move 'app/views/comatose app/views/comatose_admin' 
+      delete 'app/views/layouts/comatose_content.html.erb' 
+    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/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