File Coverage

blib/lib/CAD/Firemen/Change.pm

Criterion	Covered	Total	%
statement	15	173	8.6
branch	0	66	0.0
condition	0	18	0.0
subroutine	5	27	18.5
pod	20	20	100.0
total	40	304	13.1

#!/usr/bin/perl
######################
#
#    Copyright (C) 2011  TU Clausthal, Institut fuer Maschinenwesen, Joachim Langenbach
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program.  If not, see .
#
######################

use strict;
use warnings;

# Pod::Weaver infos
# ABSTRACT: Object to represant the changes of an option

package CAD::Firemen::Change;
{
  $CAD::Firemen::Change::VERSION = '0.7.1';
}
use Exporter 'import';

use CAD::Firemen::Common qw(strip);
use CAD::Firemen::Change::Type;

sub new {
  my ($class) = shift;
  my (%params) = @_;

  # check parameters
  if(!exists($params{"name"})){
    $params{"name"} = "";
  }
  if(!exists($params{"valueOld"})){
    $params{"valueOld"} = "";
  }
  if(!exists($params{"valueNew"})){
    $params{"valueNew"} = "";
  }

  my $self = {
    '_option' => $params{"name"},
    '_valueOld' => $params{"valueOld"},
    '_valueNew' => $params{"valueNew"},
    '_changeType' => {},
    '_changeDescription' => "",
    '_possibleValuesOld' => [],
    '_possibleValuesNew' => [],
    '_defaultValueOld' => "",
    '_defaultValueNew' => ""
  };
  bless $self, $class;
  $self->evalChange();
  return $self;
}

sub setOption {
  my $self = shift;
  my $name = shift;
  if(!defined($name)){
    return 0;
  }
  $self->{'_option'} = $name;
  return 1;
}

sub option {
  my $self = shift;
  return $self->{'_option'};
}

sub setValueOld {
  my $self = shift;
  my $value = shift;
  if(!defined($value)){
    return 0;
  }
  $self->{'_valueOld'} = $value;
  return 1;
}

sub valueOld {
  my $self = shift;
  return $self->{'_valueOld'};
}

sub setValueNew {
  my $self = shift;
  my $value = shift;
  if(!defined($value)){
    return 0;
  }
  $self->{'_valueNew'} = $value;
  return 1;
}

sub valueNew {
  my $self = shift;
  return $self->{'_valueNew'};
}

sub setPossibleValuesOld {
  my $self = shift;
  my $valuesRef = shift;
  if(!defined($valuesRef) || (ref($valuesRef) ne "ARRAY")){
    return 0;
  }
  $self->{'_possibleValuesOld'} = $valuesRef;
  return 1;
}

sub possibleValuesOld {
  my $self = shift;
  return $self->{'_possibleValuesOld'};
}

sub setPossibleValuesNew {
  my $self = shift;
  my $valuesRef = shift;
  if(!defined($valuesRef) || (ref($valuesRef) ne "ARRAY")){
    return 0;
  }
  $self->{'_possibleValuesNew'} = $valuesRef;
  return 1;
}

sub possibleValuesNew {
  my $self = shift;
  return $self->{'_possibleValuesNew'};
}


sub setDefaultValueOld {
  my $self = shift;
  my $value = shift;
  if(!defined($value)){
    return 0;
  }
  # default value must be an possible value
  my $found = 0;
  foreach my $posValue (@{$self->possibleValuesOld()}){
    if($value eq $posValue){
      $found = 1;
    }
  }
  if(!$found){
    return 0;
  }
  $self->{'_defaultValueOld'} = $value;
  return 1;
}

sub defaultValueOld {
  my $self = shift;
  return $self->{'_defaultValueOld'};
}

sub setDefaultValueNew {
  my $self = shift;
  my $value = shift;
  if(!defined($value)){
    return 0;
  }
  # default value must be an possible value
  my $found = 0;
  foreach my $posValue (@{$self->possibleValuesNew()}){
    if($value eq $posValue){
      $found = 1;
    }
  }
  if(!$found){
    return 0;
  }
  $self->{'_defaultValueNew'} = $value;
  return 1;
}

sub defaultValueNew {
  my $self = shift;
  return $self->{'_defaultValueNew'};
}

sub setChangeDescription {
  my $self = shift;
  my $value = shift;
  if(!defined($value)){
    return 0;
  }
  $self->{'_changeDescription'} = strip($value);
  return 1;
}

sub changeDescription {
  my $self = shift;
  return $self->{'_changeDescription'};
}

sub evalChange {
  my $self = shift;

  # reset change type
  $self->_setChangeType(CAD::Firemen::Change::Type->NoChange);

  # determine whether values or default values have changed
  my $valuesChanged = 0;
  my $defaultChanged = 0;
  # check for removed options
  foreach my $value (@{$self->possibleValuesOld()}){
    my $exist = 0;
    foreach my $newValue (@{$self->possibleValuesNew()}){
      if($value eq $newValue){
        $exist = 1;
        last;
      }
    }
    if(!$exist){
      $self->setChangeDescription($self->changeDescription() ."\nRemoved ". $value);
      $valuesChanged = 1;
    }
  }

  # check for added options
  foreach my $value (@{$self->possibleValuesNew()}){
    my $exist = 0;
    foreach my $oldValue (@{$self->possibleValuesOld()}){
      if($value eq $oldValue){
        $exist = 1;
        last;
      }
    }
    if(!$exist){
      $self->setChangeDescription($self->changeDescription() ."\nAdded ". $value);
      $valuesChanged = 1;
    }
  }

  # check for changed default value
  if($self->defaultValueNew() ne $self->defaultValueOld()){
    $self->setChangeDescription($self->changeDescription() ."\nDefault value changed from ". $self->defaultValueOld() ." to ". $self->defaultValueNew());
    $defaultChanged = 1;
  }

  # evaluate results
  if(($self->valueOld() ne $self->valueNew()) && (uc($self->valueOld()) eq uc($self->valueNew()))){
    $self->_addChangeType(CAD::Firemen::Change::Type->Case);
  }
  if(($self->valueOld() =~ m/^[A-Za-z]:[\\\/]/) && ($self->valueNew() =~ m/^[A-Za-z]:[\\\/]/)){
    $self->_addChangeType(CAD::Firemen::Change::Type->Path);
  }
  # NoSpecial means only valueOld and valueNew have changed
  # therefore it is NoSpecial, if values are not equal and it is not Case or Path
  if(($self->valueOld() ne $self->valueNew()) && !$self->changeType(CAD::Firemen::Change::Type->Case) && !$self->changeType(CAD::Firemen::Change::Type->Case)){
    $self->_addChangeType(CAD::Firemen::Change::Type->NoSpecial);
  }

  if($valuesChanged){
    $self->_addChangeType(CAD::Firemen::Change::Type->ValuesChanged);
  }
  if($defaultChanged){
    $self->_addChangeType(CAD::Firemen::Change::Type->DefaultValueChanged);
  }

  return 1;
}

sub _setChangeType {
  my $self = shift;
  my $value = shift;
  if(!defined($value)){
    return 0;
  }
  delete($self->{'_changeType'});
  $self->{'_changeType'} = {};
  return $self->_addChangeType($value);
}

sub _addChangeType {
  my $self = shift;
  my $value = shift;
  if(!defined($value)){
    return 0;
  }
  $self->{'_changeType'}->{$value} = 1;
  # if we have a change now, remove NoChange
  if($value ne CAD::Firemen::Change::Type->NoChange){
    if(exists($self->{'_changeType'}->{CAD::Firemen::Change::Type->NoChange})){
      delete($self->{'_changeType'}->{CAD::Firemen::Change::Type->NoChange});
    }
  }
  return 1;
}

sub changeType {
  my $self = shift;
  my $type = shift;
  if(!defined($type)){
    return 0;
  }
  if(exists($self->{'_changeType'}->{$type})){
    return 1;
  }
  return 0;
}

sub highlightColor {
  my $self = shift;
  if($self->changeType(CAD::Firemen::Change::Type->Case)){
    return "CYAN";
  }
  elsif($self->changeType(CAD::Firemen::Change::Type->Path)){
    return "MAGENTA";
  }
  return "YELLOW";
}

1;

__END__