Ruby Invoice

September 2017 · 10 minute read

I have recently challenged my skills building a small program to process an order and generate an itemized invoice which calculates the optimum pack sizes to make up a given quantity for the best price.

The completed project can be viewed at https://github.com/SelenaSmall/ruby_invoice

Project Description

A fresh food supplier sells product items to customers in packs. The bigger the pack, the cheaper the cost per item.

The supplier currently sells the following products

Product            	Packs          
----------------------------------
Watermelons        	3 pack @ $6.99
                   	5 pack @ $8.99
                   
Pineapples         	2 pack @ $9.95
                   	5 pack @ $16.95
                   	8 pack @ $24.95
                   
Rockmelons         	3 pack @ $5.95
                  	5 pack @ $9.95
                   	9 pack @ $16.99

Your task is to build a system that can take a customer order…

For example, something like:

10 Watermelons 14 Pineapples 13 Rockmelons

And generate an invoice for the order…

For example, something like:

10 Watermelons         $17.98
   - 2 x 5 pack @ $8.99
14 Pineapples          $54.80
   - 1 x 8 pack @ $24.95
   - 3 x 2 pack @ $9.95
13 Rockmelons          $25.85
   - 2 x 5 pack @ $9.95
   - 1 x 3 pack @ $5.95
-----------------------------
TOTAL                  $98.63

Note that the system has determined the optimal packs to fill the order. You can assume that bigger packs will always have a cheaper cost per unit price.

Planing

The first step in any new project, of course is consider your requirements and make a plan. It’s likely the plan will change later, but it’s a start point.

Why did I choose ruby?

I’m most familiar to me so I will get the product out in a reasonable timeframe.
Just worked out a great way to practice TDD for ruby apps using Travis-CI.
I can see this product being object oriented therefore ruby seems like a reasonable fit.

Objects

I’m probably going to split the compnents up into individual objects as follows:

item(item_name, pack)
pack(qty, price)
- child of item (subClass)
order(items = [], basket)
basket(current_order=nil)
order_line(qty, item)
- calculate optimal packs required to make up the qty
- calculate total price of packs per product

invoice(order)

order.items.each do | item |
	puts item.get_receipt_line 
end

Input

This is my planned perception of how the program will work:

Would you like to LIST available products, SHOP, VIEW basket, EXIT without placing an order?

$_ LIST

list_products & packs

$_ SHOP

place your order:

$_ 10 watermelons
$_ VIEW

10 Watermelons			$17.98
	- 2 x 5 pack @ $8.99
——————————————————————————————
TOTAL                  	$17.98

Would you like to complete your order and checkout now?

$_ yes

> Your order has been placed, thank you. Goodbye!

$_ EXIT

> Your order has not been placed, are you sure you want to leave?

$_ yes

> Goodbye!

Assumptions

If someone orders a quantity of product which does not equal a quantity made up of packs, they will be charged for the the nearest quantity above what they have ordered.

ie 11 Watermelons = 2x 5 packs + 1x 3pack

Build Process

Initialize_repo

Set up Travis-CI and blank app to get started

https://github.com/SelenaSmall/ruby_invoice/commit/d16526d753b67aef99035c957471433a09548fa6

1. Create items and packs

Item class
Pack class
Watermelon class

I think for scalability, Watermelon should be a subclass of Item - I’m not quite sure yet how this is going to work. For now, I will just focus on getting the base of the app working.

Each sub-item will have a range of Packs available with pre-determined item qty’s and prices.

https://github.com/SelenaSmall/ruby_invoice/commit/f2812ece9a4d347417e0651a794e5d972708801d

2. Handle user inputs

Handle_input class

I put this in next because it makes me feel better to know what the end result will connect to. At this stage, the only thing being checked is that a command is valid.

https://github.com/SelenaSmall/ruby_invoice/commit/828dc25d386207223dc6f67111d8f3427766c5a3

3. Define orders

Basket class

Need an empty basket to put the orders into

Order class

To put the items into the basket

https://github.com/SelenaSmall/ruby_invoice/commit/925b83c8fe0578ec24bc40e2e4e179a30fe842c2

4. Define each line in the order

Order_line class

The quantity and name of the item requested to be ordered by customer input

https://github.com/SelenaSmall/ruby_invoice/commit/ffba1411bafd814d9057501ade50c5c722d0a4c7

5. Determine optimal packs for each order line

Given what I have so far, there is enough to make the SHOP and LIST actions work with my HandleInput class.

SHOP should allow user to input an order_line in the format “3 watermelon”

OrderLine needs to determine the optimal # of packs to fill the order:

packs = []
left_over_qty = order_qty
pack.each (starting from largest value) do |p|
	left_over_qty / p
	for each whole result, packs << p
	left_over_qty = remainder
	next
end

https://github.com/SelenaSmall/ruby_invoice/commit/424c2d597de3150800030276ab9faff66701f70d https://github.com/SelenaSmall/ruby_invoice/commit/120a507f8be82fdb81753abc9a6b00aa838535f3

6. Add orderline packs to Order

OrderLine needs to be added to the overall Order

Both Basket and Order probably aren’t required at this point

I’ll start by initialising the Order object in app entry and update it with every additional item added when ‘shopping’

https://github.com/SelenaSmall/ruby_invoice/commit/ddd08f537eff38792eeb2b5e222d9f6daba064cb

7. Review and refactor

Got a bunch of code working and doing it’s job. Time for a tidy up!

Refactor the code and revise tests

Although there is no duplicate code, there is certainly room for improvements and methods can be broken down into smaller easier-to-work-with components

https://github.com/SelenaSmall/ruby_invoice/commit/e7df573d38fd1178cc567e3d0b70d65406d17b5a

8. Define invoice

Invoice class

VIEW should output the itemised invoice of the full order

https://github.com/SelenaSmall/ruby_invoice/commit/f232c0bf3bcbbc054b6c69d2fe1b01bdd50a0d18

9. Define additional products

Create additional fruit items

Reorganise code and review tests again.
Refactor shop_menu into it’s own method

https://github.com/SelenaSmall/ruby_invoice/commit/56b658717a5ee41287142733e5cd7e73c1f24e81

10. Define LIST action

LIST should output a list of available items with their pack size and quantity. I probably should have listed the options first, but I was on a roll with SHOP and now that I’ve gotten this far, it seems less relevant. Still it will tie the app nicely to be able to view all available products and pack sizes.

11. Break down HandleInput methods

The handle_input class is getting too heavy, especially considering the size of the app. I’ve just taken this opportunity to also move the shop methods out into their own Shop object

https://github.com/SelenaSmall/ruby_invoice/commit/4b96f158a107d02dcc69d58fff9ce34d742f3f35

12. Review OrderLine

I’m still pretty unhappy with the OrderLine methods. They’re chunky and painful to look at, which leads me to believe there must be a better way.

It also looks like I’ve made a mistake in selecting optimal pack sizes. I focussed too much on trying to make up qty’s which would not be an exact product of pack sizes available and in the process overlooked searching for an exact match first.

What I actually should have done was check if an exact match is possible first.

if order_qty === any sum of pack sizes
	make up order with those
	(using lowest price combo)
else
	go get whole/left_over_pieces to make up closest qty packs
	OR
    if qty does not add up, ignore it. 
end

This is actually trickier than I initially thought, but the best way to approach it is to break it right down and play around with a simple array in a seperate window. Here’s the test I ended up writing to get the whole optimal selection part working.

class ArrayCheck
  attr_reader :pack_qtys

  def initialize
    @pack_qtys = [[2, 6], [5, 9], [8, 16]]
  end

  def optimal(qty)
    # Get Exact matches
    exact_matches = []
    pack_qtys.sort { |a, b| b <=> a }.each do |p, v|
      next unless (qty / p) * p == qty
      exact_matches << [qty / p, p, v]
    end
    # puts exact_matches

    # Check for the optimim price
    price_check = []
    exact_matches.each do |x, y, z|
      val = (x * z)

      price_check << [x, y, z, val]
    end
    # puts price_check

    numbers = price_check.select { |x| x[3] }.map

    # Get Part matches
    partial_matches = []
    pack_qtys.sort { |a, b| b <=> a }.each do |p, v|
      partial_matches << [qty / p, p, v]
    end
    # puts partial_matches

    # Top up part matches
    exact_partial = []
    partial_matches.each do |x, y, z|
      val = qty - (x * y)

      pack_qtys.detect do |a|
        if a.include?(val)
          exact_partial << [x, y, z]
          exact_partial << [val / a[0], a[0], a[1]]
        end
      end
    end
    # puts exact_partial

    # Check for the optimim partial price
    partial_price_check = []
    exact_partial.each do |x, y, z|
      val = (x * z)

      partial_price_check << [x, y, z, val]
    end
    # puts partial_price_check

    partial_numbers = partial_price_check.select { |x| x[3] }.map

    partial_price_array = []
    partial_numbers.each do |f|
      partial_price_array << f
    end
    # puts partial_price_array

    puts "Exact Match: #{exact_matches}"
    # Array for bext price line: 1x 9pk @16 = $16
    puts "Best Exact Price: #{numbers.min}"
    puts "Partial Match: #{exact_partial}"
    puts "Best Partial Price: #{partial_price_array}"

    calculate_best(numbers.min, partial_price_array)
  end

  def calculate_best(exact, partial)
    sub_total = []
    partial.each do |_x, _y, _z, val|
      sub_total << val
    end

    # Find total cost of sub_items
    line_total = sub_total.inject(:+)

    # Return array of the cheapest line
    puts "\nThis is it #{partial}" if [exact[3], line_total].min == line_total

    puts "\nThis is it #{exact}" if [exact[3], line_total].min == exact
  end
end

array = ArrayCheck.new

array.optimal(14)

Transfer the test code into my project and wallah! The pack selections that are meant to be made on orders are now being made!!

It’s late now, so before I call it a day I’m just going to make sure my existing tests pass. Although this is now working, it’s certainly not finished. I’ll break down the code in cleaner methods and write the tests fro them tomorrow.

https://github.com/SelenaSmall/ruby_invoice/commit/ace50ed589c4e0a3bb1038e716633324d54e3b63

13. Optimise OrderLine

Same process. Now that the system is actually working the way it should, I can go through and do a clean up.

a) Ensure all items are returned in the same format

Optimal method responses as determined by calculate_best method - I want everything to be returned as an Enumerator.

b) Split optimal sections out into individual methods

This will thin down the optimal method and make it easier to see what’s going on. By adding doc blocks, I will also be able to see clearly any duplicate methods.

def exact_match(pack_qtys, exact_matches)
    pack_qtys.sort { |a, b| b <=> a }.each do |p, v|
      next unless (order_qty / p) * p == order_qty
      exact_matches << [order_qty / p, p, v]
    end

    exact_matches
end

def price_check(exact_matches, price_check)
    exact_matches.each do |x, y, z|
      val = (x * z)

      price_check << [x, y, z, val]
    end

    price_check
end

def partial_matches(pack_qtys, partial_matches)
    pack_qtys.sort { |a, b| b <=> a }.each do |p, v|
      partial_matches << [order_qty / p, p, v]
    end

    partial_matches
end

def exact_partial(pack_qtys, partial_matches, exact_partial)
    partial_matches.each do |x, y, z|
      val = order_qty - (x * y)
      puts "VAL: #{val}"
      pack_qtys.detect do |a|
        # To be optimised: a.include?(val) does not cooperate with Money
        if a[0] == val || a[0] * 3 == val
          exact_partial << [x, y, z]
          exact_partial << [val / a[0], a[0], a[1]]
        end
      end
    end

    exact_partial
end

def partial_price_check(exact_partial, partial_price_check)
    exact_partial.each do |x, y, z|
      val = (x * z)

      partial_price_check << [x, y, z, val]
    end

    partial_price_check
end

def partial_price_array(partial_numbers, partial_price_array)
    partial_numbers.each do |f|
      partial_price_array << f
    end

    partial_price_array
end

c) Review those methods

Look to see where duplicate code can be cut out and find methods which are not required.

There are two identical methods - I only need this code once:

price_check
partial_price_check

Additionally, two methods are called currently to return one object. The difference is one extra param - these can be combined into one method.

partial_matches
exact_partial

There are now two identical lines in the optimal method which means they can be abstracted out into their own method.

exact_match_prices = exact_price_check.select { |x| x[3] }.map
partial_numbers = partial_price_check.select { |x| x[3] }.map

And they will become:

  def match_prices(array)
    array.select { |x| x[3] }.map
  end

I’ve also got a completely unnecessary method, since I’ll be handling Enumerators instead of Arrays, I won’t need this:

partial_price_array

d) Clean up calculate_best method

e) Optimal method check

Return unless there is an optimal match for packs (ignore the order item).

https://github.com/SelenaSmall/ruby_invoice/commit/1d97d008f8fd21ba852eb89d12920803f6b80ea7 https://github.com/SelenaSmall/ruby_invoice/commit/b3c7b73cc5483b71b9247df037a4eacd0b433235

Documentation & Final Review

Of course, no good code is complete without doc blocks and no project is complete without a README. This is also a good chance to review and add additional tests which might have been overlooked. - Finished up with tests passing a 99% code coverage.

https://github.com/SelenaSmall/ruby_invoice/commit/199b7b4cde020a4b89fc6762e052604e47008923

Selena Small

Blogger | Developer | Nak Muay Ying

Ruby Invoice

Project Description

Planing

Build Process

Documentation & Final Review