#!/usr/bin/perl -w

use strict;

my %fieldDescs=(
    'ManagedSystem.Product',  'Product Code',
    'ManagedSystem.Status',   'Status',
    # and many more, in actuality loaded from your database
);

my %keywords=(
    EQ      => 'is equal to',
    OFFLINE => "'OFFLINE'",
    IF      => 'if',
    VALUE   => 'the value of',
    # And your other keywords
);

my $text="*IF *VALUE ManagedSystem.Product *EQ NT *AND *VALUE ManagedS
+ystem.Status *EQ '*OFFLINE'";

# Substitute *FOO for the equivalent from %keywords, if it exists
$text=~s/\*(\w+)\b/(exists $keywords{$1})?$keywords{$1}:$1/eg;

# Substitute any word for its description from fieldDescs, if the word
+s exists there
$text=~s/\b([A-Za-z_\.0-9]+)\b/(exists $fieldDescs{$1})?$fieldDescs{$1
+}:$1/eg;

print "New text is\n\t$text\n";
[download]

A recursive-descent parser might be overkill here, but don't discount it completely yet. A naive left-to-right token match and replacement may actually work here, though. The language used is pretty simple.

The left-to-right replacements would be simple with a hash. You could use a different top-level hash for each attribute group or you could use a hash of hashes. Two thousand entries is not that large. You could use YAML or XML for the specification if you didn't want to make constant hashes on disk. Just grab a token, see if it exists as a hash key, and replace it with its value. The code for this is simple and often seen (more often than it should be, as many times as the wheel has bene reinvented actually). The below is a simplified place to start, but you probably want to populate the full data structure in some other way for clarity.

use strict;
use warnings;

my $string = q(*IF *VALUE ManagedSystem.Product *EQ NT *AND *VALUE Man
+agedSystem.Status *EQ '*OFFLINE');

my %dict = (
  'ManagedSystem' => {
    'Product' => 'Product Code',
    'Status'  => 'Status',
  },
  '*IF'         => 'If',
  '*VALUE'      => 'the value of',
  '*EQ'         => 'is equal to',
  '*AND'        => 'and',
  q('*OFFLINE') => q('OFFLINE'),
);

my @parts = split /\s+/, $string;
foreach my $p ( @parts ) {

  if ( $p =~ m/\./ ) {
    my ( $attr_grp, $attr ) = split /\./, $p;
    $p = $dict{ $attr_grp }{ $attr } if exists $dict{ $attr_grp }{ $at
+tr };
  } else  {
    $p = $dict{ $p } if exists $dict{ $p };
  }

  print $p . ' ';
}
print "\n";
[download]

If using a database, just make a table in the DB for each attribute group. Then make a char column for the attribute and make an index on it. Make another column for the replacement text. Then something simple like "select replacement from ManagedSystem where attribute = 'Product';" will get you the right replacement text. DBI, Rose::DBI, Class:DBI, or DBIx::Class would each be able to help you with that in its own way.

Wow, October. I started this process way back in October and am just now getting a chance to try and tackle this problem. Just goes to show how low a priority documentation is.

Thank you guys for your responses. I like the idea of a hash, I just couldn't visualize how to do it. These examples help.

Mr Mischief, these are ITM Situations. We just want to generate documentation we can post to a wiki so users can quickly figure out what the cryptic page means. I have no problem walking the XML and generating the rest of the document. The problem was just how to make this single line easier to read.

If your AttributeGroup.Attribute mapping is getting out of hand, you could use DBM::Deep instead of a straight hash. If you're committed to a database, you could still tie a hash to an object that will query the database as appropriate. Then those replacements as easy as

s/((?:[A-Z][a-z]*)+\.(?:[A-Z][a-z]*)+)/$name_of{$1}/g;
[download]

A hash will allow you to map one string to another straightforwardly enough. So, is the problem identifying the possible candidates ? If so, what is the nature of that problem ?