composite_content 1.0.0

data/lib/composite_content/action_view.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module CompositeContent
+  # Additional views helpers to manipulate composite content.
+  module ActionView
+    # Render the content of a CompositeContent::Slot.
+    def composite_content_render(slot)
+      renders = slot.blocks.collect do |block|
+        render "composite_content/blocks/#{block.blockable.block_type}/show", block: block
+      end
+
+      safe_join(renders)
+    end
+
+    # Output an action link to add a block to a slot.
+    #
+    # ==== Signatures
+    #
+    #   composite_content_add_block_link(label, form, block_type, options = {})
+    #     # Explicit name
+    #
+    #   composite_content_add_block_link(form, block_type, options = {}) do
+    #     # Name as a block
+    #   end
+    #
+    #   composite_content_add_block_link(form, block_type, options = {})
+    #     # Use default name
+    #
+    # ==== Parameters
+    #
+    # `label` is the text to be used as the link label.
+    # Just as when you use the Rails builtin helper +link_to+, you can give an explicit
+    # label to your link or use a block to build it. If you provide neither an explicit
+    # label nor a  block, the default label will be used, looking for an I18n key named
+    # `composite_content.blocks.{block type}.add`.
+    #
+    # `form` is your form builder. Can be a SimpleForm::Builder, Formtastic::Builder or
+    # a standard Rails FormBuilder.
+    #
+    # `options` are passed to the cocooned_add_item_link helper, which some adjustements:
+    # :count, :form_name, :force_non_association_create are ignored, :form_name, :partial
+    # and :wrap_object are forced on purpose. Any other option will be passed.
+    # See the documentation of cocooned_add_item_link for details.
+    def composite_content_add_block_link(*args, &block)
+      return composite_content_add_block_link(capture(&block), *args) if block
+      return composite_content_add_block_link(nil, *args) if args.first.respond_to?(:object)
+
+      label, form, block_type, options = *args
+      label ||= composite_content_default_label(block_type)
+      opts = (options || {}).except(:count, :form_name, :force_non_association_create)
+                            .merge!(form_name: :form,
+                                    partial: 'composite_content/block/form',
+                                    wrap_object: ->(b) { composite_content_wrap_block(b, block_type) })
+
+      cocooned_add_item_link(label, form, :blocks, opts)
+    end
+
+    # Alias to cocooned_move_item_up_link
+    def composite_content_move_block_up_link(*args, &block)
+      cocooned_move_item_up_link(*args, &block)
+    end
+
+    # Alias to cocooned_move_item_down_link
+    def composite_content_move_block_down_link(*args, &block)
+      cocooned_move_item_down_link(*args, &block)
+    end
+
+    # Alias to cocooned_remove_item_link
+    def composite_content_remove_block_link(*args, &block)
+      cocooned_remove_item_link(*args, &block)
+    end
+
+    protected
+
+    def composite_content_default_label(block_type)
+      I18n.t("composite_content.blocks.#{block_type}.add")
+    end
+
+    def composite_content_wrap_block(block, block_type)
+      block.blockable = CompositeContent::Blocks.const_get(block_type.to_s.classify).new
+      block
+    end
+  end
+end

data/lib/composite_content/active_record.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module CompositeContent
+  module ActiveRecord # :nodoc:
+    extend ActiveSupport::Concern
+
+    # Integration methods with ActiveRecord models
+    # These methods are available on any ActiveRecord model once CompositeContent is loaded.
+    #
+    # rubocop:disable Naming/PredicateName, Rails/ReflectionClassName
+    module ClassMethods
+      def has_composite_content(name = :composite_content, types: [])
+        CompositeContent::Model::Builder::Block.build(self, name, types)
+        slot_class = CompositeContent::Model::Builder::Slot.build(self, name, types)
+
+        has_one name, class_name: slot_class.name, as: :parent, dependent: :destroy
+        accepts_nested_attributes_for name, reject_if: :all_blank
+
+        include Mixins.instance_mixin(name)
+        extend Mixins.class_mixin(name)
+      end
+    end
+    # rubocop:enable Naming/PredicateName, Rails/ReflectionClassName
+
+    module Mixins # :nodoc:
+      class << self
+        def instance_mixin(name)
+          Module.new do
+            define_method name do
+              super() || send(:"build_#{name}")
+            end
+          end
+        end
+
+        def class_mixin(name)
+          Module.new do
+            define_method "strong_parameters_for_#{name}" do
+              reflect_on_association(name).class_name.constantize.strong_parameters
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composite_content/block.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module CompositeContent
+  # Base class for all types of blocks.
+  class Block < ::CompositeContent::Model::Base
+    acts_as_list scope: :slot_id
+
+    # Delegation to block types is dynamically declared when building dedicated slot and
+    # block classes. See CompositeContent::Model::Builder.
+  end
+end

data/lib/composite_content/blocks/heading.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CompositeContent
+  module Blocks
+    class Heading < ::CompositeContent::Model::Base
+      include ::CompositeContent::Model::Blockable
+
+      validates :level,
+                presence: true,
+                numericality: {
+                  allow_blank: true,
+                  only_integer: true,
+                  greater_than_or_equal_to: 1,
+                  less_than_or_equal_to: 6
+                }
+
+      validates :content,
+                presence: true
+    end
+  end
+end

data/lib/composite_content/blocks/quote.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module CompositeContent
+  module Blocks
+    class Quote < ::CompositeContent::Model::Base
+      include ::CompositeContent::Model::Blockable
+
+      validates :content,
+                presence: true
+    end
+  end
+end

data/lib/composite_content/blocks/text.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module CompositeContent
+  module Blocks
+    class Text < ::CompositeContent::Model::Base
+      include ::CompositeContent::Model::Blockable
+
+      validates :content,
+                presence: true
+    end
+  end
+end

data/lib/composite_content/blocks.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module CompositeContent
+  module Blocks
+    extend ActiveSupport::Autoload
+
+    autoload :Heading
+    autoload :Quote
+    autoload :Text
+  end
+end

data/lib/composite_content/engine.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'rails'
+require 'active_model_validations_reflection'
+require 'acts_as_list'
+require 'cocooned'
+
+module CompositeContent
+  class Engine < ::Rails::Engine # :nodoc:
+    # Configurable engine options
+    #
+    # Feel free to adjust these settings in a initializer in your application.
+    # Ex:
+    #
+    #     # In config/initializers/composite_content.rb
+    #     require 'composite_content'
+    #     CompositeContent::Engine.config.block_types += %w[CompositeContent::Blocks::Image]
+
+    # Allowed block types
+    config.block_types = %w[
+      CompositeContent::Blocks::Heading
+      CompositeContent::Blocks::Quote
+      CompositeContent::Blocks::Text
+    ]
+
+    # Engine internals
+    #
+    # Following configurations are here for engine initialization and internal
+    # configurations and are not meant to be changed by your application.
+
+    # Isolate models (and their tables) in their own namespace.
+    isolate_namespace CompositeContent
+
+    config.i18n.load_path += Dir[root.join('config', 'locales', '**', '*.{rb,yml}')]
+
+    initializer 'composite_content.active_record' do |_app|
+      ::ActiveSupport.on_load :active_record do
+        require 'composite_content/active_record'
+        include CompositeContent::ActiveRecord
+      end
+    end
+
+    initializer 'composite_content.action_view' do |_app|
+      ActiveSupport.on_load :action_view do
+        require 'composite_content/action_view'
+        include CompositeContent::ActionView
+      end
+    end
+  end
+end

data/lib/composite_content/model/base.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module CompositeContent
+  module Model
+    # Base class for engine's models.
+    # Equivalent to ApplicationRecord in a Rails app.
+    class Base < ::ActiveRecord::Base
+      self.abstract_class = true
+
+      include ActiveModel::Validations::Reflection
+    end
+  end
+end

data/lib/composite_content/model/blockable.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CompositeContent
+  module Model
+    # Shared behaviors for concrete block implementations
+    module Blockable
+      extend ActiveSupport::Concern
+
+      included do
+        has_one :block,
+                as: :blockable,
+                touch: true,
+                dependent: :destroy
+      end
+
+      def block_type
+        self.class.name.demodulize.underscore
+      end
+    end
+  end
+end

data/lib/composite_content/model/builder/base.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module CompositeContent
+  module Model
+    module Builder
+      class Base # :nodoc:
+        BLOCK_SUFFIX = 'Block'
+        SLOT_SUFFIX = 'Slot'
+
+        class << self
+          def build(parent, association, types = [])
+            new.build(parent, association, types)
+          end
+        end
+
+        def build(parent, association, types = [])
+          demodulized = build_classname(parent, association).demodulize
+
+          parent.const_set(demodulized, build_class(parent, association, types))
+          parent.const_get(demodulized)
+        end
+
+        def build_class(_parent, _association, _types = [])
+          raise NotImplementedError
+        end
+
+        def build_classname(_parent, _association)
+          raise NotImplementedError
+        end
+
+        protected
+
+        def classname_for_slot(parent, association)
+          classname_for(parent, association, SLOT_SUFFIX)
+        end
+
+        def classname_for_block(parent, association)
+          classname_for(parent, association, BLOCK_SUFFIX)
+        end
+
+        def classname_for(parent, association, suffix)
+          [parent.model_name.to_s, [association.to_s.singularize.classify, suffix].join].join('::')
+        end
+      end
+    end
+  end
+end

data/lib/composite_content/model/builder/block.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module CompositeContent
+  module Model
+    module Builder
+      # Class builder for Block models
+      #
+      # Every composite content slot as its own block class, subclass of CompositeContent::Block.
+      # This allows to set distinct validations on allowed block types used in each composite
+      # content.
+      class Block < Base
+        alias build_classname classname_for_block
+
+        def build_class(parent, association, types = [])
+          Class.new(::CompositeContent::Block).tap do |klass|
+            klass.belongs_to :slot, class_name: classname_for_slot(parent, association), inverse_of: :blocks
+
+            klass.delegated_type :blockable, types: blockable_types(types), dependent: :destroy
+            klass.accepts_nested_attributes_for :blockable, reject_if: :all_blank
+
+            klass.validates_associated :blockable
+            klass.validates :blockable_type, inclusion: { in: blockable_types(types) }
+          end
+        end
+
+        protected
+
+        def blockable_types(types)
+          return CompositeContent::Engine.config.block_types if types.empty?
+
+          CompositeContent::Engine.config.block_types & types
+        end
+      end
+    end
+  end
+end

data/lib/composite_content/model/builder/slot.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module CompositeContent
+  module Model
+    module Builder
+      # Class builder for Slot models
+      #
+      # Every composite content slot is defined by its own class, subclass of CompositeContent::Slot.
+      # This allows to use of a dedicated block class where we can set validations on block types and
+      # to rely on ActiveRecord default behaviors for Single Table Inheritance models (as adding a
+      # constraint on type to queries).
+      class Slot < Base
+        alias build_classname classname_for_slot
+
+        def build_class(parent, association, _types = [])
+          Class.new(CompositeContent::Slot).tap do |klass|
+            klass.has_many :blocks,
+                           -> { order(position: :asc) },
+                           class_name: classname_for_block(parent, association),
+                           foreign_key: :slot_id,
+                           inverse_of: :slot,
+                           dependent: :destroy
+
+            klass.accepts_nested_attributes_for :blocks, allow_destroy: true, reject_if: :all_blank
+            klass.validates_associated :blocks
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composite_content/model/builder.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module CompositeContent
+  module Model
+    module Builder # :nodoc:
+      extend ActiveSupport::Autoload
+
+      autoload :Base
+      autoload :Block
+      autoload :Slot
+    end
+  end
+end

data/lib/composite_content/model.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module CompositeContent
+  module Model
+    extend ActiveSupport::Autoload
+
+    autoload :Base
+    autoload :Blockable
+    autoload :Builder
+  end
+end

data/lib/composite_content/slot.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module CompositeContent
+  # Slots are used as container for blocks collection.
+  #
+  # Whether a model as one or more composite content slots does not matter: blocks are always
+  # contained in a slot. This allows to keep programming interface consistent between uses and
+  # ease future integration of multiple slots on model where only one was expected at first.
+  class Slot < ::CompositeContent::Model::Base
+    belongs_to :parent, polymorphic: true
+
+    # Compatibility with parent models using Single Table Inheritance.
+    # See ActiveRecord::Associations::ClassMethods's overview for more detail.
+    def parent_type=(class_name)
+      super(class_name.constantize.base_class.to_s)
+    end
+
+    # Association with blocks is dynamically declared when building dedicated slot and
+    # block classes. See CompositeContent::Model::Builder.
+
+    class << self
+      def block_class
+        @block_class ||= reflect_on_association(:blocks).class_name.constantize
+      end
+
+      def blockable_classes
+        @blockable_classes ||= begin
+          validators = block_class.validators_on_of_kinds(:blockable_type, :inclusion)
+          types = validators.collect(&:options).collect { |opts| opts.fetch(:in) }.flatten.compact.uniq
+          types.collect(&:constantize)
+        end
+      end
+
+      def strong_parameters
+        [:id, { blocks_attributes: block_column_names + [{ blockable_attributes: blockable_column_names }, :_destroy] }]
+      end
+
+      protected
+
+      def block_column_names
+        @block_column_names ||= begin
+          columns = block_class.column_names.collect(&:to_sym)
+          columns - %i[slot_id blockable_id created_at updated_at]
+        end
+      end
+
+      def blockable_column_names
+        @blockable_column_names ||= begin
+          columns = blockable_classes.collect(&:column_names).flatten.collect(&:to_sym).compact.uniq
+          columns - %i[created_at updated_at]
+        end
+      end
+    end
+  end
+end

data/lib/composite_content/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CompositeContent
+  VERSION = '1.0.0'
+end

data/lib/composite_content.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'composite_content/version'
+require 'composite_content/engine'
+require 'composite_content/model'
+require 'composite_content/active_record'
+
+module CompositeContent # :nodoc:
+  extend ActiveSupport::Autoload
+
+  autoload :Block
+  autoload :Blocks
+  autoload :Slot
+end

data/lib/generators/composite_content/install_generator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module CompositeContent
+  module Generators
+    # Generator to copy CompositeContent views into an application.
+    class InstallGenerator < Rails::Generators::Base
+      desc 'Copies composite_content partial templates to your application.'
+
+      source_root File.expand_path('templates', __dir__)
+
+      def copy_views
+        directory File.join(self.class.source_root), 'app/views/composite_content'
+      end
+
+      def copy_migrations
+        rake 'composite_content:install:migrations'
+      end
+    end
+  end
+end

data/lib/generators/composite_content/templates/block/_form.html.erb

@@ -0,0 +1,13 @@
+<div class="cocooned-item">
+  <%= form.hidden_field :id %>
+  <%= form.hidden_field :position %>
+  <%= form.hidden_field :blockable_type %>
+
+  <%= form.fields_for :blockable, form.object.blockable do |blockable_form| %>
+    <%= render "composite_content/blocks/#{form.object.blockable.block_type}/form", form: blockable_form %>
+  <% end %>
+
+  <%= composite_content_move_block_up_link form %>
+  <%= composite_content_move_block_down_link form %>
+  <%= composite_content_remove_block_link form %>
+</div>

data/lib/generators/composite_content/templates/blocks/heading/_form.html.erb

@@ -0,0 +1,9 @@
+<div>
+  <%= form.label :level %>
+  <%= form.text_field :level %>
+</div>
+
+<div>
+  <%= form.label :content %>
+  <%= form.text_field :content %>
+</div>

data/lib/generators/composite_content/templates/blocks/heading/_show.html.erb

@@ -0,0 +1 @@
+<h<%= block.blockable.level %>><%= block.blockable.content %></h<%= block.blockable.level %>>

data/lib/generators/composite_content/templates/blocks/quote/_form.html.erb

@@ -0,0 +1,9 @@
+<div>
+  <%= form.label :source %>
+  <%= form.text_field :source %>
+</div>
+
+<div>
+  <%= form.label :content %>
+  <%= form.text_area :content %>
+</div>

data/lib/generators/composite_content/templates/blocks/quote/_show.html.erb

@@ -0,0 +1,7 @@
+<figure class="quote">
+  <blockquote><%= block.blockable.content %></blockquote>
+
+  <% if block.blockable.source.present? %>
+    <figcaption><%= block.blockable.source %></figcaption>
+  <% end %>
+</figure>

data/lib/generators/composite_content/templates/blocks/text/_form.html.erb

@@ -0,0 +1,4 @@
+<div>
+  <%= form.label :content %>
+  <%= form.text_area :content %>
+</div>

data/lib/generators/composite_content/templates/blocks/text/_show.html.erb

@@ -0,0 +1 @@
+<%= block.blockable.content %>

data/lib/generators/composite_content/templates/slot/_form.html.erb

@@ -0,0 +1,13 @@
+<%= form.hidden_field :id %>
+
+<div data-cocooned-options="<%= { reorderable: true }.to_json %>">
+  <%= form.fields_for :blocks do |block_form| %>
+    <%= render 'composite_content/block/form', form: block_form %>
+  <% end %>
+
+  <div class="links">
+    <%= composite_content_add_block_link form, :heading %>
+    <%= composite_content_add_block_link form, :quote %>
+    <%= composite_content_add_block_link form, :text %>
+  </div>
+</div>