- delete unused _default_algo

- actually use aliases as aliases
- support postformat_replace

Author: Ed Freyfogle

lib/Geo/Address/Formatter.pm

@@ -84,6 +84,8 @@ sub _read_configuration {
         File::Find::Rule->file()->name( '*.yaml' )->in($path.'/countries');
 
     $self->{templates} = {};
+    $self->{component_aliases} = {};
+
     foreach my $filename ( sort @a_filenames ){
         try {
             my $rh_templates = LoadFile($filename);
@@ -102,16 +104,23 @@ sub _read_configuration {
 
     try {
         my @c = LoadFile($path . '/components.yaml');
-        # warn Dumper \@c;
+
+        foreach my $rh_c (@c){
+            if (defined($rh_c->{aliases})){
+                foreach my $alias (@{$rh_c->{aliases}}){
+                    $self->{component_aliases}{$alias} = $rh_c->{name};
+                }
+            }
+        }
+        #warn Dumper $self->{component_aliases};
+        #warn Dumper \@c;
         $self->{ordered_components} = 
             [ map { $_->{name} => ($_->{aliases} ? @{$_->{aliases}} : ()) } @c];
     }
     catch {
         warn "error parsing component configuration: $_";
     };
 
-    #print STDERR Dumper $self->{ordered_components};
-
     $self->{state_codes} = {};
     if ( -e $path . '/state_codes.yaml'){
         try {
@@ -148,31 +157,61 @@ sub format_address {
             || $self->_determine_country_code($rh_components) 
             || '';
 
+    # set the aliases
+    foreach my $alias (keys %{$self->{component_aliases}}){
+        if (defined($rh_components->{$alias})){     
+            $rh_components->{$self->{component_aliases}->{$alias}} = 
+                $rh_components->{$alias};
+        }
+    }
+
+    # determine the template
     my $rh_config = $self->{templates}{uc($cc)} || $self->{templates}{default};
     my $template_text = $rh_config->{address_template};
 
     #print STDERR "t text " . Dumper $template_text;
     #print STDERR "comp " . Dumper $rh_components;
 
     # do we have the minimal components for an address?
-    # or should we instead fall back?
-    $self->_apply_replacements($rh_components, $rh_config->{replace});
-    $self->_add_state_code($rh_components);
-
+    # or should we instead use the fallback template?
     if (!$self->_minimal_components($rh_components)){
         $template_text = 
             $rh_config->{fallback_template}
             || $self->{templates}{default}{fallback_template}
             || $rh_config->{address_template};  # if there is no fallback
     }
 
-    $rh_components->{attention} = join(', ', map { $rh_components->{$_} } @{ $self->_find_unknown_components($rh_components)} );
+    # clean up the components
+    $self->_apply_replacements($rh_components, $rh_config->{replace});
+    $self->_add_state_code($rh_components);
 
+    # add the attention
+    $rh_components->{attention} = join(', ', map { $rh_components->{$_} } @{ $self->_find_unknown_components($rh_components)} );
+    #warn Dumper $rh_components;
+    # render it
     my $text = $self->_render_template($template_text, $rh_components);
+    $text = $self->_postformat($text,$rh_config->{postformat_replace});
     $text = $self->_clean($text);
     return $text;
 }
 
+sub _postformat {
+    my $self        = shift;
+    my $text  = shift;
+    my $raa_rules   = shift;
+
+    foreach my $ra_fromto ( @$raa_rules ){
+        try {
+            my $regexp = qr/$ra_fromto->[0]/;
+            $text =~ s/$regexp/$ra_fromto->[1]/;
+        }
+        catch {
+            warn "invalid replacement: " . join(', ', @$ra_fromto)
+        };
+    }
+    return $text;
+}
+
 sub _minimal_components {
     my $self = shift;
     my $rh_components = shift || return;
@@ -273,7 +312,6 @@ sub _render_template {
         my $selected = first { length($_) } split(/\s*\|\|\s*/, $text);
         return $selected;
     };
-
     $template_content =~ s/\n/, /sg;
     my $output = $tache->render($template_content, $context);
 
@@ -290,35 +328,8 @@ sub _find_unknown_components {
     my %h_known = map { $_ => 1 } @{ $self->{ordered_components} };
     my @a_unknown = grep { !exists($h_known{$_}) } keys %$components;
 
+    #warn Dumper \@a_unknown;
     return \@a_unknown;
 }
 
-sub _default_algo { # the ultimate fallback
-    my $self = shift;
-    my $cs = shift || return;
-
-    my @values = ();
-
-    # upper case country code
-    if ( my $ccode = $cs->{country_code} ){
-        $cs->{country_code} = uc($ccode);
-    }
-
-    # now do the location pieces
-    foreach my $k (@{ $self->{ordered_components} }){
-        next unless ( exists($cs->{$k}) );
-        next if ( $k eq 'country_code' && $cs->{'country'} );
-        push(@values, $cs->{$k});
-    }
-
-    # get the ones we missed previously
-    # FIXME - this is bad, we're just shoving stuff to the start
-    foreach my $k ( @{ $self->_find_unknown_components($cs) } ) {
-        warn "not sure where to put this: $k";
-        ## add to the front
-        unshift(@values, $cs->{$k});
-    }
-    return join(', ', @values);
-}
-
 1;