pages_core 3.4.3 → 3.5.1

data/app/models/concerns/pages_core/page_model/localizable.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module PagesCore
+  module PageModel
+    module Localizable
+      extend ActiveSupport::Concern
+
+      included do
+        localizable do
+          attribute :name
+          attribute :body
+          attribute :excerpt
+          attribute :headline
+          attribute :boxout
+
+          attribute :path_segment
+          attribute :meta_title
+          attribute :meta_description
+          attribute :open_graph_title
+          attribute :open_graph_description
+
+          dictionary(lambda do
+            PagesCore::Templates::TemplateConfiguration.all_blocks
+          end)
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/pages_core/page_model/pathable.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+
+module PagesCore
+  module PageModel
+    module Pathable
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :page_paths, dependent: :destroy
+
+        validates :path_segment, format: { with: /\A[[[:alnum:]]\-_]*\z/ }
+        validate :path_segment_cannot_be_routable
+        before_validation :ensure_no_path_segment_on_deletion
+        after_save :ensure_path_segment
+        after_save :associate_page_path
+      end
+
+      def full_path(last_segment = nil)
+        last_segment ||= path_segment
+        return nil unless full_path?(last_segment)
+        if parent
+          [parent.full_path, last_segment].join("/")
+        else
+          last_segment
+        end
+      end
+
+      def full_path?(last_segment = nil)
+        last_segment ||= path_segment
+        if parent
+          parent.full_path? && !last_segment.blank?
+        else
+          !last_segment.blank?
+        end
+      end
+
+      def ensure_path_segment
+        return if deleted? || path_segment? || !name?
+        if path_collision?(generated_path_segment)
+          update path_segment: "#{generated_path_segment}-#{id}"
+        else
+          update path_segment: generated_path_segment
+        end
+      end
+
+      def pathable?
+        return true unless parent
+        parent.full_path?
+      end
+
+      private
+
+      def associate_page_path
+        return if deleted? || !full_path?
+        PagePath.build(self)
+      end
+
+      def ensure_no_path_segment_on_deletion
+        return unless deleted?
+        self.path_segment = nil
+      end
+
+      def generated_path_segment
+        name.gsub(/[^[[:alnum:]]\-_]+/, "-")
+            .gsub(/[\-]{2,}/, "-")
+            .gsub(/(^\-|\-$)/, "")
+            .mb_chars
+            .downcase
+      end
+
+      def page_path_matches_routes?(page_path)
+        [
+          "/#{page_path}",
+          "/#{I18n.default_locale}/#{page_path}"
+        ].map { |p| recognizable_route?(p) }.any?
+      end
+
+      def page_path_route?(route)
+        route[:controller] == "pages" &&
+          route[:action] == "show" &&
+          !route[:path].blank?
+      end
+
+      def path_collision?(path_segment)
+        sibling_path_segments.include?(path_segment) ||
+          page_path_matches_routes?(full_path(path_segment))
+      end
+
+      def path_segment_cannot_be_routable
+        return unless full_path?
+        return unless page_path_matches_routes?(full_path)
+        errors.add(:path_segment, "can't match an existing URL")
+      end
+
+      def recognizable_route?(path)
+        route = Rails.application.routes.recognize_path(path)
+        !page_path_route?(route)
+      rescue ActionController::RoutingError
+        false
+      end
+
+      def sibling_path_segments
+        siblings = if parent
+                     parent.children
+                   else
+                     self.class.roots
+                   end
+        siblings.reject { |p| p == self }
+                .map { |p| p.localize(locale) }
+                .map(&:path_segment)
+                .reject(&:blank?)
+      end
+    end
+  end
+end

data/app/models/concerns/pages_core/page_model/redirectable.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module PagesCore
+  module PageModel
+    class InvalidRedirectUrl < StandardError; end
+
+    module Redirectable
+      extend ActiveSupport::Concern
+
+      included do
+        validates(:redirect_to,
+                  format: { with: %r{\A(/|https?://).+\z},
+                            allow_nil: true,
+                            allow_blank: true })
+      end
+
+      # Returns boolean true if page has a valid redirect
+      def redirects?
+        redirect_to?
+      end
+
+      def redirect_path(params = {})
+        path = redirect_to.dup
+        if path.start_with? "/"
+          params.each do |key, value|
+            unless value.is_a?(String) || value.is_a?(Symbol)
+              raise InvalidRedirectUrl, "must be a string or a symbol"
+            end
+            path.gsub!("/:#{key}", "/#{value}")
+          end
+        end
+        path
+      end
+    end
+  end
+end

data/app/models/concerns/pages_core/page_model/searchable.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module PagesCore
+  module PageModel
+    module Searchable
+      extend ActiveSupport::Concern
+
+      included do
+        after_save ThinkingSphinx::RealTime.callback_for(:page)
+      end
+
+      def localization_values
+        localizations.map(&:value)
+      end
+
+      def category_names
+        categories.map(&:name)
+      end
+
+      def comment_names
+        comments.map(&:name)
+      end
+
+      def comment_bodies
+        comments.map(&:body)
+      end
+
+      def file_names
+        files.map(&:name)
+      end
+
+      def file_filenames
+        files.map(&:filename)
+      end
+
+      def published
+        published?
+      end
+    end
+  end
+end

data/app/models/concerns/pages_core/page_model/sortable.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+module PagesCore
+  module PageModel
+    module Sortable
+      extend ActiveSupport::Concern
+
+      included do
+        acts_as_list scope: :parent_page
+        after_save :check_list_position
+      end
+
+      module ClassMethods
+        def order_by_tags(tags)
+          joins(
+            "LEFT JOIN taggings ON taggings.taggable_id = pages.id AND " \
+              "taggable_type = #{ActiveRecord::Base.connection.quote('Page')}",
+            "LEFT JOIN tags ON tags.id = taggings.tag_id AND tags.id IN (" +
+              tags.map(&:id).join(",") +
+              ")"
+          )
+            .group("pages.id, localizations.id")
+            .reorder("COUNT(tags.id) DESC, position ASC")
+        end
+      end
+
+      def reorderable_children?
+        !news_page?
+      end
+
+      def reorderable?
+        !parent || !parent.news_page?
+      end
+
+      def content_order
+        if news_page?
+          "pages.pinned DESC, published_at DESC"
+        else
+          "position ASC"
+        end
+      end
+
+      private
+
+      def check_list_position
+        if deleted?
+          remove_from_list
+        elsif !position?
+          assume_bottom_position
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/pages_core/page_model/status.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+module PagesCore
+  module PageModel
+    module Status
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def status_labels
+          {
+            0 => "Draft",
+            1 => "Reviewed",
+            2 => "Published",
+            3 => "Hidden",
+            4 => "Deleted"
+          }
+        end
+      end
+
+      # Return the status of the page as a string
+      def status_label
+        self.class.status_labels[status]
+      end
+
+      def flag_as_deleted!
+        update(status: 4)
+      end
+
+      def draft?
+        status == 0
+      end
+
+      def reviewed?
+        status == 1
+      end
+
+      def published?
+        status == 2 && !autopublish?
+      end
+
+      def hidden?
+        status == 3
+      end
+
+      def deleted?
+        status == 4
+      end
+    end
+  end
+end

data/app/models/concerns/pages_core/page_model/templateable.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+module PagesCore
+  module PageModel
+    module Templateable
+      extend ActiveSupport::Concern
+
+      included do
+        before_validation :ensure_template
+      end
+
+      def template_config
+        PagesCore::Templates::TemplateConfiguration.new(template)
+      end
+
+      def template
+        return self[:template] unless self[:template].blank?
+        inherited_or_default_template
+      end
+
+      def default_subtemplate
+        template_config.value(:sub_template) ||
+          default_template ||
+          subtemplate_with_postfix ||
+          singularized_subtemplate ||
+          template
+      end
+
+      private
+
+      def singularized_subtemplate
+        singularized = ActiveSupport::Inflector.singularize(base_template)
+        return if base_template == singularized
+        find_template_by_expression(
+          Regexp.new("^" + Regexp.quote(singularized))
+        )
+      end
+
+      def subtemplate_with_postfix
+        find_template_by_expression(
+          Regexp.new(
+            "^" + Regexp.quote(base_template) + "_?(post|page|subpage|item)"
+          )
+        )
+      end
+
+      def base_template
+        template.split(/_/)
+                .reject { |w| %w(index list archive liste arkiv).include?(w) }
+                .join(" ")
+      end
+
+      def default_template
+        configured = PagesCore::Templates.configuration.get(
+          :default, :template, :value
+        )
+        configured if configured != :autodetect
+      end
+
+      def find_template_by_expression(expr)
+        PagesCore::Templates.names
+                            .select { |t| t.match(expr) }
+                            .try(&:first)
+      end
+
+      def default_template_options
+        PagesCore::Templates.configuration.get(
+          :default, :template, :options
+        ) || {}
+      end
+
+      def inherited_or_default_template
+        return parent.default_subtemplate.to_s if parent
+        (default_template_options[:root] || default_template || :index).to_s
+      end
+
+      def ensure_template
+        self[:template] ||= inherited_or_default_template
+      end
+    end
+  end
+end

data/app/models/concerns/pages_core/page_model/tree.rb

@@ -0,0 +1,108 @@
+# encoding: utf-8
+
+module PagesCore
+  module PageModel
+    module Tree
+      extend ActiveSupport::Concern
+
+      included do
+        belongs_to :parent,
+                   class_name:  "Page",
+                   foreign_key: :parent_page_id,
+                   inverse_of:  :children
+
+        has_many :children,
+                 class_name:  "Page",
+                 foreign_key: :parent_page_id,
+                 inverse_of:  :parent,
+                 dependent:   :destroy
+
+        # This must be included after the belongs_to call in order
+        # to override the .parent method.
+        include PagesCore::PageModel::Tree::InstanceMethods
+      end
+
+      module ClassMethods
+        # Returns all root pages
+        def roots
+          where(parent_page_id: nil).order("position ASC")
+        end
+
+        # Returns the first root page
+        def root
+          roots.first
+        end
+      end
+
+      module InstanceMethods
+        # Returns list of ancestors, starting from parent until root.
+        #
+        #   subchild1.ancestors # => [child1, root]
+        def ancestors
+          node = self
+          nodes = []
+          nodes << node = node.parent while node.parent
+          nodes
+        end
+
+        # Returns all children, recursively
+        def all_subpages
+          return nil unless subpages.any?
+          localized_subpages.map { |p| [p, p.all_subpages] }.flatten.compact
+        end
+
+        def localized_subpages
+          return subpages unless locale?
+          subpages.localized(locale)
+        end
+
+        # Finds the page's next sibling. Returns nil if there isn't one.
+        def next_sibling
+          return unless siblings.any?
+          siblings[(siblings.index(self) + 1)...siblings.length].try(&:first)
+        end
+
+        # Returns the pages parent
+        def parent
+          super.try { |node| node.localize(locale) }
+        end
+
+        # Get subpages
+        def pages(_options = nil)
+          localized_subpages.published
+        end
+
+        # Finds the page's next sibling. Returns nil if there isn't one.
+        def previous_sibling
+          return unless siblings.any?
+          siblings[0...siblings.index(self)].try(&:last)
+        end
+
+        # Returns the root node of the tree.
+        def root
+          self_and_ancestors.last
+        end
+
+        # Returns ancestors and current node itself.
+        #
+        #   subchild1.self_and_ancestors # => [subchild1, child1, root]
+        def self_and_ancestors
+          [self] + ancestors
+        end
+
+        # Returns all siblings, including self.
+        def siblings
+          if parent
+            parent.pages
+          else
+            self.class.roots.map { |node| node.localize(locale) }
+          end
+        end
+
+        def subpages
+          children.order(content_order)
+        end
+      end
+    end
+  end
+end