para 0.6.9 → 0.7.0

data/lib/para/attribute_field/belongs_to.rb

@@ -19,7 +19,7 @@ module Para
         reflection.klass.all
       end
 
-      def parse_input(params)
+      def parse_input(params, resource)
         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

data/lib/para/attribute_field/boolean.rb

@@ -10,7 +10,7 @@ module Para
       end
 
       def wrapper_name
-        :horizontal_radio_and_checkboxes
+        :vertical_radio_and_checkboxes
       end
     end
   end

data/lib/para/attribute_field/friendly_id.rb

@@ -0,0 +1,19 @@
+module Para
+  module AttributeField
+    class FriendlyId < Base
+      register :friendly_id, self
+
+      # Set empty string as nil to allow default friendly id methods to
+      # generate the slug when the field is empty
+      def parse_input(params, resource)
+        params[slug_column] = nil if slug_column && params[slug_column] == ''
+      end
+
+      private
+
+      def slug_column
+        model.try(:friendly_id_config).try(:slug_column)
+      end
+    end
+  end
+end

data/lib/para/attribute_field/has_many.rb

@@ -13,21 +13,60 @@ module Para
         end.join(', ')
       end
 
-      def parse_input(params)
+      def parse_input(params, resource)
         if (ids = params[plural_foreign_key].presence) && String === ids
           # Format selectize value for Rails
-          ids = params[plural_foreign_key] = ids.split(',')
+          ids = params[plural_foreign_key] = ids.split(',').map(&:to_i)
 
-          on_the_fly_creation(ids) do |resource, value|
+          on_the_fly_creation(ids) do |res, value|
             params[plural_foreign_key].delete(value)
-            params[plural_foreign_key] << resource.id
+            params[plural_foreign_key] << res.id
           end
         end
+
+        assign_ids(params, resource)
       end
 
       def plural_foreign_key
         foreign_key.to_s.pluralize
       end
+
+      def assign_ids(params, resource)
+        return unless Array === params[plural_foreign_key]
+
+        ids = params.delete(plural_foreign_key)
+
+        if through_reflection && through_reflection.klass.orderable?
+          assign_ordered_through_reflection_ids(through_reflection, resource, ids)
+        else
+          resource.assign_attributes(plural_foreign_key => ids)
+        end
+      end
+
+      def assign_ordered_through_reflection_ids(through_reflection, resource, ids)
+        association = resource.association(through_reflection.name)
+        join_resources = association.load_target
+
+        return association.replace([]) if ids.empty?
+
+        new_resources = ids.each_with_index.map do |id, position|
+          join_resource = join_resources.find do |res|
+            res.send(through_relation_source_foreign_key) == id &&
+              (!polymorphic_through_reflection? || res.send(reflection.foreign_type) == reflection.klass.name)
+          end
+
+          unless join_resource
+            attributes = { through_relation_source_foreign_key => id }
+            attributes[reflection.foreign_type] = reflection.klass.name if polymorphic_through_reflection?
+            join_resource = association.build(attributes)
+          end
+
+          join_resource.position = position
+          join_resource
+        end
+
+        association.replace(new_resources)
+      end
     end
   end
 end

data/lib/para/attribute_field/nested_field.rb

@@ -0,0 +1,46 @@
+module Para
+  module AttributeField
+    module NestedField
+      def nested_model_mappings(nested_attributes)
+        model = if (type = nested_attributes[:type]).present?
+          nested_attributes[:type].try(:constantize)
+        else
+          reflection.klass
+        end
+
+        mappings = attributes_mappings_for(nested_attributes)
+
+        AttributeFieldMappings.new(model, mappings: mappings)
+      end
+
+      def nested_attributes_key
+        @nested_attributes_key ||= :"#{ name }_attributes"
+      end
+
+      # This method extends the current resource so its #id method returns a
+      # fake id based on the given attributes, but immediately returns to its
+      # standard behavior of returning nil as soon as the `#assign_attributes`
+      # method is called.
+      #
+      # During nested attributes assignation, the id of the resource is used
+      # to assign it its nested params. When it is nil, a new resource is
+      # created, but since we already need our resource to be created at the
+      # time we parse the input params, we fake the presence of an id while the
+      # nested attributes assignation is running, and remove that behavior as
+      # soon as we don't need it anymore.
+      #
+      def temporarily_extend_new_resource(resource, attributes)
+        resource.instance_variable_set(:@_waiting_for_attributes_assignation, true)
+
+        resource.define_singleton_method(:assign_attributes) do |*args|
+          @_waiting_for_attributes_assignation = false
+          super(*args)
+        end
+
+        resource.define_singleton_method(:id) do
+          @_waiting_for_attributes_assignation ? attributes['id'] : read_attribute(:id)
+        end
+      end
+    end
+  end
+end

data/lib/para/attribute_field/nested_many.rb

@@ -1,28 +1,49 @@
 module Para
   module AttributeField
     class NestedManyField < AttributeField::HasManyField
+      include Para::Helpers::AttributesMappings
+      include Para::AttributeField::NestedField
+
       register :nested_many, self
 
-      def parse_input(params)
+      def parse_input(params, resource)
         if (nested_attributes = params[nested_attributes_key])
           nested_attributes.each do |index, attributes|
-            nested_model_mappings.fields.each do |field|
-              field.parse_input(attributes)
+            mappings = nested_model_mappings(attributes)
+            nested_resource = fetch_or_build_nested_resource_for(resource, index, attributes)
+
+            mappings.fields.each do |field|
+              field.parse_input(attributes, nested_resource)
             end
 
             params[nested_attributes_key][index] = attributes
           end
         else
-          super(params)
+          super
         end
       end
 
-      def nested_model_mappings
-        @nested_model_mappings ||= AttributeFieldMappings.new(reflection.klass)
-      end
+      private
+
+      # Force loading association and look for a resource matching the provided
+      # attributes. If no resource is found, one is created and a fake `id` is
+      # assigned to it to hack Rails' nested resources lookup from new
+      # attributes params.
+      #
+      # This is necessary to be able to provide a resource to the #parse_input
+      # method when called on the nested resources hash
+      #
+      def fetch_or_build_nested_resource_for(parent, index, attributes)
+        nested_resources = parent.association(name).load_target
 
-      def nested_attributes_key
-        @nested_attributes_key ||= :"#{ name }_attributes"
+        if (id = attributes['id'].presence)
+          nested_resources.find { |res| res.id == id.to_i }
+        else
+          parent.association(name).build(attributes.slice('type')).tap do |resource|
+            attributes['id'] = "__#{ index }"
+            temporarily_extend_new_resource(resource, attributes)
+          end
+        end
       end
     end
   end

data/lib/para/attribute_field/nested_one.rb

@@ -1,26 +1,45 @@
 module Para
   module AttributeField
     class NestedOneField < AttributeField::BelongsToField
+      include Para::Helpers::AttributesMappings
+      include Para::AttributeField::NestedField
+
       register :nested_one, self
 
-      def parse_input(params)
+      def parse_input(params, resource)
         if (nested_attributes = params[nested_attributes_key])
-          nested_model_mappings.fields.each do |field|
-            field.parse_input(nested_attributes)
+          mappings = nested_model_mappings(nested_attributes)
+          nested_resource = fetch_or_build_nested_resource_for(resource, nested_attributes)
+
+          mappings.fields.each do |field|
+            field.parse_input(nested_attributes, nested_resource)
           end
 
           params[nested_attributes_key] = nested_attributes
         else
-          super(params)
+          super
         end
       end
 
-      def nested_model_mappings
-        @nested_model_mappings ||= AttributeFieldMappings.new(reflection.klass)
-      end
+      private
 
-      def nested_attributes_key
-        @nested_attributes_key ||= :"#{ name }_attributes"
+      # Force loading association and look for a resource matching the provided
+      # attributes. If no resource is found, one is created and a fake `id` is
+      # assigned to it to hack Rails' nested resources lookup from new
+      # attributes params.
+      #
+      # This is necessary to be able to provide a resource to the #parse_input
+      # method when called on the nested resources hash
+      #
+      def fetch_or_build_nested_resource_for(parent, attributes)
+        if (nested_resource = parent.association(name).load_target)
+          return nested_resource
+        end
+
+        parent.association(name).build(attributes.slice('type')).tap do |resource|
+          attributes['id'] = "__#{ object_id }"
+          temporarily_extend_new_resource(resource, attributes)
+        end
       end
     end
   end

data/lib/para/attribute_field/password.rb

@@ -12,7 +12,7 @@ module Para
         nil
       end
 
-      def parse_input(params)
+      def parse_input(params, resource)
         params[name] = params[name].presence
       end
     end

data/lib/para/attribute_field/relation.rb

@@ -1,7 +1,7 @@
 module Para
   module AttributeField
     class RelationField < AttributeField::Base
-      private
+      include Para::Helpers::ResourceName
 
       def reflection
         @reflection ||= model.reflect_on_association(name)
@@ -15,6 +15,24 @@ module Para
         end
       end
 
+      def through_relation
+        @through_relation ||= reflection.options[:through]
+      end
+
+      def through_reflection
+        @through_reflection ||= through_relation && model.reflect_on_association(through_relation)
+      end
+
+      def through_relation_source_foreign_key
+        @through_relation_source_foreign_key ||= reflection.source_reflection.foreign_key
+      end
+
+      def polymorphic_through_reflection?
+        !!(through_relation && reflection.source_reflection.options[:polymorphic])
+      end
+
+      private
+
       def resource_name(resource)
         Para.config.resource_name_methods.each do |method|
           return resource.send(method) if resource.respond_to?(method)

data/lib/para/attribute_field_mappings.rb

@@ -2,11 +2,17 @@ module Para
   class AttributeFieldMappings
     UNEDITABLE_ATTRIBUTES = %w(id component_id created_at updated_at type)
 
-    attr_reader :model, :fields_hash, :whitelist_attributes
+    attr_reader :model, :fields_hash, :whitelist_attributes, :mappings
 
-    def initialize(model, whitelist_attributes: nil)
+    # The mappings hash is a form provided hash of attributes and input types
+    # mapping that are automatically generated in the form builder and that
+    # allows our model field parsers to spot unregistered fields and process
+    # them when needed.
+    #
+    def initialize(model, whitelist_attributes: nil, mappings: nil)
       @model = model
       @whitelist_attributes = whitelist_attributes
+      @mappings = mappings || {}
 
       process_fields!
     end
@@ -52,7 +58,7 @@ module Para
         end
       end.with_indifferent_access
 
-      Para::ModelFieldParsers.parse!(model, fields_hash)
+      Para::ModelFieldParsers.parse!(model, fields_hash, mappings)
     end
 
     def build_field_for(attribute_name, type)

data/lib/para/breadcrumbs/breadcrumb.rb

@@ -1,42 +1,89 @@
 module Para
   module Breadcrumbs
     class Breadcrumb
-      attr_reader :identifier, :_path, :options
+      include ActionDispatch::Routing::PolymorphicRoutes
+      include Para::Helpers::ResourceName
 
-      def initialize(identifier, path, *options)
-        @identifier = identifier
+      attr_reader :resource_or_identifier, :_path, :controller, :options
+
+      def initialize(resource_or_identifier, path, controller, *options)
+        @resource_or_identifier = resource_or_identifier
         @_path = path
+        @controller = controller
         @options = options
       end
 
       def title
-        @title ||= if Symbol === identifier
-          ::I18n.t("admin.breadcrumbs.#{ identifier }")
+        @title ||= if resource_or_identifier.is_a?(Symbol)
+          translate(resource_or_identifier)
+        elsif resource_or_identifier.is_a?(ActiveRecord::Base)
+          resource_name(resource_or_identifier)
         else
-          identifier
+          resource_or_identifier
         end
       end
 
       # Allow lazy evaluation of routes to define breadcrumbs before being
       # able to access request or routes
+      #
       def path
-        @path ||= if Symbol === _path
+        @path ||= if _path.is_a?(Symbol)
           find_route_for(_path, *options)
         elsif _path
           _path
         else
-          '#'
+          begin
+            polymorphic_path(resource_or_identifier)
+          rescue
+            '#'
+          end
         end
       end
 
       def active?(request)
-        path == request.path || !_path
+        path == request.path || path == '#'
       end
 
       private
 
+      def translate(key)
+        if controller.admin?
+          ::I18n.t("admin.breadcrumbs.#{ resource_or_identifier }")
+        else
+          # Check if a specific translation has been defined
+          if (translation = ::I18n.t("breadcrumbs.#{ resource_or_identifier }", default: '')).present?
+            translation
+          else
+            # If no translation is defined, we check if there's a plural model
+            # translation associated to the given key
+            begin
+              klass = key.to_s.singularize.camelize.constantize
+              klass.try(:model_name).try(:human, count: 2) || key
+            rescue NameError
+              key
+            end
+          end
+        end
+      end
+
       def find_route_for(path, *options)
-        Rails.application.routes.url_helpers.send(:"#{ path }_path", *options)
+        path = path_method?(path) ? path.to_sym : :"#{ path }_path"
+        Rails.application.routes.url_helpers.send(path, *options)
+      end
+
+      # Allow #polymorphic_path to work by delegating missing methods ending
+      # with _path or _url to be tried on url_helpers
+      #
+      def method_missing(method_name, *args, &block)
+        if path_method?(method_name)
+          Rails.application.routes.url_helpers.try(method_name, *args) || super
+        else
+          super
+        end
+      end
+
+      def path_method?(path)
+        path.to_s.match(/_(path|url)\z/)
       end
     end
   end

data/lib/para/breadcrumbs/controller.rb

@@ -6,6 +6,8 @@ module Para
       included do
         class_attribute :_class_level_breadcrumbs
 
+        before_action :build_breadcrumbs_manager
+
         helper_method :add_breadcrumb, :breadcrumbs
         helper ViewHelper
       end
@@ -15,11 +17,18 @@ module Para
       end
 
       def breadcrumbs
-        Para.store[:breadcrumbs] ||= begin
-          manager = Breadcrumbs::Manager.new
-          _class_level_breadcrumbs.each { |args| manager.add(*args) }
-          manager
-        end
+        build_breadcrumbs_manager
+      end
+
+      private
+
+      def build_breadcrumbs_manager
+        Para.store['para.breadcrumbs'] ||=
+          Breadcrumbs::Manager.new(self).tap do |manager|
+            if _class_level_breadcrumbs
+              _class_level_breadcrumbs.each { |args| manager.add(*args) }
+            end
+          end
       end
 
       module ClassMethods
@@ -30,8 +39,12 @@ module Para
       end
 
       module ViewHelper
+        # Render the breadcrumbs view depending wether it is in the admin or
+        # in front, allowing the front view to be overriden in app
+        #
         def render_breadcrumbs
-          render partial: 'para/admin/shared/breadcrumbs'
+          prefix = controller.admin? ? 'para/admin/' : ''
+          render partial: "#{ prefix }shared/breadcrumbs"
         end
       end
     end