para 0.4.0

data/lib/para/model_field_parsers/redactor.rb

@@ -0,0 +1,19 @@
+module Para
+  module ModelFieldParsers
+    class Redactor < Para::ModelFieldParsers::Base
+      register :redactor, self
+
+      def parse!
+        %w(content description).each do |field_name|
+          field = fields_hash[field_name]
+
+          if field && field.type == :text
+            fields_hash[field_name] = Para::AttributeField::Redactor.new(
+              field.model, name: field_name
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/para/model_field_parsers/relations.rb

@@ -0,0 +1,67 @@
+module Para
+  module ModelFieldParsers
+    class Relations < Para::ModelFieldParsers::Base
+      register :relations, self
+
+      def parse!
+        model.reflections.each do |name, reflection|
+          # We ensure that name is a symbol and not a string for 4.2+
+          # versions of AR
+          # We may find a better solution to handle strings, since our
+          # `fields_hash` is already a `HashWithIndifferentAccess`
+          name = name.to_sym
+
+          next if name == :component
+
+          # Remove foreign key, if existing, from fields
+          fields_hash.delete(reflection.foreign_key.to_s)
+
+          if reflection.options[:polymorphic] == true
+            fields_hash.delete(reflection.foreign_type.to_s)
+            next
+          end
+
+          if model.nested_attributes_options[name]
+            if reflection.collection?
+              fields_hash[name] = AttributeField::NestedManyField.new(
+                model, name: name, type: 'has_many', field_type: 'nested_many'
+              )
+            else
+              fields_hash[name] = AttributeField::NestedOneField.new(
+                model, name: name, type: 'belongs_to', field_type: 'nested_one'
+              )
+            end
+          else
+            if reflection.collection?
+              remove_counter_cache_column!(name, reflection)
+
+              fields_hash[name] = AttributeField::HasManyField.new(
+                model, name: name, type: 'has_many', field_type: 'selectize'
+              )
+            else
+              fields_hash[name] = AttributeField::BelongsToField.new(
+                model, name: name, type: 'belongs_to', field_type: 'selectize'
+              )
+            end
+          end
+        end
+      end
+
+      # Allows removing counter cache columns from fields from has_many
+      # relations, when :inverse_of option is set
+      #
+      def remove_counter_cache_column!(name, reflection)
+        return unless (inverse_relation = reflection.inverse_of)
+        return unless (counter_name = inverse_relation.options[:counter_cache])
+
+        counter_name = if String === counter_name
+          counter_name
+        else
+          "#{ name }_count"
+        end
+
+        fields_hash.delete(counter_name)
+      end
+    end
+  end
+end

data/lib/para/model_field_parsers.rb

@@ -0,0 +1,22 @@
+module Para
+  module ModelFieldParsers
+    def self.registered_parsers
+      @registered_parsers ||= {}
+    end
+
+    def self.parse!(model, fields_hash)
+      registered_parsers.each do |_, parser_class|
+        parser = parser_class.new(model, fields_hash)
+        parser.parse! if parser.applicable?
+      end
+    end
+  end
+end
+
+require 'para/model_field_parsers/base'
+require 'para/model_field_parsers/devise'
+require 'para/model_field_parsers/paperclip'
+require 'para/model_field_parsers/orderable'
+require 'para/model_field_parsers/relations'
+require 'para/model_field_parsers/redactor'
+require 'para/model_field_parsers/globalize'

data/lib/para/orderable.rb

@@ -0,0 +1,44 @@
+module Para
+  module Orderable
+    extend ActiveSupport::Concern
+
+    included do
+      scope :ordered, -> { order('position ASC') }
+      before_create :orederable_assign_position
+    end
+
+    def orederable_assign_position
+      last_resource = self.class.order('position DESC')
+        .where.not(position: nil)
+        .select(:position)
+        .first
+
+      self.position = if last_resource && last_resource.position
+        last_resource.position + 1
+      else
+        0
+      end
+    end
+  end
+
+  module ActiveRecordOrderableMixin
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :orderable
+    end
+
+    module ClassMethods
+      def acts_as_orderable
+        return if orderable?
+
+        self.orderable = true
+        include Para::Orderable
+      end
+
+      def orderable?
+        !!orderable
+      end
+    end
+  end
+end

data/lib/para/routes.rb

@@ -0,0 +1,49 @@
+module Para
+  class Routes
+    attr_reader :router
+
+    def initialize(router)
+      @router = router
+    end
+
+    def draw(mount_location = '/', &block)
+      routes = self
+
+      router.instance_eval do
+        scope mount_location do
+          scope module: :para do
+            namespace :admin do
+              get '/' => 'main#index'
+
+              component :crud do
+                scope ':model' do
+                  resources :crud_resources, path: '/' do
+                    collection do
+                      patch :order
+                      patch :tree
+                      get :export
+                    end
+
+                    member do
+                      post :clone
+                    end
+                  end
+                end
+              end
+
+              component :singleton_resource, path: 'resource-form' do
+                resource :singleton_resource, path: 'resource', only: [:create, :update]
+              end
+
+              component :settings do
+                resource :settings_form, controller: 'settings_form', only: [:update]
+              end
+            end
+          end
+
+          block.call if block
+        end
+      end
+    end
+  end
+end

data/lib/para/version.rb

@@ -0,0 +1,3 @@
+module Para
+  VERSION = "0.4.0"
+end

data/lib/para.rb

@@ -0,0 +1,65 @@
+require 'devise'
+require 'paperclip'
+require 'simple_form'
+require 'simple_form_extension'
+require 'active_decorator'
+require 'friendly_id'
+require 'haml-rails'
+require 'truncate_html'
+require 'cocoon'
+require 'cancan'
+require 'request_store'
+
+require 'sass-rails'
+require 'selectize-rails'
+require 'bootstrap-sass'
+require 'compass-rails'
+require 'font-awesome-rails'
+
+require 'rails/routing_mapper'
+require 'rails/relation_length_validator'
+
+require 'para/ext'
+require 'para/errors'
+require 'para/config'
+require 'para/model_field_parsers'
+require 'para/attribute_field_mappings'
+require 'para/inputs'
+require 'para/cloneable'
+require 'para/orderable'
+require 'para/form_builder'
+require 'para/markup'
+require 'para/engine'
+require 'para/components_configuration'
+require 'para/exporter'
+
+module Para
+  extend ActiveSupport::Autoload
+
+  eager_autoload do
+    autoload :Config
+    autoload :Component
+    autoload :Generators
+    autoload :Routes
+  end
+
+  def self.config(&block)
+    if block
+      block.call(Para::Config)
+    else
+      Para::Config
+    end
+  end
+
+  def self.components
+    Para::Component.config
+  end
+
+  def self.store
+    RequestStore.store
+  end
+
+  def self.table_name_prefix
+    'para_'
+  end
+end

data/lib/rails/relation_length_validator.rb

@@ -0,0 +1,45 @@
+class RelationLengthValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    if smaller?(value)
+      record.errors.add(attribute, smaller_error_message, options)
+    elsif greater?(value)
+      record.errors.add(attribute, greater_error_message, options)
+    end
+  end
+
+  private
+
+  def minimum
+    options[:minimum] || 0
+  end
+
+  def maximum
+    options[:maximum] || Float::INFINITY
+  end
+
+  def smaller?(value)
+    value.length < minimum
+  end
+
+  def greater?(value)
+    value.length > minimum
+  end
+
+  def smaller_error_message
+    message = options[:message] && options[:message][:minimum]
+    message || I18n.t(
+      "activerecord.errors.relation_length_is_smaller",
+      minimum: minimum,
+      default: "must have at least #{ minimum } elements"
+    )
+  end
+
+  def greater_error_message
+    message = options[:message] && options[:message][:maximum]
+    message || I18n.t(
+      "activerecord.errors.relation_length_is_greater",
+      maximum: maximum,
+      default: "must have at most #{ maximum } elements"
+    )
+  end
+end

data/lib/rails/routing_mapper.rb

@@ -0,0 +1,27 @@
+module ActionDispatch
+  module Routing
+    class Mapper
+      def para_at(mount_location, &block)
+        Para::Routes.new(self).draw(mount_location, &block)
+      end
+
+      def para_plugin(plugin_name)
+        routes = ['', plugin_name.to_s.camelize, 'Routes'].join('::').constantize
+        routes.new(self).draw
+      end
+
+      def component(component_name, options = {}, &block)
+        path = options.fetch(:path, component_name.to_s)
+        as = options.fetch(:as, component_name)
+        controller = options.fetch(:controller, "#{ component_name }_component")
+
+        endpoint = "#{ path }/:component_id"
+
+        get endpoint => "#{ controller }#show", as: as
+        delete endpoint => "#{ controller }#destroy", as: "destroy_#{as}"
+
+        scope(endpoint, as: component_name, &block) if block
+      end
+    end
+  end
+end

data/lib/tasks/para_tasks.rake

@@ -0,0 +1,22 @@
+namespace :para do
+  namespace :components do
+    desc <<-DESC
+      Remove all components that are no longer referenced in the components.rb
+      configuration file
+    DESC
+
+    task clean: :environment do
+      Para::Component::Base.find_each do |component|
+        unless Para.components.component_for(component.identifier)
+          component.destroy
+        end
+      end
+
+      Para::ComponentSection.find_each do |section|
+        unless Para.components.section_for(section.identifier)
+          section.destroy
+        end
+      end
+    end
+  end
+end