tribeca_cms 0.1.1

data/app/models/locomotive/extensions/content_type/sync.rb

@@ -0,0 +1,62 @@
+module Locomotive
+  module Extensions
+    module ContentType
+      module Sync
+
+        extend ActiveSupport::Concern
+
+        included do
+          after_save :sync_relationships_order_by
+        end
+
+        protected
+
+        # If the user changes the order of the content type, we have to make
+        # sure that other related content types tied to the current one through
+        # a belongs_to / has_many relationship also gets updated.
+        #
+        def sync_relationships_order_by
+          current_class_name = self.klass_with_custom_fields(:entries).name
+
+          self.entries_custom_fields.where(:type => 'belongs_to').each do |field|
+            target_content_type = self.class_name_to_content_type(field.class_name)
+
+            operations = { '$set' => {} }
+
+            target_content_type.entries_custom_fields.where(:type.in => %w(has_many many_to_many), :ui_enabled => false, :class_name => current_class_name).each do |target_field|
+              if target_field.order_by != self.order_by_definition
+                target_field.order_by = self.order_by_definition # needed by the custom_fields_recipe_for method in order to be up to date
+
+                operations['$set']["entries_custom_fields.#{target_field._index}.order_by"] = self.order_by_definition
+              end
+            end
+
+            unless operations['$set'].empty?
+              persist_content_type_changes target_content_type, operations
+            end
+          end
+        end
+
+        # Save the changes for the content type passed in parameter without forgetting
+        # to bump the version.. It also updates the recipe for related entries.
+        # That method does not call the Mongoid API but directly MongoDB.
+        #
+        # @param [ ContentType ] content_type The content type to update
+        # @param [ Hash ] operations The MongoDB atomic operations
+        #
+        def persist_content_type_changes(content_type, operations)
+          content_type.entries_custom_fields_version += 1
+
+          operations['$set']['entries_custom_fields_version'] = content_type.entries_custom_fields_version
+
+          self.collection.update({ '_id' => content_type._id }, operations)
+
+          collection, selector = content_type.entries.collection, content_type.entries.criteria.selector
+
+          collection.update selector, { '$set' => { 'custom_fields_recipe' => content_type.custom_fields_recipe_for(:entries) } }, :multi => true
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+module Locomotive
+  module Extensions
+    module Page
+      module EditableElements
+
+        extend ActiveSupport::Concern
+
+        included do
+          embeds_many   :editable_elements, :class_name => 'Locomotive::EditableElement', :cascade_callbacks => true
+
+          after_save    :remove_disabled_editable_elements
+
+          accepts_nested_attributes_for :editable_elements
+        end
+
+        def disable_parent_editable_elements(block)
+          Rails.logger.debug "[disable_parent_editable_elements] #{block.inspect}"
+          self.editable_elements.each { |el| el.disabled = true if el.from_parent? && el.block == block }
+        end
+
+        def disable_all_editable_elements
+          self.editable_elements.each { |el| el.disabled = true }
+        end
+
+        def editable_element_blocks
+          self.editable_elements.collect(&:block)
+        end
+
+        def enabled_editable_elements
+          self.editable_elements.by_priority.find_all(&:editable?)
+        end
+
+        def editable_elements_grouped_by_blocks
+          groups = self.enabled_editable_elements.group_by(&:block)
+          groups.delete_if { |block, elements| elements.empty? }
+        end
+
+        def find_editable_elements(block)
+          self.editable_elements.find_all { |el| el.block == block }
+        end
+
+        def find_editable_element(block, slug)
+          self.editable_elements.detect { |el| el.block == block && el.slug == slug }
+        end
+
+        def find_editable_files
+          self.editable_elements.find_all { |el| el.respond_to?(:source) }
+        end
+
+        def add_or_update_editable_element(attributes, type)
+          element = self.find_editable_element(attributes[:block], attributes[:slug])
+
+          if element
+            element.copy_attributes(attributes)
+          else
+            element = self.editable_elements.build(attributes, type)
+          end
+
+          element.add_current_locale
+
+          element
+        end
+
+        def enable_editable_elements(block)
+          Rails.logger.debug "[enable_editable_elements] #{block.inspect}"
+          self.editable_elements.each { |el| el.disabled = false if el.block == block }
+        end
+
+        def merge_editable_elements_from_page(source)
+          source.editable_elements.each do |el|
+            next if el.disabled?
+
+            existing_el = self.find_editable_element(el.block, el.slug)
+
+            if existing_el.nil? # new one from parents
+              new_el = self.editable_elements.build({}, el.class)
+              new_el.copy_attributes_from(el)
+            else
+              existing_el.disabled = false
+
+              # make sure the default content gets updated too
+              existing_el.set_default_content_from(el)
+
+              # only the type, hint and fixed properties can be modified from the parent element
+              %w(_type hint fixed priority).each do |attr|
+                existing_el.send(:"#{attr}=", el.send(attr.to_sym))
+              end
+            end
+          end
+        end
+
+        def remove_disabled_editable_elements
+          # get only those which are fully disabled, meaning in ALL the locales
+          ids = self.editable_elements.find_all { |el| el.disabled_in_all_translations? }.map(&:_id)
+
+          return if ids.empty?
+
+          # super fast way to remove useless elements all in once
+          self.collection.update(self.atomic_selector, '$pull' => { 'editable_elements' => { '_id' => { '$in' => ids } } })
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Locomotive
+  module Extensions
+    module Page
+      module Listed
+
+        extend ActiveSupport::Concern
+
+        included do
+
+          ## fields ##
+          field :listed, :type => Boolean, :default => true
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+module Locomotive
+  module Extensions
+    module Page
+      module Parse
+
+        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
+
+        def template
+          @template ||= Marshal.load(self.serialized_template.to_s) rescue nil
+        end
+
+        def force_serialize_template
+          self.serialize_template
+          @done_serialize_template = true
+        end
+
+        protected
+
+        def serialize_template
+          if !@done_serialize_template &&
+              (self.new_record? || self.raw_template_changed?)
+            @template_changed = true
+
+            @parsing_errors = []
+
+            begin
+              self._parse_and_serialize_template
+            rescue ::Liquid::SyntaxError => error
+              @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
+
+        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) do |msg|
+            self.errors.add :template, msg
+            self.errors.add :raw_template, msg
+          end
+        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.#{::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 }
+
+          self._update_direct_template_descendants(template_descendants.clone, cached)
+
+          # finally save them all
+          ::Locomotive::Page.without_callback(:save, :after, :update_template_descendants) do
+            template_descendants.each do |page|
+              page.save(:validate => false)
+            end
+          end
+        end
+
+        def _update_direct_template_descendants(template_descendants, cached)
+          direct_descendants = template_descendants.select do |page|
+            ((self.template_dependencies || []) + [self._id]) == (page.template_dependencies || [])
+          end
+
+          direct_descendants.each do |page|
+            page.send(:_parse_and_serialize_template, { :cached_parent => self, :cached_pages => cached })
+
+            template_descendants.delete(page) # no need to loop over it next time
+
+            page.send(:_update_direct_template_descendants, template_descendants, cached) # move down
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Locomotive
+  module Extensions
+    module Page
+      module Redirect
+
+        extend ActiveSupport::Concern
+
+        included do
+
+          ## fields ##
+          field :redirect,      :type => Boolean, :default  => false
+          field :redirect_url,  :type => String,  :localize => true
+          field :redirect_type, :type => Integer, :default  => 301
+
+          ## validations ##
+          validates_presence_of :redirect_type, :if => :redirect?
+          validates_presence_of :redirect_url,  :if => :redirect?
+          validates_format_of   :redirect_url,  :with => Locomotive::Regexps::URL, :allow_blank => true
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+module Locomotive
+  module Extensions
+    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
+end

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

@@ -0,0 +1,163 @@
+module Locomotive
+  module Extensions
+    module Page
+      module Templatized
+
+        extend ActiveSupport::Concern
+
+        included do
+
+          ## fields ##
+          field :templatized,             :type => Boolean, :default => false
+          field :templatized_from_parent, :type => Boolean, :default => false
+          field :target_klass_name
+
+          ## validations ##
+          validates_presence_of :target_klass_name, :if => :templatized?
+          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
+
+        # Return the class specified by the target_klass_name property
+        #
+        # @example
+        #
+        #   page.target_klass_name = 'Locomotive::Entry12345'
+        #   page.target_klass # <Locomotive::Entry12345...>
+        #
+        # @return [ Class ] The target class
+        #
+        def target_klass
+          target_klass_name.constantize
+        end
+
+        # Return the slug related to the target_klass.
+        # In other words, it returns the slug of the target content type.
+        #
+        # @return [ String ] The slug of the target class / content type. Nil if no target klass.
+        #
+        def target_klass_slug
+          if self.target_klass_name =~ /^Locomotive::Entry([a-z0-9]+)$/
+            @content_type ||= self.site.content_types.find($1)
+            @content_type.slug
+          else
+            nil
+          end
+        end
+
+        # Set the target klass from the slug of a content type
+        #
+        # @param [ String ] slug The slug of the content type
+        #
+        # @return [ Object ] The content type or nil if not found
+        #
+        def target_klass_slug=(slug)
+          if @content_type = self.site.content_types.where(:slug => slug).first
+            self.target_klass_name = @content_type.entries_class_name
+          end
+          @content_type
+        end
+
+        # Give the name which can be used in a liquid template in order
+        # to reference an entry. It uses the slug property if the target klass
+        # is a Locomotive content type or the class name itself for the other classes.
+        #
+        # @example
+        #
+        #   page.target_klass_name = 'Locomotive::Entry12345' # related to the content type Articles
+        #   page.target_entry_name = 'article'
+        #
+        #   page.target_klass_name = 'OurProduct'
+        #   page.target_entry_name = 'our_product'
+        #
+        # @return [ String ] The name in lowercase and underscored
+        #
+        def target_entry_name
+          if self.target_klass_name =~ /^Locomotive::Entry([a-z0-9]+)$/
+            @content_type ||= self.site.content_types.find($1)
+            @content_type.slug.singularize
+          else
+            self.target_klass_name.underscore
+          end
+        end
+
+        # Find the entry both specified by the target klass and identified by the permalink
+        #
+        # @param [ String ] permalink The permalink of the entry
+        #
+        # @return [ Object ] The document
+        #
+        def fetch_target_entry(permalink)
+          target_klass.find_by_permalink(permalink)
+        end
+
+        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.templatized_from_parent?
+        end
+
+        # Make 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?
+
+          if self.target_klass_name =~ /^Locomotive::Entry([a-z0-9]+)$/
+            content_type = Locomotive::ContentType.find($1)
+
+            if content_type.site_id != self.site_id
+              self.errors.add :target_klass_name, :security
+            end
+          elsif !Locomotive.config.models_for_templatization.include?(self.target_klass_name)
+            self.errors.add :target_klass_name, :security
+          end
+        end
+
+        # Set 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
+    end
+  end
+end