Improved the way of building names for repeatable elements.

For repeatable elements that don't have a nested_name attribute we still use the old behaviour. The repeatable counter is added to the field names (e. g. 'field_1_1' for two nested repeatable elements without nested_name attributes).
If a nested_name attribute is given, we now add the counter to the repeatable name part to ease the automatic generation of fields with client side technologies like javascript. So now we get 'outer_1.inner_1.field' for two nested repeatable elements with the nested_name attributes 'outer' and 'inner'.

Author: mariominati

lib/HTML/FormFu/Element/Block.pm

@@ -10,7 +10,10 @@ use List::MoreUtils qw( uniq );
 use Storable qw( dclone );
 use Carp qw( croak );
 
-__PACKAGE__->mk_item_accessors(qw( tag _elements nested_name ));
+__PACKAGE__->mk_item_accessors( qw(
+        tag                         _elements
+        nested_name                 original_nested_name
+) );
 
 __PACKAGE__->mk_output_accessors(qw( content ));
 

lib/HTML/FormFu/Element/Repeatable.pm

@@ -12,6 +12,7 @@ __PACKAGE__->mk_item_accessors( qw(
         _original_elements
         increment_field_names
         counter_name
+        repeatable_delimiter
 ) );
 
 sub new {
@@ -20,6 +21,10 @@ sub new {
     $self->filename('repeatable');
     $self->is_repeatable(1);
     $self->increment_field_names(1);
+# TODO
+    # This setter is currently not documentes as FF::Model::HashRef
+    # only supports '_'
+    $self->repeatable_delimiter('_');
 
     return $self;
 }
@@ -49,7 +54,152 @@ sub repeat {
     $self->_elements( [] );
 
     return [] if !$count;
-    
+
+    # switch behaviour
+    # If nested_name is set, we add the repeatable counter to the name
+    # of the containing block (this repeatable block).
+    #     This behaviour eases the creation of client side javascript code
+    #     to add and remove repeatable elements client side.
+    # If nested_name is *not* set, we add the repeatable counter to the names
+    # of the child elements (leaves of the element tree).
+    my $nested_name = $self->nested_name;
+    if (defined $nested_name && length $nested_name) {
+        return $self->_repeat_containing_block( $count );
+    }
+    else {
+        return $self->_repeat_child_elements( $count );
+    }
+}
+
+sub _repeat_containing_block {
+    my ( $self, $count ) = @_;
+
+    my $children = $self->_original_elements;
+
+    # We must not get 'nested.nested_1' instead of 'nested_1' through the
+    # nested_name attribute of the Repeatable element, thus we extended
+    # FF::Elements::_Field nested_names method to ignore Repeatable elements.
+    my $nested_name = $self->nested_name;
+    $self->original_nested_name( $nested_name );
+
+    # delimiter between nested_name and the incremented counter
+    my $delimiter = $self->repeatable_delimiter;
+
+    my @return;
+
+    for my $rep ( 1 .. $count ) {
+        # create clones of elements and put them in a new block
+        my @clones = map { $_->clone } @$children;
+        my $block = $self->element('Block');
+
+        # initiate new block with properties of this repeatable
+        $block->_elements( \@clones );
+        $block->attributes( $self->attributes );
+        $block->tag( $self->tag );
+
+        $block->repeatable_count($rep);
+
+        if ( $self->increment_field_names ) {
+            # store the original nested_name attribute for later usage when
+            # building the original nested name
+            $block->original_nested_name( $block->nested_name )
+                if !defined $block->original_nested_name;
+
+            # create new nested name with repeat counter
+            $block->nested_name( $nested_name . $delimiter . $rep );
+
+            for my $field ( @{ $block->get_fields } ) {
+
+                if ( defined( my $name = $field->name ) ) {
+                    # store original name for later usage when
+                    # replacing the field names in constraints
+                    $field->original_name($name)
+                        if !defined $field->original_name;
+
+                    # store original nested name for later usage when 
+                    # replacing the field names in constraints
+                    $field->original_nested_name( $field->build_original_nested_name )
+                        if !defined $field->original_nested_name;
+                }
+            }
+        }
+
+        _reparent_children($block);
+
+        for my $field ( @{ $block->get_fields } ) {
+            map { $_->parent($field) }
+                @{ $field->_deflators },
+                @{ $field->_filters },
+                @{ $field->_constraints },
+                @{ $field->_inflators },
+                @{ $field->_validators },
+                @{ $field->_transformers },
+                @{ $field->_plugins },
+                ;
+        }
+
+        my $block_fields = $block->get_fields;
+
+        my @block_constraints = map { @{ $_->get_constraints } } @$block_fields;
+
+        # rename any 'others' fields
+        my @others_constraints = grep { defined $_->others }
+            grep { $_->can('others') } @block_constraints;
+
+        for my $constraint (@others_constraints) {
+            my $others = $constraint->others;
+            if ( !ref $others ) {
+                $others = [$others];
+            }
+            my @new_others;
+
+            for my $name (@$others) {
+                my $field
+                    = ( first { $_->original_nested_name eq $name }
+                    @$block_fields )
+                    || first { $_->original_name eq $name } @$block_fields;
+
+                if ( defined $field ) {
+                    push @new_others, $field->nested_name;
+                }
+                else {
+                    push @new_others, $name;
+                }
+            }
+
+            $constraint->others( \@new_others );
+        }
+
+        # rename any 'when' fields
+        my @when_constraints = grep { defined $_->when } @block_constraints;
+
+        for my $constraint (@when_constraints) {
+            my $when = $constraint->when;
+            my $name = $when->{field};
+
+            my $field
+                = first { $_->original_nested_name eq $name } @$block_fields;
+
+            if ( defined $field ) {
+                $when->{field} = $field->nested_name;
+            }
+        }
+
+        push @return, $block;
+
+    }
+
+    return \@return;
+}
+
+sub _repeat_child_elements {
+    my ( $self, $count ) = @_;
+
+    my $children = $self->_original_elements;
+
+    # delimiter between nested_name and the incremented counter
+    my $delimiter = $self->repeatable_delimiter;
+
     my @return;
 
     for my $rep ( 1 .. $count ) {
@@ -72,7 +222,7 @@ sub repeat {
                     $field->original_nested_name( $field->nested_name )
                         if !defined $field->original_nested_name;
 
-                    $field->name("${name}_$rep");
+                    $field->name(${name} . $delimiter . $rep);
                 }
             }
         }
@@ -333,6 +483,35 @@ C<n> is the L</repeatable_count> value.
 This is set on each new L<Block|HTML::FormFu::Element::Block> element 
 returned by L</repeat>, starting at number C<1>.
 
+Because this is an 'inherited accessor' available on all elements, it can be
+used to determine whether any element is a child of a Repeatable element.
+
+=head2 nested_name
+
+If the L</nested_name> attribute is set the naming scheme of the Repeatable
+elements children is switched to add the counter to the repeatable blocks
+themself.
+
+    ---
+    elements:
+      - type: Repeatable
+        nested_name: my_rep
+        elements:
+          - name: foo
+          - name: bar
+
+Calling C<< $element->repeat(2) >> would result in the following markup:
+
+    <div>
+        <input name="my_rep_1.foo" type="text" />
+        <input name="my_rep_1.bar" type="text" />
+    </div>
+    <div>
+        <input name="myrep_2.foo" type="text" />
+        <input name="myrep_2.bar" type="text" />
+    </div>
+
+
 Because this is an 'inherited accessor' available on all elements, it can be
 used to determine whether any element is a child of a Repeatable element.
 

lib/HTML/FormFu/Element/_Field.pm

@@ -132,6 +132,9 @@ sub nested_name {
     if ( $self->form->nested_subscript ) {
         my $name = shift @names;
         map { $name .= "[$_]" } @names;
+# TODO - Mario Minati 19.05.2009
+# Does this (name formatted as '[name]') collide with FF::Model::HashRef as
+# it uses /_\d/ to parse repeatable names?
         return $name;
     }
     else {
@@ -153,10 +156,17 @@ sub nested_names {
         while ( defined( $parent = $parent->{parent} ) ) {
 
             if ( $parent->can('is_field') && $parent->is_field ) {
+                # handling Field
                 push @names, $parent->name
                     if defined $parent->name;
             }
+            elsif ( $parent->can('is_repeatable') && $parent->is_repeatable ) {
+                # handling Repeatable
+                # ignore Repeatables nested_name attribute as it is provided
+                # by the childrens Block elements
+            }
             else {
+                # handling 'not Field' and 'not Repeatable'
                 push @names, $parent->nested_name
                     if defined $parent->nested_name;
             }
@@ -170,6 +180,84 @@ sub nested_names {
     return ( $self->name );
 }
 
+sub build_original_nested_name {
+    my ($self) = @_;
+
+    croak 'cannot set build_original_nested_name' if @_ > 1;
+
+    return if !defined $self->name;
+
+    my @names = $self->build_original_nested_names;
+
+    if ( $self->form->nested_subscript ) {
+        my $name = shift @names;
+        map { $name .= "[$_]" } @names;
+# TODO - Mario Minati 19.05.2009
+# Does this (name formatted as '[name]') collide with FF::Model::HashRef as
+# it uses /_\d/ to parse repeatable names?
+        return $name;
+    }
+    else {
+        return join ".", @names;
+    }
+}
+
+sub build_original_nested_names {
+    my ($self) = @_;
+
+    croak 'cannot set build_original_nested_names' if @_ > 1;
+
+# TODO - Mario Minati 19.05.2009
+# Maybe we have to use original_name instead of name.
+# Yet there is no testcase, which is currently failing. 
+
+    if ( defined( my $name = $self->name ) ) {
+        my @names;
+        my $parent = $self;
+
+        # micro optimization! this method's called a lot, so access
+        # parent hashkey directly, instead of calling parent()
+        while ( defined( $parent = $parent->{parent} ) ) {
+
+            if ( $parent->can('is_field') && $parent->is_field ) {
+                # handling Field
+                if (defined $parent->original_name) {
+                    push @names, $parent->original_name;
+                }
+                elsif (defined $parent->name) {
+                    push @names, $parent->name;
+                }
+            }
+            elsif ( $parent->can('is_repeatable') && $parent->is_repeatable ) {
+                # handling Repeatable
+# TODO - Mario Minati 19.05.2009
+# Do we have to take care of chains of Repeatable elements, if the Block
+# elements have already been created for the outer Repeatable elements to
+# avoid 'outer.outer_1.inner'
+# Yet there is no failing testcase. All testcases in FF and FF::Model::DBIC
+# which have nested repeatable elements are passing currently.
+                push @names, $parent->original_nested_name
+                    if defined $parent->original_nested_name;
+            }
+            else {
+                # handling 'not Field' and 'not Repeatable'
+                if ($parent->can('original_nested_name') && defined $parent->original_nested_name) {
+                    push @names, $parent->original_nested_name;
+                }
+                elsif (defined $parent->nested_name) {
+                    push @names, $parent->nested_name
+                }
+            }
+        }
+
+        if (@names) {
+            return reverse $name, @names;
+        }
+    }
+
+    return ( $self->name );
+}
+
 sub nested_base {
     my ($self) = @_;
 

lib/HTML/FormFu/Element/_MultiElement.pm

@@ -17,10 +17,17 @@ sub nested_names {
         while ( defined( $parent = $parent->parent ) ) {
 
             if ( $parent->can('is_field') && $parent->is_field ) {
+                # handling Field
                 push @names, $parent->name
                     if defined $parent->name;
             }
+            elsif ( $parent->can('is_repeatable') && $parent->is_repeatable ) {
+                # handling Repeatable
+                # ignore Repeatables nested_name attribute as it is provided
+                # by the childrens Block elements
+            }
             else {
+                # handling 'not Field' and 'not Repeatable'
                 push @names, $parent->nested_name
                     if defined $parent->nested_name;
             }