para 0.4.0

data/lib/generators/para/orderable/orderable_generator.rb

@@ -0,0 +1,53 @@
+module Para
+  class OrderableGenerator < Rails::Generators::NamedBase
+    include Rails::Generators::Migration
+
+    source_root File.expand_path('../templates', __FILE__)
+
+    class_option :migrate, type: :boolean, default: false, :aliases => "-m"
+
+    desc 'Para orderable model updater'
+
+    def welcome
+      say "Making #{ class_name } model orderable ..."
+    end
+
+    def add_field_to_model
+      migration_template(
+        'orderable_migration.rb',
+        "db/migrate/add_orderable_position_to_#{ plural_file_name }.rb"
+      )
+    end
+
+    def add_orderable_to_model
+      class_definition = "class #{ class_name } < ActiveRecord::Base\n"
+
+      inject_into_file "app/models/#{ file_name }.rb", after: class_definition do
+        "  acts_as_orderable\n"
+      end
+    end
+
+    def migrate
+      rake 'db:migrate' if options[:migrate]
+    end
+
+    def fianl_message
+      message = "The #{ class_name } model is now orderable.\n"
+      message << "* Please migrate to update your model's table\n" unless options[:migrate]
+      message << <<-MESSAGE
+* Please add to your model resource's routes the ordering path.
+  e.g.: resources :#{ plural_file_name } do
+          collection do
+            patch 'order'
+          end
+        end
+      MESSAGE
+
+      say(message)
+    end
+
+    def self.next_migration_number(dir)
+      Time.now.utc.strftime("%Y%m%d%H%M%S")
+    end
+  end
+end

data/lib/generators/para/orderable/templates/orderable_migration.rb

@@ -0,0 +1,6 @@
+class AddOrderablePositionTo<%= class_name.pluralize %> < ActiveRecord::Migration
+  def change
+    add_column :<%= table_name %>, :position, :integer, default: 0
+    add_index :<%= table_name %>, :position
+  end
+end

data/lib/generators/para/resource/resource_generator.rb

@@ -0,0 +1,71 @@
+module Para
+  class ResourceGenerator < Rails::Generators::NamedBase
+    source_root File.expand_path('../templates', __FILE__)
+
+    argument :component_name, type: :string
+    argument :attributes, type: :array
+
+    class_option :migrate, type: :boolean, default: false, :aliases => "-m"
+    class_option :orderable, type: :boolean, default: false, :aliases => "-o"
+
+    desc 'Para resource generator'
+
+    def welcome
+      say 'Creating resource...'
+    end
+
+    def copy_resource_controller
+      template 'resource_controller.rb', "app/controllers/admin/#{ plural_file_name }_controller.rb"
+    end
+
+    def add_resource_to_component_controller
+      gsub_file "app/controllers/admin/#{ component_name.singularize }_component_controller.rb", /# You can access @component here/ do
+        <<-RUBY
+          @q = @component.#{ plural_file_name }.search(params[:q])
+          @resources = @q.result.page(params[:page])
+        RUBY
+      end
+    end
+
+    def insert_route
+      inject_into_file 'config/routes.rb', after: "component :#{ component_name.underscore } do" do
+        "\n      resources :#{ plural_file_name }"
+      end
+    end
+
+    def insert_relation_to_show
+      append_to_file "app/views/admin/#{ component_name.underscore }_component/show.html.haml" do
+        "\n\n= listing_for(@resources)"
+      end
+    end
+
+    def generate_model
+      generate 'model',
+        file_name,
+        attributes.map { |attr|
+          "#{ attr.name }:#{ attr.type }"
+        }.insert(-1, 'component:references').join(' ')
+    end
+
+    def orderable
+      generate 'para:orderable', file_name if options[:orderable]
+    end
+
+    def migrate
+      rake 'db:migrate' if options[:migrate]
+    end
+
+    def insert_belongs_to_to_resource
+      inject_into_file "app/models/#{ file_name }.rb", after: "belongs_to :component" do
+        ", class_name: 'Para::Component::Base'"
+      end
+    end
+
+    def insert_has_many_to_component
+      inject_into_file "app/components/#{ component_name.underscore }_component.rb", after: "register :#{ component_name.underscore }, self" do
+        "\n\n      has_many :#{ plural_file_name }, class_name: '::#{ class_name }', inverse_of: :component,
+          foreign_key: :component_id, dependent: :destroy"
+      end
+    end
+  end
+end

data/lib/generators/para/resource/templates/resource_controller.rb

@@ -0,0 +1,5 @@
+module Admin
+  class <%= plural_file_name.camelize %>Controller < Para::Admin::ResourcesController
+    resource :<%= file_name %>
+  end
+end

data/lib/generators/para/table/table_generator.rb

@@ -0,0 +1,34 @@
+module Para
+  class TableGenerator < Para::Generators::NamedBase
+    source_root File.expand_path('../templates', __FILE__)
+
+    desc 'Para resources table generator'
+
+    def generate_table
+      template(
+        "_table.html.haml",
+        "app/views/admin/#{ plural_namespaced_path }/_table.haml"
+      )
+    end
+
+    private
+
+    def attributes
+      @attributes ||= begin
+        model =
+          begin
+            Para.const_get(class_name)
+          rescue
+            class_name.classify.constantize
+          end
+        AttributeFieldMappings.new(model).fields
+      end
+    end
+
+    def attributes_list
+      @attributes_list ||= attributes.map do |field|
+        field.name.to_sym.inspect
+      end.join(', ')
+    end
+  end
+end

data/lib/generators/para/table/templates/_table.html.haml

@@ -0,0 +1,10 @@
+= resources_table(model: model, component: component) do |table|
+  = table.header do
+    <%- attributes.each do |field| -%>
+    = table.header_for(:<%= field.name %>)
+    <%- end -%>
+
+  = table.rows(resources) do |resource|
+    <%- attributes.each do |field| -%>
+    = table.data_for(resource, :<%= field.name %>)
+    <%- end -%>

data/lib/para/attribute_field/base.rb

@@ -0,0 +1,77 @@
+module Para
+  module AttributeField
+    class Base
+      class_attribute :_field_options
+
+      attr_reader :model, :name, :type, :field_type, :field_method
+
+      def self.field_option(key, method_name, options = {})
+        self._field_options ||= []
+
+        self._field_options += [{
+          key: key,
+          method_name: method_name,
+          options: options
+        }]
+      end
+
+      field_option :as, :field_type_name
+
+      def initialize(model, options = {})
+        @model = model
+        @name = options[:name]
+        @type = options[:type]
+        @field_type = options[:field_type]
+
+        determine_name_and_field_method!
+      end
+
+      def determine_name_and_field_method!
+        name = @name
+
+        reference = model.reflect_on_all_associations.find do |association|
+          association.foreign_key == name
+        end
+
+        if reference
+          @name = reference.name
+          @field_method = :association
+        else
+          @name = name
+          @field_method = :input
+        end
+      end
+
+      def value_for(instance)
+        instance.send(name)
+      end
+
+      # Allows parsing input params before they're passed to the model, so
+      # it can be easy to edit them according to some field type specific
+      # behavior
+      #
+      def parse_input(params); end
+
+      def field_options
+        self.class._field_options.each_with_object({}) do |params, hash|
+          value = send(params[:method_name])
+          hash[params[:key]] = value if value != nil || params[:options][:allow_nil]
+        end
+      end
+
+      def field_name
+        name
+      end
+
+      def attribute_column_path
+        [name]
+      end
+
+      private
+
+      def field_type_name
+        field_type.presence && field_type.to_sym
+      end
+    end
+  end
+end

data/lib/para/attribute_field/belongs_to.rb

@@ -0,0 +1,29 @@
+module Para
+  module AttributeField
+    class BelongsToField < RelationField
+      field_option :collection, :relation_options
+
+      def field_name
+        reflection.name
+      end
+
+      def value_for(instance)
+        if (resource = instance.send(name))
+          resource_name(resource)
+        end
+      end
+
+      def relation_options
+        reflection.klass.all
+      end
+
+      def parse_input(params)
+        if (id = params[reflection.foreign_key].presence) && !reflection.klass.exists?(id: id)
+          on_the_fly_creation(id) do |resource|
+            params[reflection.foreign_key] = resource.id
+          end
+        end
+      end
+    end
+  end
+end

data/lib/para/attribute_field/boolean.rb

@@ -0,0 +1,15 @@
+module Para
+  module AttributeField
+    class BooleanField < AttributeField::Base
+      field_option :wrapper, :wrapper_name
+
+      def value_for(instance)
+        I18n.t("para.types.boolean.#{ (!!instance.send(name)).to_s }")
+      end
+
+      def wrapper_name
+        :horizontal_radio_and_checkboxes
+      end
+    end
+  end
+end

data/lib/para/attribute_field/datetime.rb

@@ -0,0 +1,9 @@
+module Para
+  module AttributeField
+    class DatetimeField < AttributeField::Base
+      def value_for(instance)
+        (value = instance.send(name)) && I18n.l(value)
+      end
+    end
+  end
+end

data/lib/para/attribute_field/file.rb

@@ -0,0 +1,20 @@
+module Para
+  module AttributeField
+    class FileField < AttributeField::Base
+      include ActionView::Helpers::UrlHelper
+
+      field_option :wrapper, :wrapper_name
+
+      def value_for(instance)
+        if instance.send(:"#{ name }?")
+          url = instance.send(name).url
+          link_to(url, url)
+        end
+      end
+
+      def wrapper_name
+        :horizontal_file_input
+      end
+    end
+  end
+end

data/lib/para/attribute_field/has_many.rb

@@ -0,0 +1,31 @@
+module Para
+  module AttributeField
+    class HasManyField < RelationField
+      def field_name
+        reflection.name
+      end
+
+      def value_for(instance)
+        instance.send(name).map do |resource|
+          resource_name(resource)
+        end.join(', ')
+      end
+
+      def parse_input(params)
+        if (ids = params[plural_foreign_key].presence) && String === ids
+          # Format selectize value for Rails
+          ids = params[plural_foreign_key] = ids.split(',')
+
+          on_the_fly_creation(ids) do |resource, value|
+            params[plural_foreign_key].delete(value)
+            params[plural_foreign_key] << resource.id
+          end
+        end
+      end
+
+      def plural_foreign_key
+        foreign_key.to_s.pluralize
+      end
+    end
+  end
+end

data/lib/para/attribute_field/image.rb

@@ -0,0 +1,25 @@
+module Para
+  module AttributeField
+    class ImageField < AttributeField::Base
+      include ActionView::Helpers::AssetTagHelper
+
+      def value_for(instance)
+        style = attachment_thumb_style_for(instance)
+
+        if instance.send(:"#{ name }?")
+          image_tag(instance.send(name).url(style))
+        end
+      end
+
+      private
+
+      def attachment_thumb_style_for(instance)
+        styles = instance.send(name).styles.map(&:first)
+        # Check if there's a :thumb or :thumbnail style in attachment definition
+        thumb = styles.find { |s| %w(thumb thumbnail).include?(s.to_s) }
+        # Return the potentially smallest size !
+        thumb || styles.first || :original
+      end
+    end
+  end
+end

data/lib/para/attribute_field/nested_many.rb

@@ -0,0 +1,26 @@
+module Para
+  module AttributeField
+    class NestedManyField < AttributeField::HasManyField
+      def parse_input(params)
+        if (nested_attributes = params[nested_attributes_key])
+          nested_attributes.each do |index, attributes|
+            nested_model_mappings.fields.each do |field|
+              field.parse_input(attributes)
+            end
+            params[nested_attributes_key][index] = attributes
+          end
+        else
+          super(params)
+        end
+      end
+
+      def nested_model_mappings
+        @nested_model_mappings ||= AttributeFieldMappings.new(reflection.klass)
+      end
+
+      def nested_attributes_key
+        @nested_attributes_key ||= :"#{ name }_attributes"
+      end
+    end
+  end
+end

data/lib/para/attribute_field/nested_one.rb

@@ -0,0 +1,27 @@
+module Para
+  module AttributeField
+    class NestedOneField < AttributeField::BelongsToField
+      def parse_input(params)
+        if (nested_attributes = params[nested_attributes_key])
+          nested_attributes.each do |index, attributes|
+            nested_model_mappings.fields.each do |field|
+              field.parse_input(attributes)
+            end
+
+            params[nested_attributes_key][index] = attributes
+          end
+        else
+          super(params)
+        end
+      end
+
+      def nested_model_mappings
+        @nested_model_mappings ||= AttributeFieldMappings.new(reflection.klass)
+      end
+
+      def nested_attributes_key
+        @nested_attributes_key ||= :"#{ name }_attributes"
+      end
+    end
+  end
+end

data/lib/para/attribute_field/password.rb

@@ -0,0 +1,18 @@
+module Para
+  module AttributeField
+    class PasswordField < AttributeField::Base
+      def initialize(model, options = {})
+        options.reverse_merge!(type: 'password', field_type: 'password')
+        super(model, options)
+      end
+
+      def value_for(instance)
+        nil
+      end
+
+      def parse_input(params)
+        params[name] = params[name].presence
+      end
+    end
+  end
+end

data/lib/para/attribute_field/redactor.rb

@@ -0,0 +1,20 @@
+module Para
+  module AttributeField
+    class Redactor < AttributeField::Base
+      include ActionView::Helpers::SanitizeHelper
+      include ActionView::Helpers::TextHelper
+
+      def initialize(model, options = {})
+        options.reverse_merge!(type: 'text', field_type: 'redactor')
+        super(model, options)
+      end
+
+      def value_for(instance)
+        (value = instance.send(name)) && truncate(
+          sanitize(value, tags: []),
+          length: 50
+        )
+      end
+    end
+  end
+end

data/lib/para/attribute_field/relation.rb

@@ -0,0 +1,52 @@
+module Para
+  module AttributeField
+    class RelationField < AttributeField::Base
+      private
+
+      def reflection
+        @reflection ||= model.reflect_on_association(name)
+      end
+
+      def foreign_key
+        @foreign_key ||= reflection && case reflection.macro
+        when :belongs_to then reflection.foreign_key
+        when :has_one then :"#{ reflection.name }_id"
+        when :has_many then :"#{ reflection.name.to_s.singularize }_ids"
+        end
+      end
+
+      def resource_name(resource)
+        Para.config.resource_name_methods.each do |method|
+          return resource.send(method) if resource.respond_to?(method)
+        end
+
+        model_name = resource.class.model_name.human
+        "#{ model_name } - #{ resource.id }"
+      end
+
+      # Takes an array of ids and a block. Check for each id if model exists
+      # and create one if not. E.g: [12, "foo"] will try to create a model with
+      # 'foo'
+      def on_the_fly_creation ids, &block
+        Array.wrap(ids).each do |id|
+          if !reflection.klass.exists?(id: id)
+            resource = reflection.klass.new
+
+            Para.config.resource_name_methods.each do |method_name|
+              setter_name = :"#{ method_name }="
+
+              if resource.respond_to?(setter_name)
+                resource.send(setter_name, id)
+
+                if resource.save
+                  block.call(resource, id)
+                  break
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/para/attribute_field/translation.rb

@@ -0,0 +1,9 @@
+module Para
+  module AttributeField
+    class Translation < AttributeField::Base
+      def attribute_column_path
+        [:translations, name]
+      end
+    end
+  end
+end

data/lib/para/attribute_field_mappings.rb

@@ -0,0 +1,82 @@
+require 'para/attribute_field/base'
+require 'para/attribute_field/boolean'
+require 'para/attribute_field/datetime'
+require 'para/attribute_field/password'
+require 'para/attribute_field/file'
+require 'para/attribute_field/image'
+require 'para/attribute_field/relation'
+require 'para/attribute_field/belongs_to'
+require 'para/attribute_field/has_many'
+require 'para/attribute_field/nested_one'
+require 'para/attribute_field/nested_many'
+require 'para/attribute_field/redactor'
+require 'para/attribute_field/translation'
+
+module Para
+  class AttributeFieldMappings
+    UNEDITABLE_ATTRIBUTES = %w(id component_id created_at updated_at type)
+
+    attr_reader :model, :fields_hash, :whitelist_attributes
+
+    def initialize(model, whitelist_attributes: nil)
+      @model = model
+      @whitelist_attributes = whitelist_attributes
+
+      process_fields!
+    end
+
+    def fields
+      fields_hash.values
+    end
+
+    def field_for(field_name, type = nil)
+      fields_hash[field_name] ||= if model.new.respond_to?(field_name)
+        build_field_for(field_name, type)
+      else
+        raise NoMethodError.new(
+          "No attribute or method correspond to ##{ field_name } " +
+          "in the model #{ model.name }. No field could be created."
+        )
+      end
+    end
+
+    private
+
+    def whitelisted?(attribute_name)
+      !whitelist_attributes || whitelist_attributes.include?(attribute_name)
+    end
+
+    def process_fields!
+      @fields_hash = model.columns.each_with_object({}) do |column, fields|
+        next unless whitelisted?(column.name)
+
+        # Reject uneditable attributes
+        unless UNEDITABLE_ATTRIBUTES.include?(column.name)
+          field_class = field_class_for(column.type)
+
+          fields[column.name] = field_class.new(
+            model, name: column.name, type: column.type
+          )
+        end
+      end.with_indifferent_access
+
+      Para::ModelFieldParsers.parse!(model, fields_hash)
+    end
+
+    def build_field_for(attribute_name, type)
+      field_class = field_class_for(type)
+
+      field_class.new(
+        model, name: attribute_name, type: type
+      )
+    end
+
+    def field_class_for(type)
+      case type
+      when :boolean then AttributeField::BooleanField
+      when :date, :datetime then AttributeField::DatetimeField
+      else AttributeField::Base
+      end
+    end
+  end
+end

data/lib/para/cloneable.rb

@@ -0,0 +1,20 @@
+module Para
+  module Cloneable
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :cloneable_associations
+    end
+
+    module ClassMethods
+      def acts_as_cloneable(*args)
+        @cloneable = true
+        self.cloneable_associations = args
+      end
+
+      def cloneable?
+        @cloneable ||= false
+      end
+    end
+  end
+end

data/lib/para/component/exportable.rb

@@ -0,0 +1,25 @@
+module Para
+  module Component
+    module Exportable
+      extend ActiveSupport::Concern
+
+      included do
+        configurable_on :export
+      end
+
+      def exportable?
+        @exportable ||= exports.length > 0
+      end
+
+      # TODO : Move :configuration column store to JSON instead of HStore
+      # which handles more data types and will help us avoid eval here
+      def exports
+        @exports ||= if export.present?
+          eval(export).map(&:with_indifferent_access)
+        else
+          []
+        end
+      end
+    end
+  end
+end