locomotive_cms 0.0.3.3 → 0.0.4.beta1

data/app/models/extensions/page/parse.rb

@@ -0,0 +1,107 @@
+module Models
+  module Extensions
+    module Page
+      module Parse
+
+        extend ActiveSupport::Concern
+
+        included do
+          field :serialized_template, :type => Binary
+          field :template_dependencies, :type => Array, :default => []
+          field :snippet_dependencies, :type => Array, :default => []
+
+          attr_reader :template_changed
+
+          before_validation :serialize_template
+          after_save :update_template_descendants
+
+          validate :template_must_be_valid
+
+          scope :pages, lambda { |domain| { :any_in => { :domains => [*domain] } } }
+        end
+
+        module InstanceMethods
+
+          def template
+            @template ||= Marshal.load(read_attribute(:serialized_template).to_s) rescue nil
+          end
+
+          protected
+
+          def serialize_template
+            if self.new_record? || self.raw_template_changed?
+              @template_changed = true
+
+              @parsing_errors = []
+
+              begin
+                self._parse_and_serialize_template
+              rescue ::Liquid::SyntaxError => error
+                @parsing_errors << :liquid_syntax
+              rescue ::Locomotive::Liquid::PageNotFound => error
+                @parsing_errors << :liquid_extend
+              end
+            end
+          end
+
+          def _parse_and_serialize_template(context = {})
+            self.parse(context)
+            self._serialize_template
+          end
+
+          def _serialize_template
+            self.serialized_template = BSON::Binary.new(Marshal.dump(@template))
+          end
+
+          def parse(context = {})
+            self.disable_all_editable_elements
+
+            default_context = { :site => self.site, :page => self, :templates => [], :snippets => [] }
+
+            context = default_context.merge(context)
+
+            @template = ::Liquid::Template.parse(self.raw_template, context)
+
+            self.template_dependencies = context[:templates]
+            self.snippet_dependencies = context[:snippets]
+
+            @template.root.context.clear
+          end
+
+          def template_must_be_valid
+            @parsing_errors.try(:each) { |msg| self.errors.add :template, msg }
+          end
+
+          def update_template_descendants
+            return unless @template_changed == true
+
+            # we admit at this point that the current template is up-to-date
+            template_descendants = self.site.pages.any_in(:template_dependencies => [self.id]).to_a
+
+            # group them by fullpath for better performance
+            cached = template_descendants.inject({}) { |memo, page| memo[page.fullpath] = page; memo }
+
+            self._update_direct_template_descendants(template_descendants, cached)
+
+            # finally save them all
+            template_descendants.map(&:save)
+          end
+
+          def _update_direct_template_descendants(template_descendants, cached)
+            direct_descendants = template_descendants.select do |page|
+              ((page.template_dependencies || []) - (self.template_dependencies || [])).size == 1
+            end
+
+            direct_descendants.each do |page|
+              page.send(:_parse_and_serialize_template, { :cached_parent => self, :cached_pages => cached })
+
+              page.send(:_update_direct_template_descendants, template_descendants, cached)
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/app/models/extensions/page/render.rb

@@ -1,19 +1,13 @@
-module Models  
-  module Extensions    
-    module Page      
+module Models
+  module Extensions
+    module Page
       module Render
 
         def render(context)
           self.template.render(context)
-
-          if self.layout
-            self.layout.template.render(context)
-          else
-            ::Liquid::Template.parse("{{ content_for_layout }}").render(context)
-          end
         end
-        
-      end      
-    end    
-  end  
-end
+
+      end
+    end
+  end
+end

data/app/models/extensions/page/templatized.rb

@@ -1,32 +1,32 @@
-module Models  
-  module Extensions    
-    module Page      
-      module Templatized  
+module Models
+  module Extensions
+    module Page
+      module Templatized
 
         extend ActiveSupport::Concern
 
         included do
-                              
-          belongs_to_related :content_type
-          
+
+          referenced_in :content_type
+
           field :templatized, :type => Boolean, :default => false
-          
+
           field :content_type_visible_column
-          
-          before_validate :set_slug_if_templatized
+
+          before_validation :set_slug_if_templatized
         end
-        
+
         module InstanceMethods
-          
+
           def set_slug_if_templatized
             self.slug = 'content_type_template' if self.templatized?
           end
-                  
+
         end
-        
+
       end
     end
   end
 end
-      
-      
+
+

data/app/models/extensions/page/tree.rb

@@ -1,21 +1,21 @@
-module Models  
-  module Extensions    
-    module Page      
-      module Tree  
+module Models
+  module Extensions
+    module Page
+      module Tree
 
         extend ActiveSupport::Concern
 
         included do
           include Mongoid::Acts::Tree
-          
+
           ## fields ##
           field :position, :type => Integer
-          
+
           ## behaviours ##
           acts_as_tree :order => ['position', 'asc']
-          
+
           ## callbacks ##
-          before_validate :reset_parent
+          before_validation :reset_parent
           before_save { |p| p.send(:write_attribute, :parent_id, nil) if p.parent_id.blank? }
           before_save :change_parent
           before_create { |p| p.send(:fix_position, false) }
@@ -24,10 +24,11 @@ module Models
 
           # Fixme (Didier L.): Instances methods are defined before the include itself
           alias :fix_position :hacked_fix_position
-        end 
-        
+          alias :descendants :hacked_descendants
+        end
+
         module InstanceMethods
-          
+
           def sort_children!(ids)
             ids.each_with_index do |id, position|
               child = self.children.detect { |p| p._id == id }
@@ -35,15 +36,23 @@ module Models
               child.save
             end
           end
-          
+
           def parent=(owner) # missing in acts_as_tree
             @_parent = owner
             self.fix_position(false)
             self.instance_variable_set :@_will_move, true
           end
-                    
+
+          def hacked_descendants
+            # workorund for mongoid unexpected behavior
+            _new_record_var = self.instance_variable_get(:@new_record)
+            _new_record = _new_record_var != false
+            return [] if _new_record
+            self.class.all_in(path_field => [self._id]).order_by tree_order
+         end
+
           protected
-          
+
           def change_parent
             if self.parent_id_changed?
               self.fix_position(false)
@@ -63,15 +72,15 @@ module Models
               self[depth_field] = parent[depth_field] + 1
               self.save if perform_save
             end
-          end          
-          
+          end
+
           def reset_parent
             if self.parent_id_changed?
               @_parent = nil
             end
           end
-          
-          def add_to_list_bottom  
+
+          def add_to_list_bottom
             self.position = (::Page.where(:_id.ne => self._id).and(:parent_id => self.parent_id).max(:position) || 0) + 1
           end
 
@@ -83,9 +92,9 @@ module Models
               p.save
             end
           end
-          
-        end        
-      end      
-    end    
-  end  
-end
+
+        end
+      end
+    end
+  end
+end

data/app/models/membership.rb

@@ -1,31 +1,31 @@
 class Membership
-  
+
   include Locomotive::Mongoid::Document
-  
+
   ## fields ##
   field :admin, :type => Boolean, :default => false
-  
+
   ## associations ##
-  belongs_to_related :account
+  referenced_in :account
   embedded_in :site, :inverse_of => :memberships
-  
+
   ## validations ##
   validates_presence_of :account
-  
+
   ## methods ##
-  
+
   def email; @email; end
-  
+
   def email=(email)
     @email = email
     self.account = Account.where(:email => email).first
   end
-  
+
   def process!
     if @email.blank?
       self.errors.add_on_blank(:email)
       :error
-    elsif self.account.nil?
+    elsif self.account.blank?
       :create_account
     elsif self.site.memberships.find_all { |m| m.account_id == self.account_id }.size > 1
       self.errors.add(:base, 'Already created')
@@ -35,5 +35,5 @@ class Membership
       :save_it
     end
   end
-  
-end
+
+end

data/app/models/page.rb

@@ -1,99 +1,101 @@
 class Page
-  
+
   include Locomotive::Mongoid::Document
 
-  ## Extensions ##  
+  ## Extensions ##
   include Models::Extensions::Page::Tree
-  include Models::Extensions::Page::Parts
+  include Models::Extensions::Page::EditableElements
+  include Models::Extensions::Page::Parse
   include Models::Extensions::Page::Render
   include Models::Extensions::Page::Templatized
-  
+
   ## fields ##
   field :title
   field :slug
   field :fullpath
+  field :raw_template
   field :published, :type => Boolean, :default => false
   field :cache_strategy, :default => 'none'
-  
+
   ## associations ##
-  belongs_to_related :site
-  belongs_to_related :layout
-  embeds_many :parts, :class_name => 'PagePart'
-    
+  referenced_in :site
+
+  ## indexes ##
+  index :site_id
+  index :parent_id
+  index [[:fullpath, Mongo::ASCENDING], [:site_id, Mongo::ASCENDING]]
+
   ## callbacks ##
-  before_validate :normalize_slug
+  before_validation :normalize_slug
   before_save { |p| p.fullpath = p.fullpath(true) }
   before_destroy :do_not_remove_index_and_404_pages
-  
+
   ## validations ##
   validates_presence_of     :site, :title, :slug
   validates_uniqueness_of   :slug, :scope => [:site_id, :parent_id]
   validates_exclusion_of    :slug, :in => Locomotive.config.reserved_slugs, :if => Proc.new { |p| p.depth == 0 }
-  
+
   ## named scopes ##
-  named_scope :latest_updated, :order_by => [[:updated_at, :desc]], :limit => Locomotive.config.lastest_items_nb
-  named_scope :index, :where => { :slug => 'index', :depth => 0 }
-  named_scope :not_found, :where => { :slug => '404', :depth => 0 }
-  named_scope :published, :where => { :published => true }
-  
-  ## behaviours ##
-  liquify_template :joined_parts
-  
+  scope :latest_updated, :order_by => [[:updated_at, :desc]], :limit => Locomotive.config.lastest_items_nb
+  scope :index, :where => { :slug => 'index', :depth => 0 }
+  scope :not_found, :where => { :slug => '404', :depth => 0 }
+  scope :published, :where => { :published => true }
+
   ## methods ##
-  
+
   def index?
     self.slug == 'index' && self.depth.to_i == 0
   end
-  
+
   def not_found?
     self.slug == '404' && self.depth.to_i == 0
   end
-  
+
   def index_or_not_found?
     self.index? || self.not_found?
   end
-  
+
   def fullpath(force = false)
     if read_attribute(:fullpath).present? && !force
       return read_attribute(:fullpath)
     end
-    
+
     if self.index? || self.not_found?
       self.slug
     else
       slugs = self.self_and_ancestors.map(&:slug)
-      slugs.shift
+      slugs.shift unless slugs.size == 1
       File.join slugs
     end
   end
-  
+
   def url
     "http://#{self.site.domains.first}/#{self.fullpath}.html"
   end
-  
+
   def with_cache?
     self.cache_strategy != 'none'
   end
-  
-  def to_liquid(options = {})
+
+  def to_liquid
     Locomotive::Liquid::Drops::Page.new(self)
   end
-    
+
   protected
-  
+
   def do_not_remove_index_and_404_pages
     return if (self.site rescue nil).nil?
-    
+
     if self.index? || self.not_found?
       self.errors[:base] << I18n.t('errors.messages.protected_page')
     end
-    
+
     self.errors.empty?
   end
-      
-  def normalize_slug  
-    self.slug = self.title.clone if self.slug.blank? && self.title.present?    
+
+  def normalize_slug
+    self.slug = self.title.clone if self.slug.blank? && self.title.present?
     self.slug.slugify!(:without_extension => true) if self.slug.present?
   end
-    
-end
+
+end

data/app/models/site.rb

@@ -1,95 +1,100 @@
 class Site
-  
+
   include Locomotive::Mongoid::Document
-  
+
   ## fields ##
   field :name
   field :subdomain
   field :domains, :type => Array, :default => []
   field :meta_keywords
   field :meta_description
-  
+
   ## associations ##
-  has_many_related :pages
-  has_many_related :layouts
-  has_many_related :snippets
-  has_many_related :theme_assets
-  has_many_related :asset_collections
-  has_many_related :content_types
+  references_many :pages
+  references_many :snippets, :dependent => :destroy
+  references_many :theme_assets, :dependent => :destroy
+  references_many :asset_collections, :dependent => :destroy
+  references_many :content_types, :dependent => :destroy
   embeds_many :memberships
-  
+
+  ## indexes
+  index :domains
+
   ## validations ##
   validates_presence_of     :name, :subdomain
   validates_uniqueness_of   :subdomain
   validates_exclusion_of    :subdomain, :in => Locomotive.config.reserved_subdomains
   validates_format_of       :subdomain, :with => Locomotive::Regexps::SUBDOMAIN, :allow_blank => true
-  validate                  :domains_must_be_valid_and_unique  
-  
+  validate                  :domains_must_be_valid_and_unique
+
   ## callbacks ##
   after_create :create_default_pages!
   before_save :add_subdomain_to_domains
-  after_destroy :destroy_in_cascade!
-  
+  after_destroy :destroy_pages
+
   ## named scopes ##
-  named_scope :match_domain, lambda { |domain| { :where => { :domains => domain } } }
-  named_scope :match_domain_with_exclusion_of, lambda { |domain, site| { :where => { :domains => domain, :_id.ne => site.id } } }
-    
-  ## behaviours ##
-  liquid_methods :name, :meta_keywords, :meta_description
-  
+  scope :match_domain, lambda { |domain| { :any_in => { :domains => [*domain] } } }
+  scope :match_domain_with_exclusion_of, lambda { |domain, site|
+    { :any_in => { :domains => [*domain] }, :where => { :_id.ne => site.id } }
+  }
+
   ## methods ##
 
   def accounts
     Account.criteria.in(:_id => self.memberships.collect(&:account_id))
   end
-  
+
   def admin_memberships
     self.memberships.find_all { |m| m.admin? }
   end
-  
+
   def add_subdomain_to_domains
-    self.domains ||= []    
+    self.domains ||= []
     (self.domains << "#{self.subdomain}.#{Locomotive.config.default_domain}").uniq!
   end
-  
+
   def domains_without_subdomain
     (self.domains || []) - ["#{self.subdomain}.#{Locomotive.config.default_domain}"]
   end
-  
+
   def domains_with_subdomain
     ((self.domains || []) + ["#{self.subdomain}.#{Locomotive.config.default_domain}"]).uniq
   end
-    
+
+  def to_liquid
+    Locomotive::Liquid::Drops::Site.new(self)
+  end
+
   protected
-  
+
   def domains_must_be_valid_and_unique
     return if self.domains.empty?
-            
+
     self.domains_without_subdomain.each do |domain|
-      if not self.class.match_domain_with_exclusion_of(domain, self).empty?
+      if self.class.match_domain_with_exclusion_of(domain, self).any?
         self.errors.add(:domains, :domain_taken, :value => domain)
       end
-      
+
       if not domain =~ Locomotive::Regexps::DOMAIN
         self.errors.add(:domains, :invalid_domain, :value => domain)
       end
     end
   end
-  
+
   def create_default_pages!
     %w{index 404}.each do |slug|
       self.pages.create({
-        :slug => slug, 
-        :title => I18n.t("attributes.defaults.pages.#{slug}.title"), 
-        :body => I18n.t("attributes.defaults.pages.#{slug}.body")
+        :slug => slug,
+        :title => I18n.t("attributes.defaults.pages.#{slug}.title"),
+        :raw_template => I18n.t("attributes.defaults.pages.#{slug}.body"),
+        :published => true
       })
     end
   end
-  
-  def destroy_in_cascade!
-    %w{pages layouts snippets theme_assets asset_collections content_types}.each do |association|
-      self.send(association).destroy_all
-    end
+
+  def destroy_pages
+    # pages is a tree so we just need to delete the root (as well as the page not found page)
+    self.pages.index.first.try(:destroy) && self.pages.not_found.first.try(:destroy)
   end
-  
-end
+
+end

data/app/models/snippet.rb

@@ -1,3 +1,64 @@
-class Snippet < LiquidTemplate
+class Snippet
 
-end
+  include Locomotive::Mongoid::Document
+
+  ## fields ##
+  field :name
+  field :slug
+  field :template
+
+  ## associations ##
+  referenced_in :site
+
+  ## callbacks ##
+  before_validation :normalize_slug
+  after_save :update_templates
+  after_destroy :update_templates
+
+  # TODO: after_save callback to let pages embedding this snippet know about the changes the user has just made.
+
+  ## validations ##
+  validates_presence_of   :site, :name, :slug, :template
+  validates_uniqueness_of :slug, :scope => :site_id
+
+  ## methods ##
+
+  protected
+
+  def normalize_slug
+    # TODO: refactor it
+    self.slug = self.name.clone if self.slug.blank? && self.name.present?
+    self.slug.slugify!(:without_extension => true, :downcase => true) if self.slug.present?
+  end
+
+  def update_templates
+    return unless (self.site rescue false) # not run if the site is being destroyed
+
+    pages = self.site.pages.any_in(:snippet_dependencies => [self.slug]).to_a
+
+    pages.each do |page|
+      self._change_snippet_inside_template(page.template.root)
+
+      page.instance_variable_set(:@template_changed, true)
+
+      page.send(:_serialize_template) && page.save
+    end
+  end
+
+  def _change_snippet_inside_template(node)
+    case node
+    when Locomotive::Liquid::Tags::Snippet
+      node.refresh(self) if node.slug == self.slug
+    when Locomotive::Liquid::Tags::InheritedBlock
+      self._change_snippet_inside_template(node.parent) if node.parent
+    else
+      if node.respond_to?(:nodelist)
+        (node.nodelist || []).each do |child|
+          self._change_snippet_inside_template(child)
+        end
+      end
+    end
+  end
+
+
+end