locomotive_cms 2.0.0.rc2 → 2.0.0.rc4

data/app/models/locomotive/editable_file.rb

@@ -1,17 +1,79 @@
 module Locomotive
   class EditableFile < EditableElement
 
+    ## behaviours ##
     mount_uploader 'source', EditableFileUploader
 
     replace_field 'source', ::String, true
 
+    ## fields ##
+    field :default_source_url, :localize => true
+
+    ## callbacks ##
+    after_save :propagate_content
+
+    ## methods ##
+
+    # Returns the url or the path to the uploaded file
+    # if it exists. Otherwise returns the default url.
+    #
+    # @note This method is not used for the rendering, only for the back-office
+    #
+    # @return [String] The url or path of the file
+    #
     def content
-      self.source? ? self.source.url : self.default_content
+      self.source? ? self.source.url : self.default_source_url
+    end
+
+    def default_content?
+      !self.source? && self.default_source_url.present?
+    end
+
+    def copy_attributes(attributes)
+      unless self.default_content?
+        attributes.delete(:default_source_url)
+      end
+
+      super(attributes)
+    end
+
+    def copy_attributes_from(el)
+      super(el)
+
+      if el.source_translations.nil?
+        self.attributes['default_source_url'] = el.attributes['default_source_url'] || {}
+      else
+        el.source_translations.keys.each do |locale|
+          ::Mongoid::Fields::I18n.with_locale(locale) do
+            self.default_source_url = el.source? ? el.source.url : el.default_source_url
+          end
+        end
+      end
+    end
+
+    def remove_source=(value)
+      self.source_will_change! # notify the page to run the callbacks for that element
+      self.default_source_url = nil
+      super
     end
 
     def as_json(options = {})
       Locomotive::EditableFilePresenter.new(self).as_json
     end
 
+    protected
+
+    def propagate_content
+      if self.source_changed?
+        operations  = {
+          '$set' => {
+            "editable_elements.$.default_source_url.#{::Mongoid::Fields::I18n.locale}" => self.source.url
+          }
+        }
+
+        self.page.collection.update self._selector, operations, :multi => true
+      end
+    end
+
   end
 end

data/app/models/locomotive/editable_long_text.rb

@@ -1,6 +1,8 @@
 module Locomotive
   class EditableLongText < EditableShortText
 
+    ## methods ##
+
     def as_json(options = {})
       Locomotive::EditableLongTextPresenter.new(self).as_json
     end

data/app/models/locomotive/editable_short_text.rb

@@ -2,20 +2,47 @@ module Locomotive
   class EditableShortText < EditableElement
 
     ## fields ##
-    field :content, :localize => true
+    field :content,         :localize => true
+    field :default_content, :type => Boolean, :localize => true, :default => true
 
     ## methods ##
 
-    def content_with_localization
-      value = self.content_without_localization
-      value.blank? ? self.default_content : value
+    def content=(value)
+      self.add_current_locale
+      self.default_content = false unless self.new_record?
+      super
     end
 
-    alias_method_chain :content, :localization
+    def default_content?
+      !!self.default_content
+    end
+
+    def copy_attributes_from(el)
+      super(el)
+
+      self.attributes['content']          = el.content_translations || {}
+      self.attributes['default_content']  = el.default_content_translations
+    end
 
     def as_json(options = {})
       Locomotive::EditableShortTextPresenter.new(self).as_json
     end
 
+    protected
+
+    def propagate_content
+      if self.content_changed?
+        operations  = {
+          '$set' => {
+            "editable_elements.$.content.#{::Mongoid::Fields::I18n.locale}"         => self.content,
+            "editable_elements.$.default_content.#{::Mongoid::Fields::I18n.locale}" => false,
+          }
+        }
+
+        self.page.collection.update self._selector, operations, :multi => true
+      end
+      true
+    end
+
   end
 end

data/app/models/locomotive/extensions/page/editable_elements.rb

@@ -6,15 +6,10 @@ module Locomotive
         extend ActiveSupport::Concern
 
         included do
-          embeds_many :editable_elements, :class_name => 'Locomotive::EditableElement'
+          embeds_many   :editable_elements, :class_name => 'Locomotive::EditableElement', :cascade_callbacks => true
 
           after_save    :remove_disabled_editable_elements
 
-          # editable file callbacks
-          after_save    :store_file_sources!
-          before_save   :write_file_source_identifiers
-          after_destroy :remove_file_sources!
-
           accepts_nested_attributes_for :editable_elements
         end
 
@@ -31,7 +26,7 @@ module Locomotive
         end
 
         def enabled_editable_elements
-          self.editable_elements.by_priority.reject { |el| el.disabled? }
+          self.editable_elements.by_priority.find_all(&:editable?)
         end
 
         def editable_elements_grouped_by_blocks
@@ -51,10 +46,14 @@ module Locomotive
           element = self.find_editable_element(attributes[:block], attributes[:slug])
 
           if element
-            element.attributes = attributes
+            element.copy_attributes(attributes)
           else
-            self.editable_elements.build(attributes, type)
+            element = self.editable_elements.build(attributes, type)
           end
+
+          element.add_current_locale
+
+          element
         end
 
         def enable_editable_elements(block)
@@ -63,26 +62,15 @@ module Locomotive
 
         def merge_editable_elements_from_page(source)
           source.editable_elements.each do |el|
-            next if el.disabled? or !el.assignable?
+            next if el.disabled?
 
             existing_el = self.find_editable_element(el.block, el.slug)
 
             if existing_el.nil? # new one from parents
-              new_attributes = el.attributes.merge(:from_parent => true)
-
-              if new_attributes['default_attribute'].present?
-                new_attributes['default_content'] = self.send(new_attributes['default_attribute']) || el.content
-              else
-                if el.respond_to?(:content) # only for text
-                  new_attributes['default_content'] = el.content
-                end
-              end
-
-              self.editable_elements.build(new_attributes, el.class)
-            elsif existing_el.default_attribute.nil?
-              existing_el.attributes = { :disabled => false, :default_content => el.content }
+              new_el = self.editable_elements.build({}, el.class)
+              new_el.copy_attributes_from(el)
             else
-              existing_el.attributes = { :disabled => false }
+              existing_el.disabled = false
             end
           end
         end
@@ -90,27 +78,8 @@ module Locomotive
         def remove_disabled_editable_elements
           return unless self.editable_elements.any? { |el| el.disabled? }
 
-          # super fast way to remove useless elements all in once (TODO callbacks)
-          self.collection.update(self.atomic_selector, '$pull' => { 'editable_elements' => { 'disabled' => true } })
-        end
-
-        protected
-
-        ## callbacks for editable files
-
-        # equivalent to "after_save :store_source!" in EditableFile
-        def store_file_sources!
-          self.find_editable_files.collect(&:store_source!)
-        end
-
-        # equivalent to "before_save :write_source_identifier" in EditableFile
-        def write_file_source_identifiers
-          self.find_editable_files.collect(&:write_source_identifier)
-        end
-
-        # equivalent to "after_destroy :remove_source!" in EditableFile
-        def remove_file_sources!
-          self.find_editable_files.collect(&:remove_source!)
+          # super fast way to remove useless elements all in once
+          self.collection.update(self.atomic_selector, '$pull' => { 'editable_elements' => { "disabled.#{::Mongoid::Fields::I18n.locale}" => true } })
         end
 
       end

data/app/models/locomotive/extensions/page/listed.rb

@@ -7,6 +7,7 @@ module Locomotive
 
         included do
 
+          ## fields ##
           field :listed, :type => Boolean, :default => true
 
         end

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

@@ -6,17 +6,22 @@ module Locomotive
         extend ActiveSupport::Concern
 
         included do
+          ## fields ##
           field :serialized_template,   :type => Binary, :localize => true
           field :template_dependencies, :type => Array, :default => [], :localize => true
           field :snippet_dependencies,  :type => Array, :default => [], :localize => true
 
+          ## virtual attributes
           attr_reader :template_changed
 
+          ## callbacks ##
           before_validation :serialize_template
           after_save        :update_template_descendants
 
+          ## validations ##
           validate :template_must_be_valid
 
+          ## scopes ##
           scope :pages, lambda { |domain| { :any_in => { :domains => [*domain] } } }
         end
 
@@ -38,6 +43,8 @@ module Locomotive
               @parsing_errors << I18n.t(:liquid_syntax, :fullpath => self.fullpath, :error => error.to_s, :scope => [:errors, :messages, :page])
             rescue ::Locomotive::Liquid::PageNotFound => error
               @parsing_errors << I18n.t(:liquid_extend, :fullpath => self.fullpath, :scope => [:errors, :messages, :page])
+            rescue ::Locomotive::Liquid::PageNotTranslated => error
+              @parsing_errors << I18n.t(:liquid_translation, :fullpath => self.fullpath, :scope => [:errors, :messages, :page])
             end
           end
         end
@@ -60,8 +67,8 @@ module Locomotive
 
           @template = ::Liquid::Template.parse(self.raw_template, context)
 
-          self.template_dependencies = context[:templates]
-          self.snippet_dependencies = context[:snippets]
+          self.template_dependencies  = context[:templates]
+          self.snippet_dependencies   = context[:snippets]
 
           @template.root.context.clear
         end
@@ -77,7 +84,7 @@ module Locomotive
           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
+          template_descendants = self.site.pages.any_in("template_dependencies.#{::Mongoid::Fields::I18n.locale}" => [self.id]).to_a
 
           # group them by fullpath for better performance
           cached = template_descendants.inject({}) { |memo, page| memo[page.fullpath] = page; memo }

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

@@ -3,10 +3,90 @@ module Locomotive
     module Page
       module Render
 
+        extend ActiveSupport::Concern
+
         def render(context)
           self.template.render(context)
         end
 
+        module ClassMethods
+
+          # Given both a site and a path, this method tries
+          # to get the matching page.
+          # If the page is templatized, the related content entry is
+          # associated to the page (page.content_entry stores the entry).
+          # If no page is found, then it returns the 404 one instead.
+          #
+          # @param [ Site ] site The site where to find the page
+          # @param [ String ] path The fullpath got from the request
+          # @param [ Boolean ] logged_in True if someone is logged in Locomotive
+          #
+          # @return [ Page ] The page matching the criteria OR the 404 one if none
+          #
+          def fetch_page_from_path(site, path, logged_in)
+            page  = nil
+            depth = path == 'index' ? 0 : path.split('/').size
+
+            matching_paths = path == 'index' ? %w(index) : path_combinations(path)
+
+            site.pages.where(:depth => depth, :fullpath.in => matching_paths).each do |_page|
+              if !_page.published? && !logged_in
+                next
+              else
+                if _page.templatized?
+                  %r(^#{_page.fullpath.gsub('content_type_template', '([^\/]+)')}$) =~ path
+
+                  permalink = $1
+
+                  _page.content_entry = _page.fetch_target_entry(permalink)
+
+                  if _page.content_entry.nil? || (!_page.content_entry.visible? && !logged_in) # content instance not found or not visible
+                    next
+                  end
+                end
+              end
+
+              page = _page
+
+              break
+            end
+
+            page || site.pages.not_found.published.first
+          end
+
+          # Calculate all the combinations possible based on the
+          # fact that one of the segment of the path could be
+          # a content type from a templatized page.
+          # We postulate that there is only one templatized page in a path
+          # (ie: no nested templatized pages)
+          #
+          # @param [ String ] path The path to the page
+          #
+          # @return [ Array ] An array of all the combinations
+          #
+          def path_combinations(path)
+            _path_combinations(path.split('/'))
+          end
+
+          #:nodoc:
+          def _path_combinations(segments, can_include_template = true)
+            return nil if segments.empty?
+
+            segment = segments.shift
+
+            (can_include_template ? [segment, 'content_type_template'] : [segment]).map do |_segment|
+              if (_combinations = _path_combinations(segments.clone, can_include_template && _segment != 'content_type_template'))
+                [*_combinations].map do |_combination|
+                  File.join(_segment, _combination)
+                end
+              else
+                [_segment]
+              end
+            end.flatten
+          end
+
+        end
+
       end
     end
   end

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

@@ -7,7 +7,9 @@ module Locomotive
 
         included do
 
-          field :templatized, :type => Boolean, :default => false
+          ## fields ##
+          field :templatized,             :type => Boolean, :default => false
+          field :templatized_from_parent, :type => Boolean, :default => false
           field :target_klass_name
 
           ## validations ##
@@ -15,11 +17,16 @@ module Locomotive
           validate              :ensure_target_klass_name_security
 
           ## callbacks ##
+          before_validation :get_templatized_from_parent
           before_validation :set_slug_if_templatized
           before_validation :ensure_target_klass_name_security
+          after_save        :propagate_templatized
 
           ## scopes ##
           scope :templatized, :where => { :templatized => true }
+
+          ## virtual attributes ##
+          attr_accessor :content_entry
         end
 
         # Returns the class specified by the target_klass_name property
@@ -70,10 +77,26 @@ module Locomotive
 
         protected
 
+        def get_templatized_from_parent
+          return if self.parent.nil?
+
+          if self.parent.templatized?
+            self.templatized        = self.templatized_from_parent = true
+            self.target_klass_name  = self.parent.target_klass_name
+          elsif !self.templatized?
+            self.templatized        = self.templatized_from_parent = false
+            self.target_klass_name  = nil
+          end
+        end
+
         def set_slug_if_templatized
-          self.slug = 'content_type_template' if self.templatized?
+          self.slug = 'content_type_template' if self.templatized? && !self.templatized_from_parent?
         end
 
+        # Makes sure the target_klass is owned by the site OR
+        # if it belongs to the models allowed by the application
+        # thanks to the models_for_templatization option.
+        #
         def ensure_target_klass_name_security
           return if !self.templatized? || self.target_klass_name.blank?
 
@@ -86,7 +109,25 @@ module Locomotive
           elsif !Locomotive.config.models_for_templatization.include?(self.target_klass_name)
             self.errors.add :target_klass_name, :security
           end
+        end
 
+        # Sets the templatized, templatized_from_parent properties of
+        # the children of the current page ONLY IF the templatized
+        # attribute got changed.
+        #
+        def propagate_templatized
+          return unless self.templatized_changed?
+
+          selector = { 'parent_ids' => { '$in' => [self._id] } }
+          operations  = {
+            '$set' => {
+              'templatized'             => self.templatized,
+              'templatized_from_parent' => self.templatized,
+              'target_klass_name'       => self.target_klass_name
+            }
+          }
+
+          self.collection.update selector, operations, :multi => true
         end
 
       end