releaf-content 0.2.1

data/lib/releaf/content/node.rb

@@ -0,0 +1,280 @@
+module Releaf::Content
+  module Node
+    extend ActiveSupport::Concern
+    # TODO Node should be configurable
+
+      def locale_selection_enabled?
+        false
+      end
+
+      def build_content(params = {}, assignment_options = nil)
+        self.content = content_class.new(params)
+      end
+
+      def content_class
+        content_type.constantize unless content_type.blank?
+      end
+
+      # Return node public path
+      def path
+        if parent
+          parent.path + "/" + slug.to_s
+        else
+          "/" + slug.to_s
+        end
+      end
+
+      def to_s
+        name
+      end
+
+      def destroy
+        begin
+          content
+        rescue NameError => e
+          raise if content_id.nil? && content_type.nil?
+          raise unless e.message == "uninitialized constant #{content_type}"
+          # Class was deleted from project.
+          # Lets try one more time, but this time set content_type to nil, so
+          # rails doesn't try to constantize it
+          update_columns(content_id: nil, content_type: nil)
+        end
+
+        super
+        self.class.updated
+      end
+
+      def attributes_to_not_copy
+        %w[content_id depth id item_position lft rgt slug created_at updated_at]
+      end
+
+      def attributes_to_copy
+        self.class.column_names - attributes_to_not_copy
+      end
+
+      def copy parent_id
+        prevent_infinite_copy_loop(parent_id)
+        begin
+          new_node = nil
+          self.class.transaction do
+            new_node = _copy!(parent_id)
+          end
+          new_node
+        rescue ActiveRecord::RecordInvalid
+          add_error_and_raise 'descendant invalid'
+        else
+          update_settings_timestamp
+        end
+      end
+
+      def move parent_id
+        return if parent_id.to_i == self.parent_id
+
+        self.class.transaction do
+          save_under(parent_id)
+          descendants.each do |node|
+            next if node.valid?
+            add_error_and_raise 'descendant invalid'
+          end
+        end
+
+        self
+      end
+
+      # Maintain unique name within parent_id scope.
+      # If name is not unique add numeric postfix.
+      def maintain_name
+        postfix = nil
+        total_count = 0
+
+        while self.class.where(parent_id: parent_id, name: "#{name}#{postfix}").where("id != ?", id.to_i).exists? do
+          total_count += 1
+          postfix = "(#{total_count})"
+        end
+
+        if postfix
+          self.name = "#{name}#{postfix}"
+        end
+      end
+
+      # Returns closest existing locale starting from object itself
+      # @return [String] locale
+      def locale
+        own = super
+        if own
+          own
+        else
+          ancestors.reorder("depth DESC").
+            where("locale IS NOT NULL").
+            first.try(:locale)
+        end
+      end
+
+      # Check whether object and all its ancestors are active
+      # @return [Boolean] returns true if object is available
+      def available?
+        # There seams to be bug in Rails 4.0.0, that prevents us from using exists?
+        # exists? will return nil or 1 in this query, instead of true/false (as it should)
+        self_and_ancestors.where(active: false).any? == false
+      end
+
+      def add_error_and_raise error
+        errors.add(:base, error)
+        raise ActiveRecord::RecordInvalid.new(self)
+      end
+
+      def duplicate_content
+        return nil if content_id.blank?
+
+        new_content = content.dup
+        new_content.save!
+        new_content
+      end
+
+      def copy_attributes_from node
+        node.attributes_to_copy.each do |attribute|
+          send("#{attribute}=", node.send(attribute))
+        end
+      end
+
+      def duplicate_under! parent_id
+        new_node = nil
+        self.class.transaction do
+          new_node = self.class.new
+          new_node.copy_attributes_from self
+          new_node.content_id = duplicate_content.try(:id)
+          new_node.prevent_auto_update_settings_timestamp do
+            new_node.save_under(parent_id)
+          end
+        end
+        new_node
+      end
+
+      def reasign_slug
+        self.slug = nil
+        ensure_unique_url
+      end
+
+      def save_under target_parent_node_id
+        self.parent_id = target_parent_node_id
+        if validate_root_locale_uniqueness?
+          # When copying root nodes it is important to reset locale to nil.
+          # Later user should fill in locale. This is needed to prevent
+          # Rails errors about conflicting routes.
+          self.locale = nil
+        end
+
+        self.item_position = self.class.children_max_item_position(self.parent) + 1
+        maintain_name
+        reasign_slug
+        save!
+      end
+
+      def prevent_auto_update_settings_timestamp &block
+        original = @prevent_auto_update_settings_timestamp
+        @prevent_auto_update_settings_timestamp = true
+        yield
+      ensure
+        @prevent_auto_update_settings_timestamp = original
+      end
+
+      protected
+
+      def validate_root_locale_uniqueness?
+        locale_selection_enabled? && root?
+      end
+
+      def validate_parent_node_is_not_self
+        return if parent_id.nil?
+        return if parent_id.to_i != id
+        self.errors.add(:parent_id, "can't be parent to itself")
+      end
+
+      def validate_parent_is_not_descendant
+        return if parent_id.nil?
+        return if self.descendants.find_by_id(parent_id).blank?
+        self.errors.add(:parent_id, "descendant can't be parent")
+      end
+
+      private
+
+      def _copy! parent_id
+        new_node = duplicate_under! parent_id
+
+        children.each do |child|
+          child.send(:_copy!, new_node.id)
+        end
+        new_node
+      end
+
+      def prevent_infinite_copy_loop(parent_id)
+        return if self_and_descendants.find_by_id(parent_id).blank?
+        add_error_and_raise("source or descendant node can't be parent of new node")
+      end
+
+      def prevent_auto_update_settings_timestamp?
+        @prevent_auto_update_settings_timestamp == true
+      end
+
+      def update_settings_timestamp
+        self.class.updated
+      end
+
+    module ClassMethods
+      def updated_at
+        Releaf::Settings['releaf.content.nodes.updated_at']
+      end
+
+      def updated
+        Releaf::Settings['releaf.content.nodes.updated_at'] = Time.now
+      end
+
+      def children_max_item_position node
+        if node.nil?
+          roots.maximum(:item_position) || 0
+        else
+          node.children.maximum(:item_position) || 0
+        end
+      end
+
+      def valid_node_content_class_names parent_id=nil
+        class_names = []
+        ActsAsNode.classes.each do |class_name|
+          test_node = self.new(content_type: class_name, parent_id: parent_id)
+          test_node.valid?
+          class_names.push class_name unless test_node.errors[:content_type].present?
+        end
+        class_names
+      end
+
+      def valid_node_content_classes parent_id=nil
+        valid_node_content_class_names(parent_id).map(&:constantize)
+      end
+    end
+
+    included do
+      acts_as_nested_set order_column: :item_position
+      acts_as_list scope: :parent_id, column: :item_position
+
+      default_scope { order(:item_position) }
+      scope :active, ->() { where(active: true) }
+
+      validates_presence_of :name, :slug, :content_type
+      validates_uniqueness_of :slug, scope: :parent_id
+      validates_length_of :name, :slug, :content_type, maximum: 255
+      validates_uniqueness_of :locale, scope: :parent_id, if: :validate_root_locale_uniqueness?
+      validates_presence_of :parent, if: :parent_id?
+      validate :validate_parent_node_is_not_self
+      validate :validate_parent_is_not_descendant
+
+      alias_attribute :to_text, :name
+
+      belongs_to :content, polymorphic: true, dependent: :destroy
+      accepts_nested_attributes_for :content
+
+      after_save :update_settings_timestamp, unless: :prevent_auto_update_settings_timestamp?
+
+      acts_as_url :name, url_attribute: :slug, scope: :parent_id, :only_when_blank => true
+    end
+  end
+end

data/lib/releaf/content/node_mapper.rb

@@ -0,0 +1,9 @@
+module Releaf::Content
+  module NodeMapper
+    def releaf_routes_for(node_class, controller: Releaf::Content::Route.node_class_default_controller(node_class), &block)
+      Releaf::Content::Route.for(node_class, controller).each do |route|
+        Releaf::Content::RouterProxy.new(self, route).draw(&block)
+      end
+    end
+  end
+end

data/lib/releaf/content/route.rb

@@ -0,0 +1,93 @@
+module Releaf::Content
+  class Route
+    attr_accessor :path, :node, :locale, :node_id, :default_controller
+
+    def self.node_class
+      # TODO model should be configurable
+      ::Node
+    end
+
+    def self.node_class_default_controller(node_class)
+      if node_class <= ActionController::Base
+        node_class.name.underscore.sub(/_controller$/, '')
+      else
+        node_class.name.pluralize.underscore
+      end
+    end
+
+    # Return node route params which can be used in Rails route options
+    #
+    # @param method_or_path [String] string with action and controller for route (Ex. home#index)
+    # @param options [Hash] options to merge with internally built params. Passed params overrides route params.
+    # @return [Hash] route options. Will return at least node "node_id" and "locale" keys.
+    def params(method_or_path, options = {})
+      method_or_path = method_or_path.to_s
+      action_path = path_for(method_or_path, options)
+      options[:to] = controller_and_action_for(method_or_path, options)
+
+      route_options = options.merge({
+        node_id: node_id.to_s,
+        locale: locale,
+      })
+
+      # normalize as with locale
+      if locale.present? && route_options[:as].present?
+        route_options[:as] = "#{locale}_#{route_options[:as]}"
+      end
+
+      [action_path, route_options]
+    end
+
+    # Return routes for given class that implement ActsAsNode
+    #
+    # @param class_name [Class] class name to load related nodes
+    # @param default_controller [String]
+    # @return [Array] array of Content::Route objects
+    def self.for(content_type, default_controller)
+      node_class.where(content_type: content_type).each.inject([]) do |routes, node|
+        routes << build_route_object(node, default_controller) if node.available?
+        routes
+      end
+    rescue ActiveRecord::NoDatabaseError, ActiveRecord::StatementInvalid
+      []
+    end
+
+    # Build Content::Route from Node object
+    def self.build_route_object(node, default_controller)
+      route = new
+      route.node_id = node.id.to_s
+      route.path = node.path
+      route.locale = node.root.locale
+      route.default_controller = default_controller
+
+      route
+    end
+
+    private
+
+    def path_for(method_or_path, options)
+      if method_or_path.include?('#')
+        path
+      elsif options.key?(:to)
+        "#{path}/#{method_or_path}"
+      else
+        path
+      end
+    end
+
+    def controller_and_action_for(method_or_path, options)
+      if method_or_path.start_with?('#')
+        "#{default_controller}#{method_or_path}"
+      elsif method_or_path.include?('#')
+        method_or_path
+      elsif options[:to].try!(:start_with?, '#')
+        "#{default_controller}#{options[:to]}"
+      elsif options[:to].try!(:include?, '#')
+        options[:to]
+      else
+        "#{default_controller}##{method_or_path}"
+      end
+    end
+
+  end
+end

data/lib/releaf/content/router_proxy.rb

@@ -0,0 +1,23 @@
+module Releaf::Content
+  class RouterProxy
+    attr_accessor :router, :releaf_route
+
+    def initialize(router, releaf_route)
+      self.router = router
+      self.releaf_route = releaf_route
+    end
+
+    def draw(&block)
+      instance_exec(releaf_route, &block)
+    end
+
+    def method_missing(method_name, *args, &block)
+      if router.respond_to?(method_name)
+        router.public_send(method_name, *releaf_route.params(*args), &block)
+      else
+        super
+      end
+    end
+  end
+
+end

data/releaf-content.gemspec

@@ -0,0 +1,20 @@
+require File.expand_path("../../releaf-core/lib/releaf/version.rb", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "releaf-content"
+  s.version     = Releaf::VERSION
+
+  s.summary     = "Node and content routes support for releaf"
+  s.description = "Content subsystem for releaf"
+  s.authors     = ["CubeSystems"]
+  s.email       = 'info@cubesystems.lv'
+  s.homepage    = 'https://github.com/cubesystems/releaf'
+
+  s.files             = `git ls-files`.split("\n")
+  s.test_files = Dir["spec/**/*"]
+
+  s.add_dependency 'releaf-core', Releaf::VERSION
+  s.add_dependency 'stringex'
+  s.add_dependency 'awesome_nested_set'
+
+end

data/spec/builders/content/nodes/content_form_builder_spec.rb

@@ -0,0 +1,24 @@
+require "rails_helper"
+
+describe Releaf::Content::Nodes::ContentFormBuilder, type: :class do
+  class FormBuilderTestHelper < ActionView::Base
+    include Releaf::ApplicationHelper
+    include Releaf::ButtonHelper
+    include FontAwesome::Rails::IconHelper
+    def controller_scope_name; end
+    def generate_url_releaf_content_nodes_path(args); end
+  end
+
+  let(:template){ FormBuilderTestHelper.new }
+  let(:node){ Node.new(content_type: "TextPage", slug: "b", id: 2,
+                         parent: Node.new(content_type: "TextPage", slug: "a", id: 1)) }
+  let(:object){ node.build_content }
+  let(:subject){ described_class.new(:resource, object, template, {}) }
+
+  describe "#field_names" do
+    it "returns array of node content object fields" do
+      allow(object.class).to receive(:acts_as_node_fields).and_return(["a", "b"])
+      expect(subject.field_names).to eq(["a", "b"])
+    end
+  end
+end