comatose-rubyisbeautiful 3.0.0

data/lib/comatose/page_wrapper.rb

@@ -0,0 +1,147 @@
+# Giving direct access to the AR model is disconcerting, so this wraps the AR
+# Model to prevent access to certain, destructive behavior
+module Comatose
+  class PageWrapper
+
+    @@allowed_methods   = %w( id full_path uri slug keywords title to_html filter_type author updated_at created_at )
+    @@custom_methods    = %w( link content parent next previous children rchildren first_child last_child has_keyword current_user )
+
+    attr_accessor :page, :current_user
+    #private :page
+
+    def initialize(page, locals={}, system={})
+      @current_user = system[:current_user]
+      @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
+    rescue => e
+      Comatose.logger.debug e.message
+      Comatose.logger.debug e.backtrace.join("\n")
+    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)
+      Comatose.logger.debug "using [] to find key: #{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)
+      #Comatose.logger.debug "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
+        #Comatose.logger.debug "sending method_id to page"
+        page_value = page.send(method_id, *args)
+        #Comatose.logger.debug "page returned: #{page_value}"
+        return page_value
+      else
+        # Access nazi says: NO ACCESS FOR YOU!!
+        # but he says it silently...
+        Comatose.logger.debug("PageWrapper#method_missing: could not find #{method_id}")
+      end
+    end
+
+  end
+end

data/lib/comatose/processing_context.rb

@@ -0,0 +1,103 @@
+# This is the rendering context object you have access to in text processing...
+module Comatose
+  class ProcessingContext < Hash
+    @@supported_methods = %w( page include current_user )
+
+    attr_accessor :locals, :page, :current_user, :system
+
+
+    def initialize(page, params={})
+      params = params.stringify_keys rescue params
+      #Comatose.logger.debug("params in ProcessingContext: #{params}")
+      @system       = params.delete('system')  || {}
+      @current_user = @system['current_user']
+      @locals = params
+      @page = Comatose::PageWrapper.new(page, @locals, @system)
+      #rescue => e
+      #  Comatose.logger.debug "ProcessingContext: initialize: #{e.message}"
+      #  Comatose.logger.debug e.backtrace.join("\n")
+      #  raise e
+    end
+
+
+      #def include(path, locals={})
+      #  begin
+      #    page = Page.find_by_path(path)
+      #    page.to_html(self[:locals].merge(locals) )
+      #  rescue
+      #    "<p>Page at <tt>#{path}</tt> could not be found.</p>"
+      #  end
+      #end
+
+
+    def find_by_path(path)
+      begin
+        # page = Page.find_by_path(path)
+        Page.send(Comatose.config.page_finder, path)
+        Comatose::PageWrapper.new(page, self[:locals])
+      rescue
+        "<p>Page at <tt>#{path}</tt> could not be found.</p>"
+      end
+    end
+
+
+    def [](key)
+      #Comatose.logger.debug "[] called with key: #{key}"
+      #Comatose.logger.debug "current_user: #{current_user.to_s}"
+      case
+        when key.to_s.downcase == 'page'
+          @page
+        when key.to_s.downcase == 'current_user'
+          @current_user
+        when locals.has_key?(key)
+          locals[key]
+        when 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 inspect
+      h = self.dup.merge(:page => page, :current_user => current_user, :locals => locals)
+    end
+
+
+    def method_missing(method_id, *args)
+      #Comatose.logger.debug("processing_context: method_missing: method: #{method_id}")
+      #Comatose.logger.debug("processing_context: method_missing: args: #{args}")
+      method_name = method_id.to_s
+      case
+        when locals.has_key?(method_name)
+          locals[method_name]
+        when page.respond_to?(method_name)
+          page.send(method_name, args)
+        when Comatose.registered_drops.has_key?(method_name)
+          Comatose.registered_drops[method_name].context = self
+          Comatose.registered_drops[method_name].send(args)
+        #else Hash.respond_to?(method_id)
+        #  super(method_id, args)
+        #else
+        #  "ProcessingContext: Couldn't find #{method_id}"
+      end
+    end
+
+  end
+end
+
+
+

data/lib/comatose/routes.rb

@@ -0,0 +1,70 @@
+require 'action_dispatch/routing/mapper'
+
+module Comatose
+  module Routes
+
+    def routes_for_comatose(opts={}, &block)
+      Comatose.logger.debug("routes_for_comatose options: #{opts}")
+      case
+        when opts.empty?
+          scope :module => "comatose" do
+            constraints(LocaleConstraint) do
+              match '/:locale/:page', :to => 'base#show'
+              match '/:locale',       :to => 'base#show', :as => 'comatose_root'
+            end
+          end
+        when opts[:mount]
+          scope :module => "comatose" do
+            constraints(LocaleConstraint) do
+              match "/:locale/#{opts[:mount]}/:page", :to => 'base#show', :index => opts[:mount]
+              match "/:locale/#{opts[:mount]}",       :to => 'base#show', :index => opts[:mount], :as => "#{opts[:mount].underscore}_comatose_root"
+            end
+          end
+          Comatose.add_mount_point(opts[:mount], { :index => opts[:index] || '' })
+      end
+    end
+
+
+    def admin_routes_for_comatose(opts={}, &block)
+      Comatose.logger.debug("routes_for_comatose options: #{opts}")
+      case
+        when opts.empty?
+          namespace(:comatose, :path => "/:locale/comatose") do
+            constraints(LocaleConstraint) do
+              match '', :to => 'admin#index'
+              resources :pages, :controller => 'admin' do
+                collection do
+                  post :import
+                  get :export, :expire
+                end
+
+                member do
+                  get :preview, :versions, :reorder
+                end
+              end
+            end
+          end
+        when opts[:mount]
+          namespace(:comatose, :path => "/:locale/comatose") do
+          #  defaults :index => opts[:mount]  do
+              constraints(LocaleConstraint) do
+                match '', :to => 'admin#index'
+                resources :pages, :controller => 'admin' do
+                  collection do
+                    post :import
+                    get :export, :expire
+                  end
+
+                  member do
+                    get :preview, :versions, :reorder
+                  end
+                end
+              end
+            #end
+          end
+      end
+    end
+
+
+  end
+end

data/lib/comatose/tasks/admin.rb

@@ -0,0 +1,57 @@
+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', 'admin.css')
+      )
+      FileUtils.rm(
+        File.join(RAILS_ROOT, 'public', 'javascripts', '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,79 @@
+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_at author position version created_at 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 = Comatose::Page.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 Comatose::Page.root"
+    task :import do 
+      require "#{Rails.root}/config/environment"
+
+      src = ENV['FROM_FILE'] || 'db/comatose-pages.yml'
+      root = ENV['TO'] || ''
+      target = (root == '') ? Comatose::Page.root : Comatose::Page.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,118 @@
+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
+      sources         = File.join(Comatose.gem_root, 'public/images/comatose', '*.gif')
+      destination_dir = File.join(Rails.root.to_s, 'public/images/comatose')
+      Comatose.logger.debug "[**Comatose**]: sources: #{sources}"
+      puts "[**Comatose**]: sources: #{sources}"
+      Comatose.logger.debug "[**Comatose**]: destination dir: #{destination_dir}"
+      puts "[**Comatose**]: destination dir: #{destination_dir}"
+      unless FileTest.exist? destination_dir
+        FileUtils.mkdir destination_dir
+      end
+      FileUtils.cp(Dir.glob(sources), destination_dir, :verbose => true)
+      puts "Finished."
+    end
+
+
+    desc "If the installation didn't add the stylesheets correctly, use this task"
+    task :copy_stylesheets do
+      sources         = File.join(Comatose.gem_root, 'public/stylesheets/comatose', '*.css')
+      destination_dir = File.join(Rails.root.to_s, 'public/stylesheets/comatose')
+      Comatose.logger.debug "[**Comatose**]: sources: #{sources}"
+      puts "[**Comatose**]: sources: #{sources}"
+      Comatose.logger.debug "[**Comatose**]: destination dir: #{destination_dir}"
+      puts "[**Comatose**]: destination dir: #{destination_dir}"
+      unless FileTest.exist? destination_dir
+        FileUtils.mkdir destination_dir
+      end
+      FileUtils.cp(Dir.glob(sources), destination_dir, :verbose => true)
+      puts "Finished."
+    end
+
+
+    desc "If the installation didn't add the javascripts correctly, use this task"
+    task :copy_javascripts do
+      sources         = File.join(Comatose.gem_root, 'public/javascripts/comatose', '*.js')
+      destination_dir = File.join(Rails.root.to_s, 'public/javascripts/comatose')
+      Comatose.logger.debug "[**Comatose**]: sources: #{sources}"
+      puts "[**Comatose**]: sources: #{sources}"
+      Comatose.logger.debug "[**Comatose**]: destination dir: #{destination_dir}"
+      puts "[**Comatose**]: destination dir: #{destination_dir}"
+      unless FileTest.exist? destination_dir
+        FileUtils.mkdir destination_dir
+      end
+      FileUtils.cp(Dir.glob(sources), destination_dir, :verbose => true)
+
+      sources         = File.join(Comatose.gem_root, 'public/javascripts/jquery', '*')
+      destination_dir = File.join(Rails.root.to_s, 'public/javascripts/jquery')
+      Comatose.logger.debug "[**Comatose**]: sources: #{sources}"
+      puts "[**Comatose**]: sources: #{sources}"
+      Comatose.logger.debug "[**Comatose**]: destination dir: #{destination_dir}"
+      puts "[**Comatose**]: destination dir: #{destination_dir}"
+      unless FileTest.exist? destination_dir
+        FileUtils.mkdir destination_dir
+      end
+      FileUtils.cp(Dir.glob(sources), destination_dir, :verbose => true)
+
+      #source_tar        = File.join(Comatose.gem_root, 'public/javascripts/wymeditor.tar')
+      #destination_dir   = File.join(Rails.root.to_s, 'public/javascripts')
+      #Comatose.logger.debug "[**Comatose**]: source: #{source_tar}"
+      #puts "[**Comatose**]: source: #{source_tar}"
+      #Comatose.logger.debug "[**Comatose**]: destination dir: #{destination_dir}"
+      #puts "[**Comatose**]: destination dir: #{destination_dir}"
+      #unless FileTest.exist? destination_dir
+      #  FileUtils.mkdir destination_dir
+      #end
+      #FileUtils.cp(source_tar, destination_dir, :verbose => true)
+      #`tar xvf #{File.join(destination_dir, "wymeditor.tar")}`
+
+      sources         = File.join(Comatose.gem_root, 'public/javascripts', '*.js')
+      destination_dir = File.join(Rails.root.to_s, 'public/javascripts')
+      Comatose.logger.debug "[**Comatose**]: sources: #{sources}"
+      puts "[**Comatose**]: sources: #{sources}"
+      Comatose.logger.debug "[**Comatose**]: destination dir: #{destination_dir}"
+      puts "[**Comatose**]: destination dir: #{destination_dir}"
+      unless FileTest.exist? destination_dir
+        FileUtils.mkdir destination_dir
+      end
+      FileUtils.cp(Dir.glob(sources), destination_dir, :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/admin.js'
+      move 'public/stylesheets/comatose.css public/stylesheets/admin.css'
+      move 'app/views/comatose app/views/comatose_admin' 
+      delete 'app/views/layouts/base.html.erb'
+    end
+  end
+end