releaf-content 0.2.1

data/app/middleware/releaf/content/routes_reloader.rb

@@ -0,0 +1,25 @@
+module Releaf::Content
+  class RoutesReloader
+    def initialize(app)
+      @app = app
+      self.class.routes_loaded
+    end
+
+    def call(env)
+      self.class.reload_if_expired
+      @app.call(env)
+    end
+
+    def self.routes_loaded
+      @updated_at = Time.now
+    end
+
+    def self.reload_if_expired
+      # TODO Node class should be configurable
+      return unless ::Node.updated_at.present? && @updated_at && @updated_at < ::Node.updated_at
+      Rails.application.reload_routes!
+      routes_loaded
+    end
+
+  end
+end

data/app/validators/releaf/content/node/parent_validator.rb

@@ -0,0 +1,48 @@
+module Releaf
+  module Content::Node
+    # Validator to test if node is valid, when created under given parrent node
+    #
+    # validator needs :for and :under options, both can be either array of classes
+    # or single class.
+    #
+    # :for option specifies for which nodes validation should be applied
+    #
+    # :under option specifies under which nodes given node can be added
+    #
+    # @example
+    #
+    #   class Node < ActiveRecord::Base
+    #     includes Releaf::Content::Node
+    #     validates_with Releaf::Content::Node::ParentValidator, for: [Text, Book], under: Store
+    #   end
+    #
+    class ParentValidator < ActiveModel::Validator
+
+      def validate node
+        @node = node
+        node.errors.add(:content_type, 'invalid parent node') unless node_parent_valid?
+        remove_instance_variable(:@node)
+      end
+
+      private
+
+      def node_parent_valid?
+        return true unless child_class_names.include? @node.content_type
+        return parent_class_names.include? @node.parent.try(:content_type)
+      end
+
+      def child_class_names
+        target_class_names :for
+      end
+
+      def parent_class_names
+        target_class_names :under
+      end
+
+      def target_class_names target_type
+        [options.fetch(target_type, [])].flatten.map(&:name)
+      end
+
+    end
+  end
+end

data/app/validators/releaf/content/node/root_validator.rb

@@ -0,0 +1,43 @@
+module Releaf
+  module Content::Node
+    # Validator to test if node is valid root node
+    #
+    # Validator needs :allow option.
+    #
+    # :allow option specifies which nodes are valid root nodes.
+    #
+    # @example
+    #
+    #   class Node < ActiveRecord::Base
+    #     includes Releaf::Content::Node
+    #     validates_with Releaf::Content::Node::RootValidator, allow: [Text, Store]
+    #   end
+    #
+    # In example above only Text and Book nodes can be created as root nodes
+    class RootValidator < ActiveModel::Validator
+
+      def validate node
+        @node = node
+
+        if allowed_root_node?
+          node.errors.add(:content_type, "can't be subnode") if @node.parent.present?
+        else
+          node.errors.add(:content_type, "can't be root node") if @node.parent.nil?
+        end
+
+        remove_instance_variable(:@node)
+      end
+
+      private
+
+      def allowed_root_node?
+        root_class_names.include? @node.content_type
+      end
+
+      def root_class_names
+        [options.fetch(:allow, [])].flatten.map(&:name)
+      end
+
+    end
+  end
+end

data/app/validators/releaf/content/node/singleness_validator.rb

@@ -0,0 +1,102 @@
+module Releaf
+  module Content::Node
+    # Validator to test if node is valid, when created under given parrent node
+    #
+    # validator needs :for and :under options, both can be either array of classes
+    # or single class.
+    #
+    # :for option specifies for which nodes validation should be applied
+    #
+    # :under option specifies under which nodes only single node of given type
+    # should be valid.
+    # If under is unspecified, then only single node with given class can be
+    # created under entrie content tree.
+    #
+    # @example
+    #
+    #   class Node < ActiveRecord::Base
+    #     includes Releaf::Content::Node
+    #     validates_with Releaf::Content::Node::ParentValidator, for: [Text, Book], under: Store
+    #   end
+    #
+    # In the example above, Text node or book node can be added in any leve
+    # under Store node, but only once.
+    # However they can be added to any other node as many times as needed, as
+    # long as none of ancestors are Store node.
+    class SinglenessValidator < ActiveModel::Validator
+
+      def validate node
+        @node = node
+        node.errors.add(:content_type, 'node exists') unless node_valid?
+        remove_instance_variable(:@node)
+      end
+
+      private
+
+      def node_valid?
+        return true unless child_class_names.include? @node.content_type
+
+        relation = base_relation_for_validation
+        # if relation is nil, then node is under ancestor for which this validation
+        # shouldn't be appied
+        return true if relation.nil?
+
+        unless @node.new_record?
+          relation = relation.where('id <> ?', @node.id)
+        end
+
+        relation.any? == false
+      end
+
+      def base_relation_for_validation
+        if ancestor_classes.blank?
+          return base_relation_for_entire_tree
+        else
+          return base_relation_for_subtree
+        end
+      end
+
+      def base_relation_for_entire_tree
+        @node.class.unscoped.where(content_type: @node.content_type)
+      end
+
+      def base_relation_for_subtree
+        return nil if @node.parent.nil?
+
+        # need to find parent node again, because Node.roots[n].ancestors can
+        # return some other parent, than @node.parent.ancestors, even though
+        # both return same node.
+        # Seams like a bug in AwesomeNestedSet (in case of @node.parent.ancestors).
+        parent_node = Node.find(@node.parent_id)
+
+        ancestor_node = parent_node.self_and_ancestors.where(content_type: ancestor_class_names).reorder(:depth).last
+        if ancestor_node.nil?
+          return nil
+        else
+          return ancestor_node.descendants.where(content_type: @node.content_type)
+        end
+      end
+
+      def child_class_names
+        target_class_names :for
+      end
+
+      def ancestor_class_names
+        target_class_names :under
+      end
+
+      def ancestor_classes
+        target_classes :under
+      end
+
+      def target_classes target_type
+        [options.fetch(target_type, [])].flatten
+      end
+
+      def target_class_names target_type
+        target_classes(target_type).map(&:name)
+      end
+
+    end
+  end
+end

data/app/views/releaf/content/nodes/content_type_dialog.ruby

@@ -0,0 +1 @@
+Releaf::Content::ContentTypeDialogBuilder.new(self).output

data/app/views/releaf/content/nodes/copy_dialog.ruby

@@ -0,0 +1 @@
+Releaf::Content::CopyDialogBuilder.new(self).output

data/app/views/releaf/content/nodes/go_to_dialog.ruby

@@ -0,0 +1 @@
+Releaf::Content::GoToDialogBuilder.new(self).output

data/app/views/releaf/content/nodes/move_dialog.ruby

@@ -0,0 +1 @@
+Releaf::Content::MoveDialogBuilder.new(self).output

data/lib/releaf-content.rb

@@ -0,0 +1,6 @@
+require 'releaf/content/router_proxy'
+require 'releaf/content/node_mapper'
+require 'releaf/content/engine'
+require 'releaf/content/acts_as_node'
+require 'releaf/content/node'
+require 'releaf/content/route'

data/lib/releaf/content/acts_as_node.rb

@@ -0,0 +1,73 @@
+require 'releaf/content/acts_as_node/active_record/acts/node'
+require 'releaf/content/acts_as_node/action_controller/acts/node'
+
+module ActsAsNode
+  @classes = []
+
+  def self.register_class(class_name)
+    @classes << class_name unless @classes.include? class_name
+  end
+
+  module ClassMethods
+
+    # Load all nodes for class
+    def nodes
+      ::Node.where(content_type: self.name)
+    end
+
+    # There are no configuration options yet.
+    #
+    def acts_as_node(params: nil, fields: nil)
+      configuration = {params: params, fields: fields}
+
+      ActsAsNode.register_class(self.name)
+
+      # Store acts_as_node configuration
+      cattr_accessor :acts_as_node_configuration
+      self.acts_as_node_configuration = configuration
+    end
+  end
+
+  def self.classes
+    # eager load in dev env
+    Rails.application.eager_load! if Rails.env.development?
+
+    @classes
+  end
+
+  if defined? Rails::Railtie
+    require 'rails'
+    class Railtie < Rails::Railtie
+      initializer 'acts_as_node.insert' do
+        ActiveSupport.on_load :active_record do
+          ActsAsNode::Railtie.insert_into_active_record
+        end
+
+        ActiveSupport.on_load :action_controller do
+          ActsAsNode::Railtie.insert_into_action_controller
+        end
+      end
+    end
+  end
+
+  class Railtie
+    def self.insert
+      insert_into_active_record
+      insert_into_action_controller
+    end
+
+    def self.insert_into_active_record
+      if defined?(ActiveRecord)
+        ActiveRecord::Base.send(:include, ActiveRecord::Acts::Node)
+      end
+    end
+
+    def self.insert_into_action_controller
+      if defined?(ActionController)
+        ActionController::Base.send(:include, ActionController::Acts::Node)
+      end
+    end
+  end
+end
+
+ActsAsNode::Railtie.insert

data/lib/releaf/content/acts_as_node/action_controller/acts/node.rb

@@ -0,0 +1,17 @@
+module ActionController
+  module Acts #:nodoc:
+    # This +acts_as+ extension provides the capabilities for attaching object to nodes tree.
+    #
+    # Text example:
+    #
+    #   class ContactFormController < ActionController::Base
+    #     has_many :acts_as_node
+    #   end
+    #
+    module Node #:nodoc:
+      def self.included(base)
+        base.extend(::ActsAsNode::ClassMethods)
+      end
+    end
+  end
+end

data/lib/releaf/content/acts_as_node/active_record/acts/node.rb

@@ -0,0 +1,55 @@
+module ActiveRecord
+  module Acts #:nodoc:
+    module Node #:nodoc:
+      def self.included(base)
+        base.extend(::ActsAsNode::ClassMethods)
+        base.extend(ClassMethods)
+      end
+
+      # This +acts_as+ extension provides the capabilities for attaching object to nodes tree.
+      #
+      # Text example:
+      #
+      #   class Text < ActiveRecord::Base
+      #     has_many :acts_as_node
+      #   end
+      #
+      module ClassMethods
+        def acts_as_node(params: nil, fields: nil)
+          super
+          include ::ActiveRecord::Acts::Node::InstanceMethods
+        end
+
+        def acts_as_node_params
+          if acts_as_node_configuration[:params].nil?
+            Releaf::Core::ResourceParams.new(self).values << :id
+          else
+            acts_as_node_configuration[:params] << :id
+          end
+        end
+
+        # Returns fields to display for releaf content controller
+        #
+        # @return [Array] list of fields to display
+        def acts_as_node_fields
+          if acts_as_node_configuration[:fields].nil?
+            Releaf::Core::ResourceFields.new(self).values
+          else
+            acts_as_node_configuration[:fields]
+          end
+        end
+      end
+
+      # All the methods available to a record that has had <tt>acts_as_node</tt> specified.
+      module InstanceMethods
+
+        # Return object corresponding node object
+        # @return [::Node]
+        def node
+          ::Node.find_by(content_type: self.class.name, content_id: id)
+        end
+
+      end
+    end
+  end
+end

data/lib/releaf/content/builders_autoload.rb

@@ -0,0 +1,18 @@
+root_path = File.expand_path('../..', File.dirname(__dir__))
+files = %w(
+  builders/tree
+  builders/dialog
+  builders/action_dialog
+  content_type_dialog_builder
+  copy_dialog_builder
+  copy_dialog_builder
+  go_to_dialog_builder
+  move_dialog_builder
+  nodes/content_form_builder
+  nodes/form_builder
+  nodes/index_builder
+  nodes/toolbox_builder
+)
+files.each do|file|
+ require "#{root_path}/app/builders/releaf/content/#{file}"
+end

data/lib/releaf/content/engine.rb

@@ -0,0 +1,40 @@
+require 'awesome_nested_set'
+require 'stringex'
+
+module Releaf::Content
+  require 'releaf/content/builders_autoload'
+  class Engine < ::Rails::Engine
+    initializer 'precompile', group: :all do |app|
+      app.config.assets.precompile += %w(releaf/controllers/releaf/content/*)
+    end
+  end
+
+  def self.initialize_component
+    Rails.application.config.middleware.use Releaf::Content::RoutesReloader
+  end
+
+  def self.draw_component_routes router
+    router.namespace :releaf, path: nil do
+      router.namespace :content, path: nil do
+        router.releaf_resources :nodes, except: [:show] do
+          router.collection do
+            router.get :content_type_dialog
+            router.get :generate_url
+            router.get :go_to_dialog
+          end
+
+          router.member do
+            router.get :copy_dialog
+            router.post :copy
+            router.get :move_dialog
+            router.post :move
+          end
+        end
+      end
+    end
+  end
+
+  ActiveSupport.on_load :action_controller do
+    ActionDispatch::Routing::Mapper.send(:include, Releaf::Content::NodeMapper)
+  end
+end