para 0.4.0

data/lib/para/form_builder/settings.rb

@@ -0,0 +1,24 @@
+module Para
+  module FormBuilder
+    module Settings
+      def settings_input(name, options = {}, &block)
+        options.reverse_merge!(as: :setting)
+
+        setting = ::Settings.get(name, options[:type])
+
+        input(name, options) do
+          fields_for(:settings, setting) do |fields|
+            fields.hidden_field(:key) +
+            fields.hidden_field(:_type) +
+
+            if block
+              block.call(fields)
+            else
+              fields.text_field(:value, class: 'form-control')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/para/form_builder.rb

@@ -0,0 +1,22 @@
+require 'simple_form/form_builder'
+
+require 'para/form_builder/containers'
+require 'para/form_builder/field_mappings'
+require 'para/form_builder/nested_form'
+require 'para/form_builder/ordering'
+require 'para/form_builder/settings'
+
+# We'll implement our own form builder later, but for now it would need to
+# patch or override Cocoon to allow creating nested fields with our custom
+# form builder instead of `simple_fields_for` which uses SimpleForm::FormBuilder
+# explicitly
+#
+SimpleForm::FormBuilder.class_eval do
+  include Para::FormBuilder::Containers
+  include Para::FormBuilder::FieldMappings
+  include Para::FormBuilder::NestedForm
+  include Para::FormBuilder::Ordering
+  include Para::FormBuilder::Settings
+end
+
+SimpleForm::FormBuilder.map_type(:inet, to: SimpleForm::Inputs::StringInput)

data/lib/para/generators/field_helpers.rb

@@ -0,0 +1,32 @@
+module Para
+  module Generators
+    module FieldHelpers
+      private
+
+      def attributes
+        @attributes ||= begin
+          model = Para.const_get(class_name)
+          AttributeFieldMappings.new(model).fields
+        end
+      end
+
+      def field_options_for(field)
+        field_options = field.field_options
+
+        options = field_options.each_with_object([]) do |(key, value), ary|
+          if writable_value?(value)
+            ary << "#{ key.inspect } => #{ value.inspect }"
+          end
+        end
+
+        ", #{ options.join(', ') }" if options.any?
+      end
+
+      def writable_value?(value)
+        [String, Symbol].any? do |type|
+          value.kind_of?(type)
+        end
+      end
+    end
+  end
+end

data/lib/para/generators/name_helpers.rb

@@ -0,0 +1,9 @@
+module Para
+  module Generators
+    module NameHelpers
+      def plural_namespaced_path
+        @plural_namespaced_path ||= File.join(*class_path, plural_name)
+      end
+    end
+  end
+end

data/lib/para/generators/named_base.rb

@@ -0,0 +1,7 @@
+module Para
+  module Generators
+    class NamedBase < Rails::Generators::NamedBase
+      include Para::Generators::NameHelpers
+    end
+  end
+end

data/lib/para/generators.rb

@@ -0,0 +1,11 @@
+require 'para/generators/name_helpers'
+
+module Para
+  module Generators
+    extend ActiveSupport::Autoload
+
+    autoload :FieldHelpers
+    autoload :NamedBase
+    autoload :NameHelpers
+  end
+end

data/lib/para/inputs/nested_many_input.rb

@@ -0,0 +1,40 @@
+module Para
+  module Inputs
+    class NestedManyInput < SimpleForm::Inputs::Base
+      def input(wrapper_options = nil)
+        input_html_options[:class] << "nested-many"
+
+        parent_model = @builder.object.class
+        model = parent_model.reflect_on_association(attribute_name).klass
+        orderable = options.fetch(:orderable, model.orderable?)
+        add_button = options.fetch(:add_button, true)
+        # Load existing resources
+        resources = object.send(attribute_name)
+        # Order them if the list should be orderable
+        resources = resources.order(:position) if orderable
+
+        template.render(
+          partial: 'para/inputs/nested_many',
+          locals: {
+            form: @builder,
+            model: model,
+            attribute_name: attribute_name,
+            orderable: orderable,
+            add_button: add_button,
+            dom_identifier: dom_identifier,
+            resources: resources
+          }
+        )
+      end
+
+      def dom_identifier
+        @dom_identifier ||= begin
+          name = attribute_name
+          time = (Time.now.to_f * 1000).to_i
+          random = (rand * 1000).to_i
+          [name, time, random].join('-')
+        end
+      end
+    end
+  end
+end

data/lib/para/inputs/nested_one_input.rb

@@ -0,0 +1,24 @@
+module Para
+  module Inputs
+    class NestedOneInput < SimpleForm::Inputs::Base
+      def input(wrapper_options = nil)
+        input_html_options[:class] << "nested-one"
+
+        parent_model = object.class
+        model = parent_model.reflect_on_association(attribute_name).klass
+        resource = object.send(:"#{ attribute_name }") ||
+                    object.send(:"#{ attribute_name }=", model.new)
+
+        template.render(
+          partial: 'para/inputs/nested_one',
+          locals: {
+            form: @builder,
+            model: model,
+            resource: resource,
+            attribute_name: attribute_name
+          }
+        )
+      end
+    end
+  end
+end

data/lib/para/inputs.rb

@@ -0,0 +1,11 @@
+module Para
+  module Inputs
+    extend ActiveSupport::Autoload
+
+    autoload :NestedOneInput
+    autoload :NestedManyInput
+    autoload :HasOneInput
+  end
+end
+
+SimpleForm.custom_inputs_namespaces << 'Para::Inputs'

data/lib/para/markup/alert.rb

@@ -0,0 +1,37 @@
+module Para
+  module Markup
+    class Alert < Para::Markup::Component
+      def container(message, options = {}, &block)
+        if block
+          options = message
+          message = capture { block.call }
+        end
+
+        type = options.delete(:type) || 'info'
+
+        merge_class!(options, "alert")
+        merge_class!(options, "alert-#{ type }")
+
+        dismissable = !options.key?(:dismissable) || options.delete(:dismissable)
+
+        merge_class!(options, "alert-dismissable") if dismissable
+
+        content_tag :div, options do
+          if dismissable
+            close_button + message
+          else
+            message
+          end
+        end
+      end
+
+      private
+
+      def close_button
+        content_tag(:button, type: "button", class: "close", "data-dismiss" => "alert") do
+          content_tag(:span, '&times;'.html_safe)
+        end
+      end
+    end
+  end
+end

data/lib/para/markup/component.rb

@@ -0,0 +1,20 @@
+module Para
+  module Markup
+    class Component
+      attr_reader :view
+
+      delegate :content_tag, :capture, to: :view
+
+      def initialize view
+        @view = view
+      end
+
+      protected
+
+      def merge_class!(options, klass)
+        options[:class] ||= ""
+        options[:class] += " #{ klass }"
+      end
+    end
+  end
+end

data/lib/para/markup/modal.rb

@@ -0,0 +1,52 @@
+module Para
+  module Markup
+    class Modal < Para::Markup::Component
+      def container(options = {}, &block)
+        merge_class!(options, "modal")
+        merge_class!(options, "fade") unless options.delete(:fade) == false
+        merge_class!(options, "in") if options.delete(:displayed)
+
+        options.reverse_merge!(
+          tabindex: "-1", role: "dialog", "aria-hidden" => "true", "aria-labelledby" => (options[:id] || "modal")
+        )
+
+        content_tag(:div, options) do
+          content_tag(:div, class: "modal-dialog") do
+            content_tag(:div, class: "modal-content") do
+              capture { block.call(self) }
+            end
+          end
+        end
+      end
+
+      def header(options = {}, &block)
+        merge_class!(options, "modal-header")
+
+        content_tag(:div, options) do
+          content_tag(:button, "&times;".html_safe, class: "close", type: "button",
+            "data-dismiss" => "modal", "aria-hidden" => "true"
+          ) +
+          content_tag(:h4, class: "modal-title") do
+            capture { block.call }
+          end
+        end
+      end
+
+      def body(options = {}, &block)
+        merge_class!(options, "modal-body")
+
+        content_tag(:div, options) do
+          capture { block.call }
+        end
+      end
+
+      def footer(options = {}, &block)
+        merge_class!(options, "modal-footer")
+
+        content_tag(:div, options) do
+          capture { block.call }
+        end
+      end
+    end
+  end
+end

data/lib/para/markup/panel.rb

@@ -0,0 +1,41 @@
+module Para
+  module Markup
+    class Panel < Para::Markup::Component
+      def container(options = {}, &block)
+        merge_class!(options, "panel")
+
+        if (type = options.fetch(:type, 'default'))
+          merge_class!(options, "panel-#{ type }")
+        end
+
+        content_tag(:div, options) do
+          capture { block.call(self) }
+        end
+      end
+
+      def header(options = {}, &block)
+        merge_class!(options, "panel-heading")
+
+        content_tag(:div, options) do
+          capture { block.call }
+        end
+      end
+
+      def body(options = {}, &block)
+        merge_class!(options, "panel-body")
+
+        content_tag(:div, options) do
+          capture { block.call }
+        end
+      end
+
+      def footer(options = {}, &block)
+        merge_class!(options, "panel-footer")
+
+        content_tag(:div, options) do
+          capture { block.call }
+        end
+      end
+    end
+  end
+end

data/lib/para/markup/resources_table.rb

@@ -0,0 +1,178 @@
+module Para
+  module Markup
+    class ResourcesTable < Para::Markup::Component
+      attr_reader :model, :component, :orderable, :actions
+
+      def container(options = {}, &block)
+        @model = options.delete(:model)
+        @component = options.delete(:component)
+
+        if !options.key?(:orderable) || options.delete(:orderable)
+          @orderable = model.orderable?
+        end
+
+        if !options.key?(:actions) || options.delete(:actions)
+          @actions = true
+        end
+
+        merge_class!(options, 'table')
+        merge_class!(options, 'para-component-relation-table')
+        merge_class!(options, 'table-hover') if options.fetch(:hover, true)
+
+        if orderable
+          merge_class!(options, 'orderable')
+          options[:data] ||= {}
+          options[:data][:'order-url'] = component.relation_path(model.model_name.route_key, action: :order)
+        end
+
+        table = content_tag(:table, options) do
+          capture { block.call(self) }
+        end
+
+        if options.fetch(:responsive, true)
+          content_tag(:div, table, class: 'table-responsive')
+        else
+          table
+        end
+      end
+
+      def header(&block)
+        cells = []
+        # Add orderable empty header
+        cells << content_tag(:th, '') if orderable
+        # Append cells
+        cells << capture { block.call }
+        # Append actions empty cell
+        cells << content_tag(:th, '', class: 'actions') if actions
+
+        # Output full header
+        content_tag(:thead) do
+          content_tag(:tr, cells.join("\n").html_safe)
+        end
+      end
+
+      def rows(resources, &block)
+        rows = resources.each_with_object(ActiveSupport::SafeBuffer.new('')) do |resource, buffer|
+          buffer << content_tag(:tr, row(resource, &block))
+        end
+
+        # Output full header
+        content_tag(:tbody, rows)
+      end
+
+      def row(resource, &block)
+        cells = []
+        # Add orderable cell with "move" thumb
+        cells << order_cell(resource) if orderable
+        # Add data cells
+        cells << capture { block.call(resource) }
+        # Add actions links to the last cell
+        cells << actions_cell(resource) if actions
+
+        cells.join("\n").html_safe
+      end
+
+      def header_for(field_name, sort: field_name)
+        label = model.human_attribute_name(field_name)
+
+        content_tag(:th) do
+          if sort != field_name
+              view.sort_link(search, *sort, label, hide_indicator: true)
+          elsif searchable?(field_name)
+            view.sort_link(search, field_name, label, hide_indicator: true)
+          else
+            label
+          end
+        end
+      end
+
+      # Data for can accept 2 versions of arguments :
+      #
+      #   - resource, field_name, type : cell value will be retrieved from
+      #       the field_value_for helper
+      #
+      #   - a single value : The value to display in the cell directly
+      #       which will be processed to be shorter than 100 chars
+      #
+      def data_for(*args)
+        value = if args.length >= 2
+          resource, field_name, type = args
+          view.field_value_for(resource, field_name, type).to_s
+        else
+          view.excerpt_value_for(args.first)
+        end
+
+        content_tag(:td) do
+          value
+        end
+      end
+
+      def order_cell(resource)
+        order_cell = content_tag(:td) do
+          view.reorder_anchor(
+            value: resource.position,
+            data: { id: resource.id }
+          )
+        end
+      end
+
+      def actions_cell(resource)
+        content_tag(:td) do
+          content_tag(:div, class: 'pull-right btn-group') do
+            edit_button(resource) +
+            clone_button(resource) +
+            delete_button(resource)
+          end
+        end
+      end
+
+      def clone_button(resource)
+        return unless resource.class.cloneable?
+
+        view.link_to(
+          component.relation_path(
+            resource, action: :clone, return_to: view.request.fullpath
+          ),
+          method: :post,
+          class: 'btn btn-info'
+        ) do
+          content_tag(:i, '', class: 'fa fa-refresh')
+        end
+      end
+
+      def edit_button(resource)
+        view.link_to(
+          component.relation_path(
+            resource, action: :edit, return_to: view.request.fullpath
+          ),
+          class: 'btn btn-primary'
+        ) do
+          content_tag(:i, '', class: 'fa fa-pencil')
+        end
+      end
+
+      def delete_button(resource)
+        view.link_to(
+          component.relation_path(resource),
+          method: :delete,
+          data: {
+            confirm: I18n.t('para.list.delete_confirmation')
+          },
+          class: 'btn btn-danger'
+        ) do
+          content_tag(:i, '', class: 'fa fa-trash')
+        end
+      end
+
+      private
+
+      def search
+        @search ||= view.instance_variable_get(:@q)
+      end
+
+      def searchable?(field_name)
+        model.columns_hash.keys.include?(field_name.to_s)
+      end
+    end
+  end
+end

data/lib/para/markup.rb

@@ -0,0 +1,10 @@
+require 'para/markup/component'
+require 'para/markup/resources_table'
+require 'para/markup/modal'
+require 'para/markup/panel'
+require 'para/markup/alert'
+
+module Para
+  module Markup
+  end
+end

data/lib/para/model_field_parsers/base.rb

@@ -0,0 +1,20 @@
+module Para
+  module ModelFieldParsers
+    class Base
+      def self.register(key, parser)
+        ModelFieldParsers.registered_parsers[key] = parser
+      end
+
+      attr_reader :model, :fields_hash
+
+      def initialize(model, fields_hash)
+        @model = model
+        @fields_hash = fields_hash
+      end
+
+      def applicable?
+        true
+      end
+    end
+  end
+end

data/lib/para/model_field_parsers/devise.rb

@@ -0,0 +1,37 @@
+module Para
+  module ModelFieldParsers
+    class Devise < Para::ModelFieldParsers::Base
+      register :devise, self
+
+      def parse!
+        hidden_fields.each(&fields_hash.method(:delete))
+
+        added_fields.each do |key|
+          fields_hash[key] = AttributeField::PasswordField.new(model, name: key)
+        end
+      end
+
+      def applicable?
+        fields_hash.key?(:encrypted_password)
+      end
+
+      private
+
+      def hidden_fields
+        [
+          :encrypted_password,
+          :password_salt,
+          :reset_password_token,
+          :remember_token
+        ]
+      end
+
+      def added_fields
+        [
+          :password,
+          :password_confirmation
+        ]
+      end
+    end
+  end
+end

data/lib/para/model_field_parsers/globalize.rb

@@ -0,0 +1,23 @@
+module Para
+  module ModelFieldParsers
+    class Globalize < Para::ModelFieldParsers::Base
+      register :globalize, self
+
+      def parse!
+        fields_hash.delete(:translations)
+
+        model.translated_attribute_names.each do |attribute_name|
+          column = model.translation_class.columns_hash[attribute_name.to_s]
+
+          fields_hash[column.name] = AttributeField::Translation.new(
+            model, name: column.name, type: column.type
+          )
+        end
+      end
+
+      def applicable?
+        defined?(::Globalize) && model.translates?
+      end
+    end
+  end
+end

data/lib/para/model_field_parsers/orderable.rb

@@ -0,0 +1,15 @@
+module Para
+  module ModelFieldParsers
+    class Orderable < Para::ModelFieldParsers::Base
+      register :orderable, self
+
+      def parse!
+        fields_hash.delete(:position)
+      end
+
+      def applicable?
+        model.orderable?
+      end
+    end
+  end
+end

data/lib/para/model_field_parsers/paperclip.rb

@@ -0,0 +1,51 @@
+module Para
+  module ModelFieldParsers
+    class Paperclip < Para::ModelFieldParsers::Base
+      register :paperclip, self
+
+      def parse!
+        model.attachment_definitions.each do |key, options|
+          paperclip_suffixes.each do |suffix|
+            field_name = [key, suffix].join('_').to_sym
+            @fields_hash.delete(field_name)
+          end
+
+          @fields_hash[key] = if image?(options)
+            AttributeField::ImageField.new(
+              model, name: key, type: 'image', field_type: 'image'
+            )
+          else
+            AttributeField::FileField.new(
+              model, name: key, type: 'file', field_type: 'file'
+            )
+          end
+        end
+      end
+
+      def applicable?
+        model.respond_to?(:attachment_definitions)
+      end
+
+      private
+
+      def paperclip_suffixes
+        [
+          :file_name,
+          :content_type,
+          :file_size,
+          :updated_at
+        ]
+      end
+
+      # For our default, we tell that an attachment is an image if it
+      # has at least one style and that this style starts with a digit or the
+      # "x" letter, which is used for styles like "x200" to only force height
+      #
+      def image?(options)
+        if (styles = options[:styles]) && !styles.empty?
+          styles.values.first.match(/^(\d|x)/i)
+        end
+      end
+    end
+  end
+end