locomotive_cms 1.0.0.beta.2 → 2.0.0.rc1

data/app/models/editable_file.rb

@@ -1,9 +0,0 @@
-class EditableFile < EditableElement
-
-  mount_uploader :source, EditableFileUploader
-
-  def content
-    self.source? ? self.source.url : self.default_content
-  end
-
-end

data/app/models/editable_long_text.rb

@@ -1,3 +0,0 @@
-class EditableLongText < EditableShortText
-
-end

data/app/models/editable_short_text.rb

@@ -1,12 +0,0 @@
-class EditableShortText < EditableElement
-
-  ## fields ##
-  field :content
-
-  ## methods ##
-
-  def content
-    self.read_attribute(:content).blank? ? self.default_content : self.read_attribute(:content)
-  end
-
-end

data/app/models/extensions/asset/vignette.rb

@@ -1,42 +0,0 @@
-module Models
-  module Extensions
-    module Asset
-      module Vignette
-
-        def vignette_url
-          if self.image?
-            if self.width < 80 && self.height < 80
-              self.source.url
-            else
-              self.source.url(:medium)
-            end
-          # elsif asset.pdf?
-          #   image_tag(asset.source.url(:medium))
-          else
-            mime_type_to_url(:medium)
-          end
-        end
-
-        protected
-
-        def mime_type_to_url(size)
-          mime_type = File.mime_type?(self.source_filename)
-          filename = "unknown"
-
-          if !(mime_type =~ /pdf/).nil?
-            filename = "PDF"
-          elsif !(mime_type =~ /css/).nil?
-            filename = "CSS"
-          elsif !(mime_type =~ /javascript/).nil?
-            filename = "JAVA"
-          elsif !(mime_type =~ /font/).nil?
-            filename = "FON"
-          end
-
-          File.join("admin", "icons", "filetype", size.to_s, filename + ".png")
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,111 +0,0 @@
-module Models
-  module Extensions
-    module Page
-      module EditableElements
-
-        extend ActiveSupport::Concern
-
-        included do
-          embeds_many :editable_elements
-
-          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
-
-        module InstanceMethods
-
-          def disable_parent_editable_elements(block)
-            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 editable_elements_grouped_by_blocks
-            all_enabled = self.editable_elements.reject { |el| el.disabled? }
-            groups = all_enabled.group_by(&:block)
-            groups.delete_if { |block, elements| elements.empty? }
-          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.attributes = attributes
-            else
-              self.editable_elements.build(attributes, type)
-            end
-          end
-
-          def enable_editable_elements(block)
-            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_attributes = el.attributes.merge(:from_parent => true)
-                new_attributes[:default_content] = el.content
-
-                self.editable_elements.build(new_attributes, el.class)
-              else
-                existing_el.attributes = { :disabled => false, :default_content => el.content }
-              end
-            end
-          end
-
-          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._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!)
-          end
-
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,107 +0,0 @@
-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/redirect.rb

@@ -1,25 +0,0 @@
-module Models
-  module Extensions
-    module Page
-      module Redirect
-
-        extend ActiveSupport::Concern
-
-        included do
-
-          field :redirect, :type => Boolean, :default => false
-
-          field :redirect_url, :type => String
-
-          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/extensions/page/render.rb

@@ -1,13 +0,0 @@
-module Models
-  module Extensions
-    module Page
-      module Render
-
-        def render(context)
-          self.template.render(context)
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-module Models
-  module Extensions
-    module Page
-      module Templatized
-
-        extend ActiveSupport::Concern
-
-        included do
-
-          referenced_in :content_type
-
-          field :templatized, :type => Boolean, :default => false
-
-          field :content_type_visible_column
-
-          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,156 +0,0 @@
-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_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) }
-          before_create :add_to_list_bottom
-          before_destroy :remove_from_list
-
-          # Fixme (Didier L.): Instances methods are defined before the include itself
-          alias :fix_position :hacked_fix_position
-          alias :descendants :hacked_descendants
-        end
-
-        module ClassMethods
-
-          # Warning: used only in read-only
-          def quick_tree(site)
-            pages = site.pages.minimal_attributes.order_by([[:depth, :asc], [:position, :asc]]).to_a
-
-            tmp = []
-
-            while !pages.empty?
-              tmp << _quick_tree(pages.delete_at(0), pages)
-            end
-
-            tmp
-          end
-
-          def _quick_tree(current_page, pages)
-            i, children = 0, []
-
-            while !pages.empty?
-              page = pages[i]
-
-              break if page.nil?
-
-              if page.parent_id == current_page.id
-                page = pages.delete_at(i)
-
-                children << _quick_tree(page, pages)
-              else
-                i += 1
-              end
-            end
-
-            current_page.instance_eval do
-              def children=(list); @children = list; end
-              def children; @children || []; end
-            end
-
-            current_page.children = children
-
-            current_page
-          end
-
-        end
-
-        module InstanceMethods
-
-          def children?
-            self.class.where(self.parent_id_field => self.id).count
-          end
-
-          def children_with_minimal_attributes
-            self.class.where(self.parent_id_field => self.id).
-              order_by(self.tree_order).
-              minimal_attributes
-          end
-
-          def sort_children!(ids)
-            ids.each_with_index do |id, position|
-              child = self.children.detect { |p| p._id == BSON::ObjectId(id) }
-              child.position = position
-              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
-            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)
-
-              unless self.parent_id_was.nil?
-                self.position = nil # make it move to bottom
-                self.add_to_list_bottom
-              end
-
-              self.instance_variable_set :@_will_move, true
-            end
-          end
-
-          def hacked_fix_position(perform_save = true)
-            if parent.nil?
-              self.write_attribute parent_id_field, nil
-              self[path_field] = []
-              self[depth_field] = 0
-            else
-              self.write_attribute parent_id_field, parent._id
-              self[path_field] = parent[path_field] + [parent._id]
-              self[depth_field] = parent[depth_field] + 1
-              self.save if perform_save
-            end
-          end
-
-          def reset_parent
-            if self.parent_id_changed?
-              @_parent = nil
-            end
-          end
-
-          def add_to_list_bottom
-            self.position ||= (::Page.where(:_id.ne => self._id).and(:parent_id => self.parent_id).max(:position) || 0) + 1
-          end
-
-          def remove_from_list
-            return if (self.site rescue nil).nil?
-
-            ::Page.where(:parent_id => self.parent_id).and(:position.gt => self.position).each do |p|
-              p.position -= 1
-              p.save
-            end
-          end
-
-        end
-      end
-    end
-  end
-end