view release on metacpan or  search on metacpan

lib/Data/MuForm.pm  view on Meta::CPAN

has 'field_prefix' => ( is => 'rw' );

has 'form_meta_fields' => ( is => 'rw', isa => ArrayRef, default => sub {[]} );
has 'index' => ( is => 'rw', isa => HashRef, default => sub {{}} );
sub add_to_index { my ( $self, $field_name, $field ) = @_; $self->{index}->{$field_name} = $field; }
sub form { shift }
sub is_form {1}
sub parent { }
has 'ctx' => ( is => 'rw', weak_ref => 1 );
# init_values can be a blessed object or a hashref
has 'init_values' => ( is => 'rw', alias => 'init_object' );
sub clear_init_values { $_[0]->{init_values} = undef }
sub has_init_values {
    my $self = shift;
    my $init_obj = $self->init_values;
    return 0 unless defined $init_obj;
    return 0 if ref $init_obj eq 'HASH' and ! scalar keys %$init_obj;
    return 1;
}
has 'fill_from_object_source' => ( is => 'rw', );
has 'active' => ( is => 'rw', clearer => 'clear_active', predicate => 'has_active' );
has 'inactive' => ( is => 'rw', clearer => 'clear_inactive', predicate => 'has_inactive' );
sub full_name { '' }
sub full_accessor { '' }
sub fif { shift->fields_fif(@_) }

has '_repeatable_fields' => (
    is => 'rw',
    default => sub {[]},
);
sub add_repeatable_field {
  my ( $self, $field ) = @_;
  push @{$self->_repeatable_fields}, $field;
}
sub has_repeatable_fields {
  my ( $self, $field ) = @_;
  return scalar @{$self->_repeatable_fields};
}
sub all_repeatable_fields {
  my $self = shift;
  return @{$self->_repeatable_fields};
}

#========= Rendering ==========
has 'http_method'   => ( is  => 'ro', default => 'post' );
has 'action' => ( is => 'rw' );
has 'enctype' => ( is => 'rw' );
has 'renderer_class' => ( is => 'ro', builder => 'build_renderer_class' );
sub build_renderer_class { 'Data::MuForm::Renderer::Base' }
has 'renderer' => ( is => 'rw', lazy => 1, builder => 'build_renderer' );
sub build_renderer {
    my $self = shift;
    my $renderer_class = load_optional_class($self->renderer_class) ? $self->renderer_class : 'Data::MuForm::Renderer::Base';
    my $renderer = $renderer_class->new(
        localizer => $self->localizer,
        form => $self->form,
        %{$self->renderer_args},
    );
    return $renderer;
}
has 'renderer_args' => ( is => 'ro', isa => HashRef, builder => 'build_renderer_args' );
sub build_renderer_args {{}}
has 'render_args' => ( is => 'rw', lazy => 1, isa => HashRef, builder => 'build_render_args' );
sub build_render_args {{}}
sub base_render_args {
  my $self = shift;
  my $args = {
    name => $self->name,
    id => $self->name,
    form_errors => $self->form_errors || [],
    form_attr => {
      method => $self->http_method,
    }
  };
  $args->{form_attr}->{action} = $self->action if $self->action;
  $args->{form_attr}->{enctype} = $self->enctype if $self->enctype;
  return $args;
}


#========= Errors ==========
has 'form_errors' => ( is => 'rw', isa => ArrayRef, default => sub {[]} );
sub clear_form_errors { $_[0]->{form_errors} = []; }
sub all_form_errors { return @{$_[0]->form_errors}; }
sub has_form_errors { scalar @{$_[0]->form_errors} }
sub num_form_errors { scalar @{$_[0]->form_errors} }
sub push_form_error { push @{$_[0]->form_errors}, $_[1] }
sub add_form_error {
    my ( $self, @message ) = @_;
    my $out;
    if ( $message[0] !~ /{/ ) {
        $out = $self->localizer->loc_($message[0]);
    }
    else {
        $out = $self->localizer->loc_x(@message);
    }
    return $self->push_form_error($out);
}

sub has_errors {
    my $self = shift;
    return $self->has_error_fields || $self->has_form_errors;
}
sub num_errors {
    my $self = shift;
    return $self->num_error_fields + $self->num_form_errors;
}
sub get_errors { shift->errors }

sub all_errors {
    my $self         = shift;
    my @errors = $self->all_form_errors;
    push @errors,  map { $_->all_errors } $self->all_error_fields;
    return @errors;
}
sub errors { [$_[0]->all_errors] }

sub errors_by_id {
    my $self = shift;
    my %errors;
    $errors{$_->id} = [$_->all_errors] for $self->all_error_fields;