lucy_cms 0.0.1

data/lib/LucyCMS/acts_as_tree.rb

@@ -0,0 +1,102 @@
+module LucyCMS::ActsAsTree
+  
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods
+    def acts_as_tree(options = {})
+      configuration = {
+        :foreign_key    => 'parent_id', 
+        :order          => nil, 
+        :counter_cache  => nil,
+        :dependent      => :destroy,
+        :touch          => false }
+      configuration.update(options) if options.is_a?(Hash)
+      
+      belongs_to :parent,
+        :class_name     => name, 
+        :foreign_key    => configuration[:foreign_key],
+        :counter_cache  => configuration[:counter_cache],
+        :touch          => configuration[:touch]
+        
+      has_many :children,
+        :class_name     => name, 
+        :foreign_key    => configuration[:foreign_key],
+        :order          => configuration[:order],
+        :dependent      => configuration[:dependent]
+        
+      class_eval <<-EOV
+        include LucyCMS::ActsAsTree::InstanceMethods
+        
+        scope :roots,
+          :conditions => "#{configuration[:foreign_key]} IS NULL",
+          :order      => #{configuration[:order].nil? ? "nil" : %Q{"#{configuration[:order]}"}}
+        
+        def self.root
+          roots.first
+        end
+        
+        validates_each "#{configuration[:foreign_key]}" do |record, attr, value|
+          if value
+            if record.id == value
+              record.errors.add attr, "cannot be it's own id"
+            elsif record.descendants.map {|c| c.id}.include?(value)
+              record.errors.add attr, "cannot be a descendant's id"
+            end
+          end
+        end
+        
+      EOV
+    end
+  end
+  
+  module InstanceMethods
+    # Returns list of ancestors, starting from parent until root.
+    #
+    #   subchild1.ancestors # => [child1, root]
+    def ancestors
+      node, nodes = self, []
+      nodes << node = node.parent while node.parent
+      nodes
+    end
+    
+    # Returns all children and children of children
+    def descendants
+      nodes = []
+      self.children.each do |c|
+        nodes << c
+        nodes << c.descendants
+      end
+      nodes.flatten
+    end
+    
+    # Returns the root node of the tree.
+    def root
+      node = self
+      node = node.parent while node.parent
+      node
+    end
+    
+    # Checks if this node is a root
+    def root?
+      !self.parent
+    end
+    
+    # Returns all siblings of the current node.
+    #
+    #   subchild1.siblings # => [subchild2]
+    def siblings
+      self_and_siblings - [self]
+    end
+    
+    # Returns all siblings and a reference to the current node.
+    #
+    #   subchild1.self_and_siblings # => [subchild1, subchild2]
+    def self_and_siblings
+      parent ? parent.children : self.class.roots
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, LucyCMS::ActsAsTree

data/lib/LucyCMS/cms_tag/field_datetime.rb

@@ -0,0 +1,26 @@
+class CmsTag::FieldDateTime < CmsBlock
+  
+  include CmsTag
+  
+  def self.regex_tag_signature(label = nil)
+    label ||= /[\w\-]+/
+    /\{\{\s*cms:field:(#{label}):datetime\s*\}\}/
+  end
+  
+  def regex_tag_signature
+    self.class.regex_tag_signature(label)
+  end
+  
+  def content=(value)
+    write_attribute(:content, value)
+  end
+  
+  def content
+    read_attribute(:content)
+  end
+  
+  def render
+    ''
+  end
+  
+end

data/lib/LucyCMS/cms_tag/field_integer.rb

@@ -0,0 +1,26 @@
+class CmsTag::FieldInteger < CmsBlock
+  
+  include CmsTag
+  
+  def self.regex_tag_signature(label = nil)
+    label ||= /[\w\-]+/
+    /\{\{\s*cms:field:(#{label}):integer\s*\}\}/
+  end
+  
+  def regex_tag_signature
+    self.class.regex_tag_signature(label)
+  end
+  
+  def content=(value)
+    write_attribute(:content, value)
+  end
+  
+  def content
+    read_attribute(:content)
+  end
+  
+  def render
+    ''
+  end
+  
+end

data/lib/LucyCMS/cms_tag/field_string.rb

@@ -0,0 +1,26 @@
+class CmsTag::FieldString < CmsBlock
+  
+  include CmsTag
+  
+  def self.regex_tag_signature(label = nil)
+    label ||= /[\w\-]+/
+    /\{\{\s*cms:field:(#{label}):?(?:string)?\s*\}\}/
+  end
+  
+  def regex_tag_signature
+    self.class.regex_tag_signature(label)
+  end
+  
+  def content=(value)
+    write_attribute(:content, value)
+  end
+  
+  def content
+    read_attribute(:content)
+  end
+  
+  def render
+    ''
+  end
+  
+end

data/lib/LucyCMS/cms_tag/field_text.rb

@@ -0,0 +1,26 @@
+class CmsTag::FieldText < CmsBlock
+  
+  include CmsTag
+  
+  def self.regex_tag_signature(label = nil)
+    label ||= /[\w\-]+/
+    /\{\{\s*cms:field:(#{label}):?(?:text)?\s*?\}\}/
+  end
+  
+  def regex_tag_signature
+    self.class.regex_tag_signature(label)
+  end
+  
+  def content=(value)
+    write_attribute(:content, value)
+  end
+  
+  def content
+    read_attribute(:content)
+  end
+  
+  def render
+    ''
+  end
+  
+end

data/lib/LucyCMS/cms_tag/helper.rb

@@ -0,0 +1,20 @@
+class CmsTag::Helper
+  
+  attr_accessor :label
+  
+  include CmsTag
+  
+  def self.regex_tag_signature(label = nil)
+    label ||= /[\w\-]+/
+    /\{\{\s*cms:helper:(#{label}):?(.*?)\s*\}\}/
+  end
+  
+  def regex_tag_signature
+    self.class.regex_tag_signature(label)
+  end
+  
+  def content
+    "<%= #{label}(#{params.split(':').collect{|p| "'#{p}'"}.join(', ')}) %>"
+  end
+  
+end

data/lib/LucyCMS/cms_tag/page_datetime.rb

@@ -0,0 +1,22 @@
+class CmsTag::PageDateTime < CmsBlock
+  
+  include CmsTag
+  
+  def self.regex_tag_signature(label = nil)
+    label ||= /[\w\-]+/
+    /\{\{\s*cms:page:(#{label}):datetime\s*\}\}/
+  end
+  
+  def regex_tag_signature
+    self.class.regex_tag_signature(label)
+  end
+  
+  def content=(value)
+    write_attribute(:content, value)
+  end
+  
+  def content
+    read_attribute(:content)
+  end
+  
+end

data/lib/LucyCMS/cms_tag/page_integer.rb

@@ -0,0 +1,22 @@
+class CmsTag::PageInteger < CmsBlock
+  
+  include CmsTag
+  
+  def self.regex_tag_signature(label = nil)
+    label ||= /[\w\-]+/
+    /\{\{\s*cms:page:(#{label}):integer\s*\}\}/
+  end
+  
+  def regex_tag_signature
+    self.class.regex_tag_signature(label)
+  end
+  
+  def content=(value)
+    write_attribute(:content, value)
+  end
+  
+  def content
+    read_attribute(:content)
+  end
+  
+end

data/lib/LucyCMS/cms_tag/page_rich_text.rb

@@ -0,0 +1,22 @@
+class CmsTag::PageRichText < CmsBlock
+  
+  include CmsTag
+  
+  def self.regex_tag_signature(label = nil)
+    label ||= /[\w\-]+/
+    /\{\{\s*cms:page:(#{label}):rich_text\s*\}\}/
+  end
+  
+  def regex_tag_signature
+    self.class.regex_tag_signature(label)
+  end
+  
+  def content=(value)
+    write_attribute(:content, value)
+  end
+  
+  def content
+    read_attribute(:content)
+  end
+  
+end

data/lib/LucyCMS/cms_tag/page_string.rb

@@ -0,0 +1,22 @@
+class CmsTag::PageString < CmsBlock
+  
+  include CmsTag
+  
+  def self.regex_tag_signature(label = nil)
+    label ||= /[\w\-]+/
+    /\{\{\s*cms:page:(#{label}):string\s*\}\}/
+  end
+  
+  def regex_tag_signature
+    self.class.regex_tag_signature(label)
+  end
+  
+  def content=(value)
+    write_attribute(:content, value)
+  end
+  
+  def content
+    read_attribute(:content)
+  end
+  
+end

data/lib/LucyCMS/cms_tag/page_text.rb

@@ -0,0 +1,22 @@
+class CmsTag::PageText < CmsBlock
+  
+  include CmsTag
+  
+  def self.regex_tag_signature(label = nil)
+    label ||= /[\w\-]+/
+    /\{\{\s*cms:page:(#{label}):?(?:text)?\s*\}\}/
+  end
+  
+  def regex_tag_signature
+    self.class.regex_tag_signature(label)
+  end
+  
+  def content=(value)
+    write_attribute(:content, value)
+  end
+  
+  def content
+    read_attribute(:content)
+  end
+  
+end

data/lib/LucyCMS/cms_tag/partial.rb

@@ -0,0 +1,21 @@
+class CmsTag::Partial
+  
+  attr_accessor :label
+  
+  include CmsTag
+  
+  def self.regex_tag_signature(label = nil)
+    label ||= /[\w\/\-]+/
+    /\{\{\s*cms:partial:(#{label}):?(.*?)\s*\}\}/
+  end
+  
+  def regex_tag_signature
+    self.class.regex_tag_signature(label)
+  end
+  
+  def content
+    ps = params.split(':').collect_with_index{|p, i| ":param_#{i+1} => '#{p}'"}.join(', ')
+    "<%= render :partial => '#{label}'#{ps.blank?? nil : ", :locals => {#{ps}}"} %>"
+  end
+  
+end

data/lib/LucyCMS/cms_tag/snippet.rb

@@ -0,0 +1,22 @@
+class CmsTag::Snippet < CmsSnippet
+  
+  include CmsTag
+  
+  def identifier
+    "#{self.class.name.underscore}_#{self.slug}"
+  end
+  
+  def self.regex_tag_signature(label = nil)
+    label ||= /[\w\-]+/
+    /\{\{\s*cms:snippet:(#{label})\s*\}\}/
+  end
+  
+  def regex_tag_signature
+    self.class.regex_tag_signature(label)
+  end
+  
+  def content
+    self.read_attribute(:content)
+  end
+  
+end

data/lib/LucyCMS/cms_tag.rb

@@ -0,0 +1,119 @@
+# This module provides all Tag classes with neccessary methods.
+# Example class that will behave as a Tag:
+#   class MySpecialTag
+#     include CmsTag
+#     ...
+#   end
+module CmsTag
+  
+  TOKENIZER_REGEX = /(\{\{\s*cms:[^{}]*\}\})|((?:\{?[^{])+|\{+)/
+  
+  attr_accessor :params,
+                :parent,
+                :record_id
+  
+  module ClassMethods
+    # Regex that is used to match tags in the content
+    # Example:
+    #   /\{\{\s*?cms:page:(\w+)\}\}/
+    # will match tags like these:
+    #   {{cms:page:my_label}}
+    def regex_tag_signature
+      nil
+    end
+    
+    # Initializing tag object for a particular Tag type
+    # First capture group in the regex is the tag label
+    def initialize_tag(cms_page, tag_signature)
+      if match = tag_signature.match(regex_tag_signature)
+        if self.respond_to?(:initialize_or_find)
+          self.initialize_or_find(cms_page, match[1])
+        else
+          tag = self.new
+          tag.label   = match[1]
+          tag.params  = match[2]
+          tag
+        end
+      end
+    end
+  end
+  
+  module InstanceMethods
+    
+    # String indentifier of the tag
+    def identifier
+      "#{self.class.name.underscore}_#{self.label}"
+    end
+    
+    # Ancestors of this tag constructed during rendering process.
+    def ancestors
+      node, nodes = self, []
+      nodes << node = node.parent while node.parent
+      nodes
+    end
+    
+    # Regex that is used to identify instance of the tag
+    # Example:
+    #   /<\{\s*?cms:page:tag_label\}/
+    def regex_tag_signature
+      nil
+    end
+    
+    # Content that is accociated with Tag instance.
+    def content
+      nil
+    end
+    
+    # Content that is used during page rendering. Outputting existing content
+    # as a default.
+    def render
+      # cleaning content from possible irb stuff. Partial and Helper tags are OK.
+      if LucyCMS.config.disable_irb && ![CmsTag::Partial, CmsTag::Helper].member?(self.class)
+        content.to_s.gsub('<%', '&lt;%').gsub('%>', '%&gt;')
+      else
+        content.to_s
+      end
+    end
+  end
+  
+private
+  
+  # Initializes a tag. It's handled by one of the tag classes
+  def self.initialize_tag(cms_page, tag_signature)
+    tag_instance = nil
+    tag_classes.find{ |c| tag_instance = c.initialize_tag(cms_page, tag_signature) }
+    tag_instance
+  end
+  
+  # Scanning provided content and splitting it into [tag, text] tuples.
+  # Tags are processed further and their content is expanded in the same way.
+  # Tags are defined in the parent tags are ignored and not rendered.
+  def self.process_content(cms_page, content = '', parent_tag = nil)
+    tokens = content.to_s.scan(TOKENIZER_REGEX)
+    tokens.collect do |tag_signature, text|
+      if tag_signature
+        if tag = self.initialize_tag(cms_page, tag_signature)
+          tag.parent = parent_tag if parent_tag
+          if tag.ancestors.select{|a| a.identifier == tag.identifier}.blank?
+            cms_page.cms_tags << tag
+            self.process_content(cms_page, tag.render, tag)
+          end
+        end
+      else
+        text
+      end
+    end.join('')
+  end
+  
+  def self.included(tag)
+    tag.send(:include, CmsTag::InstanceMethods)
+    tag.send(:extend, CmsTag::ClassMethods)
+    @@tag_classes ||= []
+    @@tag_classes << tag
+  end
+  
+  # A list of registered Tag classes
+  def self.tag_classes
+    @@tag_classes ||= []
+  end
+end

data/lib/LucyCMS/configuration.rb

@@ -0,0 +1,36 @@
+class LucyCMS::Configuration
+  
+  # Location of YAML files that can be used to render pages instead of pulling
+  # data from the database. Not active if not specified.
+  attr_accessor :seed_data_path
+  
+  attr_accessor :version
+
+  attr_accessor :cms_upload_directory
+
+  # Default url to access admin area is http://yourhost/cms-admin/ 
+  # You can change 'cms-admin' to 'admin', for example.
+  attr_accessor :admin_route_prefix
+  
+  # /cms-admin redirects to /cms-admin/pages but you can change it
+  # to something else
+  attr_accessor :admin_route_redirect
+  
+  # Not allowing irb code to be run inside page content. True by default.
+  attr_accessor :disable_irb
+  
+  # Caching for css/js. For admin layout and ones for cms content. Enabled by default.
+  attr_accessor :enable_caching
+  
+  # Configuration defaults
+  def initialize
+    @seed_data_path       = nil
+    @version	          = '0.0.2'
+    @cms_upload_directory = 'common'
+    @admin_route_prefix   = 'cms-admin'
+    @admin_route_redirect = "/#{@admin_route_prefix}/pages"
+    @disable_irb          = true
+    @enable_caching       = true
+  end
+  
+end

data/lib/LucyCMS/controller_methods.rb

@@ -0,0 +1,42 @@
+module LucyCMS::ControllerMethods
+  
+  def self.included(base)
+    
+    # If application controller doesn't have template associated with it
+    # CMS will attempt to find one. This is so you don't have to explicitly
+    # call render :cms_page => '/something'
+    base.rescue_from 'ActionView::MissingTemplate' do |e|
+      begin
+        render :cms_page => request.path
+      rescue ActionView::MissingTemplate
+        raise e
+      end
+    end
+    
+    # Now you can render cms_page simply by calling:
+    #   render :cms_page => '/path/to/page'
+    # This way application controllers can use CMS content while populating
+    # instance variables that can be used in partials (that are included by
+    # by the cms page and/or layout)
+    def render(options = {}, locals = {}, &block)
+      if options.is_a?(Hash) && path = options.delete(:cms_page)
+        site = CmsSite.find_by_hostname(request.host.downcase)
+        page = CmsPage.load_from_file(site, path) if site && LucyCMS.configuration.seed_data_path
+        page ||= site && site.cms_pages.find_by_full_path(path)
+        if page
+          cms_app_layout = page.cms_layout.try(:app_layout)
+          options[:layout] ||= cms_app_layout.blank?? nil : cms_app_layout
+          options[:inline] = page.content
+          @cms_page = page
+          super(options, locals, &block)
+        else
+          raise ActionView::MissingTemplate.new([path], path, "CMS page not found", nil)
+        end
+      else
+        super(options, locals, &block)
+      end
+    end
+  end
+end
+
+ActionController::Base.send :include, LucyCMS::ControllerMethods

data/lib/LucyCMS/engine.rb

@@ -0,0 +1,12 @@
+require 'LucyCMS'
+require 'rails'
+require 'paperclip'
+require 'active_link_to'
+require 'mime/types'
+
+module LucyCMS
+  class Engine < ::Rails::Engine
+    
+  end
+end
+