File Coverage

blib/lib/Business/Inventory/Valuation.pm

Criterion	Covered	Total	%
statement	96	97	98.9
branch	33	36	91.6
condition	6	9	66.6
subroutine	9	9	100.0
pod	6	6	100.0
total	150	157	95.5

package Business::Inventory::Valuation;

our $DATE = '2018-03-17'; # DATE
our $VERSION = '0.007'; # VERSION

use 5.010001;
use strict;
use warnings;

sub new {
    my $class = shift;
    my %args = @_;

    my $self = bless {}, $class;

    die "Please specify method" unless $args{method};
    die "Invalid method, please choose LIFO/FIFO/weighted average"
        unless $args{method} =~ /\A(LIFO|FIFO|weighted average)\z/;
    $self->{method} = delete $args{method};

    $self->{allow_negative_inventory} = delete $args{allow_negative_inventory};

    keys(%args) and die "Unknown argument(s): ".join(", ", keys %args);

    $self->{_inventory} = [];
    $self->{_units} = 0;
    $self->{_average_purchase_price} = undef;

    $self;
}

sub buy {
    my ($self, $units, $unit_price) = @_;

    # sanity checks
    die "Units must be > 0" unless $units > 0;
    die "Unit price must be >= 0" unless $unit_price >= 0;

    if (!@{ $self->{_inventory} }) {
        push @{ $self->{_inventory} }, [$units, $unit_price];
        $self->{_units} = $units;
        $self->{_average_purchase_price} = $unit_price;
    } elsif (@{ $self->{_inventory} } && $self->{_inventory}[-1][1] == $unit_price) {
        my $old_units = $self->{_units};
        $self->{_inventory}[-1][0] += $units;
        $self->{_units} += $units;
        $self->{_average_purchase_price} = (
            $old_units * $self->{_average_purchase_price} +
                $units * $unit_price) / $self->{_units};
    } elsif ($self->{method} eq 'weighted average') {
        my $old_units = $self->{_units};
        $self->{_inventory}[0][0] = $self->{_units} = $self->{_units} + $units;
        $self->{_inventory}[0][1] = $self->{_average_purchase_price} = (
            $old_units * $self->{_average_purchase_price} +
                $units * $unit_price) / $self->{_units};
    } else {
        push @{ $self->{_inventory} }, [$units, $unit_price];
        my $old_units = $self->{_units};
        $self->{_units}+= $units;
        $self->{_average_purchase_price} = (
            $old_units * $self->{_average_purchase_price} +
                $units * $unit_price) / $self->{_units};
    }
}

sub sell {
    my ($self, $units, $unit_price) = @_;

    # sanity checks
    die "Units must be > 0" unless $units > 0;
    die "Unit price must be >= 0" unless $unit_price >= 0;

    my $profit = 0;
    my $units_sold = 0;

    if ($self->{_units} < $units) {
        if ($self->{allow_negative_inventory}) {
            $units = $self->{_units};
        } else {
            die "Attempted to oversell ($units, while inventory only has ".
                "$self->{_units})";
        }
    }

    my $remaining = $units;
    my $orig_average_purchase_price = $self->{_average_purchase_price};

    # due to rounding error, _units and _inventory might disagree for a bit
    while ($self->{_units} > 0 && @{ $self->{_inventory} } && $remaining > 0) {
        my $item;
        if ($self->{method} eq 'LIFO') {
            $item = $self->{_inventory}[-1];
        } else {
            $item = $self->{_inventory}[0];
        }

        if ($item->[0] > $remaining) {
            # inventory item is not used up
            my $old_units = $self->{_units};
            $item->[0] -= $remaining;
            $self->{_units} -= $remaining;
            if ($self->{_units} == 0) {
                undef $self->{_average_purchase_price};
            } else {
                $self->{_average_purchase_price} = (
                    $old_units * $self->{_average_purchase_price} -
                        $remaining * $item->[1]) / $self->{_units};
            }
            $profit += $remaining * ($unit_price - $item->[1]);
            $units_sold += $remaining;
            $remaining = 0;
            goto RETURN;
        } else {
            # inventory item is used up, remove from inventory
            if ($self->{method} eq 'LIFO') {
                pop @{ $self->{_inventory} };
            } else {
                shift @{ $self->{_inventory} };
            }
            $units_sold += $item->[0];
            $remaining -= $item->[0];
            my $old_units = $self->{_units};
            $self->{_units} -= $item->[0];
            $profit += $item->[0] * ($unit_price - $item->[1]);
            if ($self->{_units} == 0) {
                undef $self->{_average_purchase_price};
            } else {
                $self->{_average_purchase_price} = (
                    $old_units * $self->{_average_purchase_price} -
                        $item->[0] * $item->[1]) / $self->{_units};
            }
        }
    }

  RETURN:
    my @return;
    if (defined $orig_average_purchase_price) {
        push @return, $units *
            ($unit_price - $orig_average_purchase_price);
    } else {
        push @return, undef;
    }
    push @return, $profit;
    push @return, $units_sold;
    @return;
}

sub inventory {
    my $self = shift;
    @{ $self->{_inventory} };
}

sub units {
    my $self = shift;
    $self->{_units};
}

sub average_purchase_price {
    my $self = shift;
    $self->{_average_purchase_price};
}


1;
# ABSTRACT: Calculate inventory value/unit price (using LIFO/FIFO/weighted average)

__END__