root/trunk/antimatter/tim/Modules/SFLC/TimeTracker/Input/CategoryParser.pm

# Copyright (C) 2005, 2006   Software Freedom Law Center, Inc.
#  Author: Bradley M. Kuhn <bkuhn@softwarefreedom.org>
#
#  This software gives you freedom; it is licensed to you under version
#  3 of the GNU Affero General Public License.
#
#  This software is distributed WITHOUT ANY WARRANTY, without even the
#  implied warranties of MERCHANTABILITY and FITNESS FOR A PARTICULAR
#  PURPOSE.  See the GNU Affero General Public License for further
#  details.
#
# You should have received a copy of the GNU Affero General Public
# License, version 3 along with this software.  If not, see
# <http://www.gnu.org/licenses/>.
use strict;
use warnings;

package SFLC::TimeTracker::Input::CategoryParser;

use base qw( Class::Factory );

use Carp;
use String::Approx 'amatch';

###############################################################################
sub getDatabase { return SFLC::TimeTracker::Input::getDatabase();}
###############################################################################
sub init {
  my $self = shift;
  my(%inputVal) = @_;
  my $userHandle;

  print "keys of inputVal: ", join(", ", keys %inputVal), "\n";
  print "values of inputVal: ", join(", ", values %inputVal), "\n";

  if (defined $inputVal{userHandle}) {
    $userHandle = $inputVal{userHandle};
  } elsif (not defined $inputVal{user}) {
    croak "cannot instantiate a CategoryParser without user";
  } else {
    $userHandle = $self->getDatabase->getUserHandle($inputVal{user});
    croak "$inputVal{user} does not have a valid userHandle"
      unless defined $userHandle;
  }

  $self->{userHandle} = $userHandle;
  $self->{name} = "Exact";
  $self->{description} =
      "Requires an exact match of a time entry category or one of its aliases";

  return $self;
}
###############################################################################
sub get {
  my($self, $field) = @_;

  if ($field =~ /^(?:userHandle|categoryID|note|description|categoryCandidate|
                 description|outputTree|name|categoryDiscard)$/x) {
    return $self->{$field};
  } else {
    confess "$field is not a valid field";
    return undef;
  }
}
###############################################################################
sub userHandle {
  my($self) = shift;
  return $self->get('userHandle');
}
###############################################################################
sub clearFields {
  my $self = shift;
  foreach my $field (qw/categoryID note name categoryCandidate
                 description outputTree categoryDiscard/) {
    $self->set($field, undef);
  }
}
###############################################################################
sub set {
  my($self, $field, $value) = @_;

  if ($field =~ /^(?:userHandle|categoryID|note|name|categoryCandidate|
                 description|outputTree|categoryDiscard)$/x) {
    $self->{$field} = $value;
  } else {
    confess "$field is not a valid field";
    return undef;
  }
}
###############################################################################
sub findMinMatch ($$@) {
  my($self, $given, @candidates) = @_;

  # No choices mean no matches
  return () if @candidates <= 0;
  return () if not defined $given or $given =~ /^\s*$/;
  my $approxVal = 0;
  my @matches;
  while (@matches == 0  and ++$approxVal < 100) {
    (@matches) = amatch($given, ['i', "${approxVal}%"], @candidates);
  }
  return @matches;
}
###############################################################################
sub _doParse ($$) {
  my ($self, $line) = @_;

  my($note, $categoryID);

  if ($line =~ s/\s+"?no?te?:?\s*"?\s*([^"]+)"?\s*$//) {
    $note = $1;
  } elsif ($line =~ s/"([^"]+)"?\s*$//) {
    $note = $1;
  }

  if (defined $note) { $note =~ s/^\s+//;   $note =~ s/\s+$//; }


  my $categoryCandidate = join("/", split(/\s+/, "\L$line\E"));

  $categoryCandidate =~ s/^\s+//;   $categoryCandidate =~ s/\s+$//;
  $categoryCandidate =~ s/\/+$//;   $categoryCandidate =~ s!//!/!g;
  $categoryCandidate =~ s!:!/!g;
  $categoryCandidate = "/$categoryCandidate" unless $categoryCandidate =~ m%^/%;

  # Do an alias lookup in the database
  $categoryID = $self->getDatabase()->
                           categoryAliasLookup($self->{userHandle},
                                               $categoryCandidate);

  $self->set(note => $note);
  $self->set(categoryID => $categoryID);
  $self->set(categoryCandidate => $categoryCandidate);
  $self->set(categoryDiscard => "");

#   $self-> new SFLC::TimeTracker::Question::Category(
#                                  category => $categoryCandidate,
#                                  timeStamp => $timeStamp,
#                                  inputString => $self->{currentOriginalLine},
#                                  userHandle => $buildData->{userHandle},
#             question => "\"$categoryCandidate\" is an unknown category.",
#              answers => \@matches);

}

__PACKAGE__->add_factory_type( BasicLawyer =>
             'SFLC::TimeTracker::Input::CategoryParser::Lawyer');

__PACKAGE__->add_factory_type( AdminAssume =>
             'SFLC::TimeTracker::Input::CategoryParser::AdminAssume');
__PACKAGE__->add_factory_type( Assistant =>
             'SFLC::TimeTracker::Input::CategoryParser::Assistant');
__PACKAGE__->add_factory_type( Press =>
             'SFLC::TimeTracker::Input::CategoryParser::PR');
1;
#
# Local variables:
# compile-command: "perl -I ../../../../Modules -c CategoryParser.pm"
# End: