seshbot-packing 0.8.2 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7336679900a9b2f7950d7af79692a4a1fa42c89d88b7b3e7e9932a564a0913c8
-  data.tar.gz: 4e3ced53b824add98949a55290e80c411f929b1c9032948214de06bac6107ce1
+  metadata.gz: 5a3ee88fef7cdb7044eb06951aaee1a388dc499a33226d553ecf1d4af3865df2
+  data.tar.gz: 7ceb6a0a5ad57b515e881352907e42c3bec29330c1055a8947e9662f03ad0ebc
 SHA512:
-  metadata.gz: 717491a4886d9ae93e5e68f9036aeeea39aa50752718e77e2a6bfdba81a794944fd3d48a5aa4f32dad48e8385bcaa327ee662026b3e241f6ed66fd12f6c59d41
-  data.tar.gz: ba70ad1c512f59b905b560414efe5ed7e31a8cc69ad971e7fa402cc4fb2c5b493da40044162eb5864f958ee205ea43ccf94dd94837591eb71a60d67d79c69098
+  metadata.gz: d7d04a459fbfc6dc06b7b028b535f5a1ab8e87579eb59f3aebc6803d82587abd7582c94074217e6935e189ba56d185138841aca429c3e774ff872c6e82e4a93c
+  data.tar.gz: 030363e4fe38d1f095766f836b86960639e8f3a23cbdde611c3d305cb259315816adc0a488cde7134f778958d3022f19056a0f850244324e0a844bc855195ba9

data/Gemfile

@@ -4,3 +4,5 @@ source "https://rubygems.org"
 gemspec
 gem "rake", "~> 12.0"
 gem "minitest", "~> 5.0"
+
+gem "timecop"

data/Gemfile.lock

@@ -1,13 +1,14 @@
 PATH
   remote: .
   specs:
-    seshbot-packing (0.8.1)
+    seshbot-packing (0.9.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
     minitest (5.14.2)
     rake (12.3.3)
+    timecop (0.9.4)
 
 PLATFORMS
   ruby
@@ -16,6 +17,7 @@ DEPENDENCIES
   minitest (~> 5.0)
   rake (~> 12.0)
   seshbot-packing!
+  timecop
 
 BUNDLED WITH
    2.1.4

data/README.md

@@ -1,5 +1,45 @@
 # Seshbot::Packing
 
+This gem allows inventory to be packed for shipping - used by BrewKeeper for pick/pack logic, and by Carrierbot to aid in calculating 'bundled' shipping rates
+
+## Recipes
+
+The packing rules are described as 'recipes' - one of which is represented as a hash of the format:
+
+```ruby
+{
+  'input_fragment': 'B306',
+  'input_quantity': 1,
+  'output_fragment': 'B301',
+  'output_quantity': '6',
+  'is_reversible': true # optional
+}
+```
+
+The process of packing a collection of line-items in a customer shipment into a smplified set of line-items representing the most cost effective way to pack those items is as follows:
+
+* get all quantity+SKUs in the order/fulfillments in the request
+* unpack as much as possible by:
+** reverse all recipes inputs/outputs
+** find the ‘best’ recipe (the recipe that gives the MOST outputs)
+** repeat until no more unpacking can be done
+* pack as much as possible by:
+** find the ‘best’ recipe (the recipe that gives the FEWEST outputs)
+** repeat until no more packing can be done
+
+Therre area few special considerations:
+- optional `is_reversible` flag: some recipes may not deemed reversible for the 'unpacking' phase; e.g., 3xB306->1xB324. These should be marked as 'is_reversible': false
+- optional `phase` flag: packing recipes may be performed in 'phases' in order to ensure certain rules are adhered to for specific products or variant types (e.g., pack cans into special can-cartons before allowing the remainders to be mixed in with bottles)
+
+Note that if a recipe is found, _it will be applied_ unless a better rule is found.
+
+## Building
+
+* Update the VERSION file
+* `gem build seshbot-packing.gemspec`
+* commit changes
+* `gem push seshbot-packing-VERSION.gem`
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -35,15 +75,15 @@ Seshbot::Packing.count_product_types(items)
 ## returns the hashes where the sku value matches the given string
 items = [{ 'sku' => 'A-C306', 'quantity' => 4, 'price' => 1 },
          { 'sku' => 'A-B306', 'quantity' => 4, 'price' => 1 }]
-Seshbot::Packing.filter_by_sku(items, '-C')
+Seshbot::Packing._filter_by_sku(items, '-C')
 #=> [{ 'sku' => 'A-C306', 'quantity' => 4, 'price' => 1 }]
 ## also takes a named argument
-Seshbot::Packing.filter_by_sku(items, '-C', inverse: true)
+Seshbot::Packing._filter_by_sku(items, '-C', inverse: true)
 #=> [{ 'sku' => 'A-B306', 'quantity' => 4, 'price' => 1 }]
 
 # Substitute SKU
 ## replaces an sku in a hash
-Seshbot::Packing.substitute_sku(items, '-B', '-C')
+Seshbot::Packing._substitute_sku(items, '-B', '-C')
 #=> items = [{"sku" => "A-C306", "quantity" => 2}, {"sku" => "B-C306", "quantity" => 1}]
 ```
 

data/lib/seshbot/packing.rb

@@ -1,3 +1,4 @@
 require "seshbot/packing/version"
 require "seshbot/packing/package"
 require "seshbot/packing/recipe"
+require "seshbot/packing/line_item"

data/lib/seshbot/packing/line_item.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Seshbot
+  module Packing
+    # :nodocs:
+    class LineItem
+      attr_accessor :sku_fragment, :quantity, :price
+
+      def initialize(sku_fragment, quantity, price=0)
+        raise 'SKU fragment must be a string' if sku_fragment.class != String
+        raise 'Quantity must be an integer' if quantity.class != Integer
+
+        @sku_fragment = sku_fragment
+        @quantity = quantity
+        @price = price
+      end
+
+      def to_s
+        "#{quantity}x#{sku_fragment}"
+      end
+
+      def self.summarise(items)
+        "#{items.map(&:to_s)}"
+      end
+
+      def self.total_quantity(items)
+        items.map { |i| i.quantity }.sum
+      end
+
+      def self.merge_line_items(items)
+        result = Hash.new(0)
+        # create a hash were the keys are sku_fragment, and the values are the summed quantities
+        items.each do |item|
+          result[item.sku_fragment] += item.quantity
+        end
+        result.delete_if { |k,v| v == 0 }
+        result.map { |sku_fragment, quantity| LineItem.new(sku_fragment, quantity) }
+      end
+    end
+  end # module Packing
+end # module Seshbot

data/lib/seshbot/packing/package.rb

@@ -5,144 +5,165 @@ module Seshbot
   module Packing
     class Error < StandardError; end
     class << self
+      @@logger = nil
       def logger
-        Logger.new(STDERR)
+        if @@logger.nil?
+          @@logger = Logger.new(STDERR)
+          @@logger.level = 1
+        end
+        @@logger
       end
 
-      def filter_by_sku(items, sku_fragment, inverse: false)
-        items.select do |i|
-          matches = i['sku'].include?(sku_fragment)
-          inverse ? !matches : matches
+      def bundle_items(recipes, items, fulfilled_at: nil)
+        if !fulfilled_at.nil? && fulfilled_at < DateTime.parse('2020-01-14T08:00:00+09:00')
+          logger.debug "== Not Bundling (pre-2020 order) =="
+          return items
         end
-      end
+        is_legacy = _is_legacy(fulfilled_at)
+        is_legacy_str = is_legacy ? " (LEGACY)" : ""
 
-      def substitute_sku(items, from, to)
-        items.each { |i| i['sku'].gsub!(from, to) }
-        items
-      end
+        logger.debug "== Bundling Items: #{items.map(&:to_s)}. Fulfilled at: #{fulfilled_at || '(no fulfillment date)'}#{is_legacy_str}"
 
-      def count_product_types(items)
-        result = Hash.new(0)
-        # create a hash were the keys are sku_fragment, and the values are the summed quantities
-        items.each do |item|
-          size = packaged_size(item["sku"])
-          result[size] += item["quantity"]
+        results = []
+
+        if is_legacy
+          results = _bundle_items_legacy(recipes, items)
+        else
+          phases = recipes.values.map { |r| r['phase'] || 0 }.map(&:to_i).uniq.sort
+
+          results = items
+          phases.each do |phase|
+            phase_recipes = recipes.select { |name, recipe| (recipe['phase'] || 0) == phase }.to_h
+
+            logger.debug "=== Bundling phase #{phase}"
+
+            results = _bundle_items_single_phase(phase_recipes, results)
+          end
         end
-        result
+
+        logger.debug "Bundled result:"
+        logger.debug " - IN: #{items.map(&:to_s)}"
+        logger.debug " - OUT: #{results.map(&:to_s)}"
+
+        results
       end
 
-      def packaged_size(sku)
-        size_regex = /-([LUP]\d{2}|[BCM]\d{3})/
-        match = sku.match(size_regex)
-        raise "Cannot determine packaged size for SKU: #{sku}" if match.nil? || match.captures.empty?
+      def unpack(recipes, items)
+        prev_result = items
 
-        # this is everything inside the (..) in the regex (everything except the leading '-')
-        result = match.captures[0]
+        (1..1000).each do |i|
+          new_result = _pack_single_step(recipes, prev_result, unpacking: true)
+          is_unchanged = new_result.map { |li| [li.sku_fragment, li.quantity] }.sort == prev_result.map { |li| [li.sku_fragment, li.quantity] }.sort
+          return new_result if is_unchanged
 
-        if result == "B502"
-          result = "B306"
+          prev_result = new_result
         end
-        if result == "B504"
-          result = "B312"
-        end
-        raise "Cannot determine packaged size for SKU: #{sku}" if result.nil?
-
-        result
+        error_message = "could not unpack - infinite loop? (latest: #{prev_result.map(&:to_s)})"
+        logger.error error_message
+        raise error_message
       end
 
-      def bundle_items(items, fulfilled_at: nil)
-        logger.debug "***** BUNDLING"
-        logger.debug "Bundling Items: #{items}. Fulfilled at: #{fulfilled_at || '(no fulfillment date)'}"
-        if !fulfilled_at.nil? && fulfilled_at < DateTime.new(2020, 1, 14, 8, 0, 0, Time.new.zone)
-          return items.map { |item| { 'sku' => item.sku, 'quantity' => item.quantity, 'price' => item.price } }
+      def pack(recipes, items)
+        prev_result = items
+
+        # keep trying to 'pack' until it stabilises (e.g., 6x6pack => 1x24pack+2x6pack => 1x24pack+1x12pack)
+        (1..1000).each do |i|
+          new_result = _pack_single_step(recipes, prev_result, unpacking: false)
+          # no changes, break out
+          is_unchanged = new_result.map { |li| [li.sku_fragment, li.quantity] }.sort == prev_result.map { |li| [li.sku_fragment, li.quantity] }.sort
+          return new_result if is_unchanged
+
+          prev_result = new_result
         end
+        error_message = "could not pack - infinite loop? (latest: #{prev_result.map(&:to_s)})"
+        logger.error error_message
+        raise error_message
+      end
 
+      #
+      # private
+      #
+
+      def _is_legacy(fulfilled_at)
+        effective_fulfilled_at = fulfilled_at.nil? ? DateTime.now : fulfilled_at
+        is_legacy = effective_fulfilled_at < DateTime.parse('2021-04-07T09:00:00+09:00')
+        is_legacy
+      end
+
+      def _bundle_items_legacy(recipes, items)
         # get the cans first, and separate them out
-        cans = filter_by_sku(items, '-C')
+        cans = _filter_by_sku_fragment_prefix(items, 'C')
+        remaining_cans = []
         unless cans.empty?
-          product_type_counts = count_product_types(cans)
-          product_type_counts = unpack(product_type_counts)
-          product_type_counts = pack(product_type_counts)
-          new_can_items = product_type_counts.map { |k, v| { 'sku' => "BUND-#{k}", 'quantity' => v, 'price' => 0 } }
+          bundle_items_by_type = LineItem.merge_line_items(cans)
+          bundle_items_by_type = unpack(recipes, bundle_items_by_type)
+          new_can_items = pack(recipes, bundle_items_by_type)
           # separate out all the C324s
-          separated_c324s = filter_by_sku(new_can_items, '-C324')
-          logger.debug "Cans: #{cans}"
-          logger.debug " - Removed C324s: #{separated_c324s}"
+          separated_c324s = _filter_by_sku_fragment_prefix(new_can_items, 'C324')
+          logger.debug "Cans: #{cans.map(&:to_s)}"
+          logger.debug " - Removed C324s: #{separated_c324s.map(&:to_s)}"
 
-          remaining_cans = filter_by_sku(new_can_items, '-C324', inverse: true)
-          logger.debug " - Remaining skus: #{remaining_cans}"
+          remaining_cans = _filter_by_sku_fragment_prefix(new_can_items, 'C324', inverse: true)
+          logger.debug " - Remaining skus: #{remaining_cans.map(&:to_s)}"
         end
 
         # merge the remaining with the original leftover
-        non_cans = filter_by_sku(items, '-C', inverse: true)
-        remaining_cans ||= []
+        non_cans = _filter_by_sku_fragment_prefix(items, 'C', inverse: true)
         remaining_items = non_cans + remaining_cans
         logger.debug "Substituting:"
-        logger.debug " - remaining items: #{remaining_items}"
+        logger.debug " - remaining items: #{remaining_items.map(&:to_s)}"
 
         # substitute C's for B's
-        substitute_sku(remaining_items, '-C', '-B')
-        logger.debug " - skus updated to: #{remaining_items}"
+        remaining_items = _substitute_sku(remaining_items, /^C/, 'B')
+        logger.debug " - skus updated to: #{remaining_items.map(&:to_s)}"
 
         # get a hash of {pack_6: 5, pack_12: 1}
-        product_type_counts = count_product_types(remaining_items)
+        bundle_items_by_type = LineItem.merge_line_items(remaining_items)
         # dismantle packages into individual units (e.g., {pack_6: 7})
-        product_type_counts = unpack(product_type_counts)
+        bundle_items_by_type = unpack(recipes, bundle_items_by_type)
         # repackage into the 'best' packaging we can figure out (e.g., {pack_12: 2})
-        product_type_counts = pack(product_type_counts)
-        new_remaining_items = product_type_counts.map { |k,v| { "sku" => "BUND-#{k}", "quantity" => v, "price" => 0} }
+        new_remaining_items = pack(recipes, bundle_items_by_type)
 
         separated_c324s ||= []
-        merged_items = new_remaining_items + separated_c324s
-        logger.debug "Bundled result:"
-        logger.debug " - IN: #{items}"
-        logger.debug " - OUT: #{merged_items}"
-        merged_items
-      end
+        results = new_remaining_items + separated_c324s
 
-
-      def unpack(product_type_counts)
-        final_result = product_type_counts
-
-        while true
-          new_result = pack_single_step(final_result, unpacking: true)
-          break if new_result == final_result
-
-          final_result = new_result
-        end
-        final_result
+        results
       end
 
-      def pack_single_step(product_type_counts, unpacking:)
-        result = Hash.new(0)
-        product_type_counts.each do |sku_fragment, qty|
-          recipe = Recipe::find_best_recipe(sku_fragment, qty, unpacking: unpacking)
-          if recipe.nil?
-            result[sku_fragment] += qty
-            next
-          end
+      def _bundle_items_single_phase(recipes, items)
+        # get a list of items merged together by variant type (e.g., 10xBIGI-C301 + 5xBISS-C301 => 15xBUND-C301))
+        merged_items = LineItem.merge_line_items(items)
+        # dismantle packages into individual units
+        unpacked_items = unpack(recipes, merged_items)
+        # repackage into the 'best' packaging we can figure out
+        pack(recipes, unpacked_items)
+      end
 
-          recipe_quantities = Recipe::apply_recipe(recipe, qty)
-          result[recipe["input_fragment"]] += recipe_quantities[:input_quantity]
-          result[recipe["output_fragment"]] += recipe_quantities[:output_quantity]
+      def _filter_by_sku_fragment_prefix(items, sku_fragment, inverse: false)
+        items.select do |i|
+          matches = i.sku_fragment.start_with? sku_fragment
+          inverse ? !matches : matches
         end
-        result.delete_if { |k,v| v == 0}
-        result
       end
 
+      def _substitute_sku(items, re, sub)
+        items.map { |i| LineItem.new(i.sku_fragment.gsub(re, sub), i.quantity) }
+      end
 
-      def pack(product_type_counts)
-        final_result = product_type_counts
-
-        # keep trying to 'pack' until it stabilises (e.g., 6x6pack => 1x24pack+2x6pack => 1x24pack+1x12pack)
-        while true
-          new_result = pack_single_step(final_result, unpacking: false)
-          # no changes, break out
-          break if new_result == final_result
-          final_result = new_result
+      def _pack_single_step(recipes, items, unpacking:)
+        recipe = Recipe::find_best_recipe(recipes, items, unpacking: unpacking)
+        if recipe.nil?
+          # its as packed/unpacked as it can get
+          return items
         end
-        final_result
+
+        before = LineItem::summarise(items)
+        items = Recipe::apply_recipe(recipe, items)
+        after = LineItem::summarise(items)
+        logger.debug "applying recipe (#{unpacking ? 'unpacking' : 'packing'}) #{Recipe::summarise(recipe)}: #{before} -> #{after}"
+        items
       end
-    end
-  end
-end
+
+    end # class << self
+  end # module Packing
+end # module Seshbot

data/lib/seshbot/packing/recipe.rb

@@ -2,113 +2,127 @@ module Seshbot
   module Packing
     module Recipe
       class << self
-        def get_recipes
-          {
-              "bottles_twenty_four_pack_4"=>{
-                  "input_fragment"=>"B306",
-                  "input_quantity"=>4,
-                  "output_fragment"=>"B324",
-                  "output_quantity"=>1
-              },
-              "bottles_twenty_four_pack_3"=>{
-                  "input_fragment"=>"B306",
-                  "input_quantity"=>3,
-                  "output_fragment"=>"B318",
-                  "output_quantity"=>1
-              },
-              "bottles_twelve_pack"=>{
-                  "input_fragment"=>"B306",
-                  "input_quantity"=>2,
-                  "output_fragment"=>"B312",
-                  "output_quantity"=>1
-              },
-              "bottles_six_pack"=>{
-                "input_fragment"=>"B301",
-                "input_quantity"=>6,
-                "output_fragment"=>"B306",
-                "output_quantity"=>1
-              },
-              "cans_twenty_four_pack_4"=>{
-                "input_fragment"=>"C306",
-                "input_quantity"=>4,
-                "output_fragment"=>"C324",
-                "output_quantity"=>1
-              },
-              "cans_twenty_four_pack_3"=>{
-                "input_fragment"=>"C306",
-                "input_quantity"=>3,
-                "output_fragment"=>"C318",
-                "output_quantity"=>1
-              },
-              "cans_twelve_pack"=>{
-                "input_fragment"=>"C306",
-                "input_quantity"=>2,
-                "output_fragment"=>"C312",
-                "output_quantity"=>1
-              },
-              "cans_six_pack"=>{
-                "input_fragment"=>"C301",
-                "input_quantity"=>6,
-                "output_fragment"=>"C306",
-                "output_quantity"=>1
-              }
-          }
-        end
+        def find_best_recipe(recipes_hash, items, unpacking: false)
+          recipes = _find_recipes(recipes_hash, items, unpacking: unpacking)
 
-        def find_best_recipe(sku_fragment, qty, unpacking: false)
-          recipes = find_recipes(sku_fragment, qty, unpacking: unpacking)
           # we want the recipe that is 'best' (packaging into as few items as possible, or unpacaging into as many as possible)
-          best_recipe_quantities = nil
-          recipes.each do |name, recipe|
-            recipe_quantities = apply_recipe(recipe, qty)
-
-            # if there was no 'best' until now, just set it (makes the next step a bit simpler)
-            best_recipe_quantities ||= recipe_quantities
+          best_recipe = nil
+          best_recipe_output_quantity = nil
+          recipes.each do |recipe_name, recipe|
+            recipe_factor = _calculate_recipe_factor(recipe, items)
+            recipe_output_quantity = recipe_factor * recipe['output_quantity']
 
             # is this recipe the 'best'? (if packaging, best is the one that creates fewest quantity)
-            is_best = unpacking ?
-                        recipe_quantities[:output_quantity] > best_recipe_quantities[:output_quantity] :
-                        recipe_quantities[:output_quantity] < best_recipe_quantities[:output_quantity]
+            is_best = if best_recipe_output_quantity.nil?
+              true
+            else
+              unpacking ?
+                  recipe_output_quantity > best_recipe_output_quantity :
+                  recipe_output_quantity < best_recipe_output_quantity
+            end
 
             if is_best
-              best_recipe_quantities = recipe_quantities
+              best_recipe_output_quantity = recipe_output_quantity
+              best_recipe = recipe
             end
           end
-          best_recipe_quantities[:recipe] if best_recipe_quantities
+          best_recipe
         end
 
-        def find_recipes(sku_fragment, qty, unpacking: false)
-          recipes = get_recipes
-          recipes = reverse_recipes(recipes) if unpacking
-          recipes.select do |name, recipe|
-            recipe["input_fragment"] == sku_fragment && qty >= recipe["input_quantity"]
+        def apply_recipe(recipe, items)
+          factor = _calculate_recipe_factor(recipe, items)
+
+          # shortcut - cannot apply recipe, not enough inputs
+          return items if factor == 0
+
+          results = items.dup
+
+          # first remove inputs (add negative quantities)
+          recipe_inputs = recipe['inputs'].nil? ? [recipe] : recipe['inputs']
+          recipe_inputs.each do |inputs|
+            results << LineItem.new(inputs['input_fragment'], -1 * inputs['input_quantity'] * factor)
           end
-          # recipes.select { |name, recipe| recipe[:input_fragment] == sku_fragment && qty >= recipe[:input_quantity] }
+
+          # now add input
+          results << LineItem.new(recipe['output_fragment'], recipe['output_quantity'] * factor)
+
+          # consolidate 
+          results = LineItem.merge_line_items(results)
         end
 
-        def reverse_recipes(recipes)
-          results = recipes.map do |recipe_name, recipe_details|
+        def summarise(recipe)
+          recipe_inputs = recipe['inputs'].nil? ? [recipe] : recipe['inputs']
+          inputs = recipe_inputs.map { |i| "#{i['input_quantity']}x#{i['input_fragment']}" }.join(',')
+          outputs = "#{recipe['output_quantity']}x#{recipe['output_fragment']}"
+          "#{inputs} -> #{outputs}"
+        end
+
+        #
+        # private
+        #
+
+        def _calculate_recipe_factor(recipe, items)
+          recipe_inputs = recipe['inputs'].nil? ? [recipe] : recipe['inputs']
+
+          recipe_input_factors = recipe_inputs.map do |inputs|
+            input_fragment = inputs['input_fragment']
+            input_quantity = inputs['input_quantity']
+
+            item = items.find { |i| i.sku_fragment == input_fragment }
+            raise "recipe contains items not present in order (#{input_fragment})" if item.nil?
+
+            [inputs, item.quantity / input_quantity]
+          end
+
+          recipe_input_factors.map { |i,f| f }.min
+        end
+
+        def _find_recipes(recipes, items, unpacking: false)
+          recipes = _reverse_recipes(recipes) if unpacking
+          recipes.select do |recipe_name, recipe_details|
+            recipe_inputs = recipe_details['inputs'].nil? ? [recipe_details] : recipe_details['inputs']
+
+            # recipe is a candidate if all inputs may be satisfied by available items
+            recipe_inputs.all? do |inputs|
+              items.any? { |i| inputs["input_fragment"] == i.sku_fragment && i.quantity >= inputs["input_quantity"] }
+            end
+          end
+        end
+
+        def _reverse_recipes(recipes)
+          # first exclude recipes that are explicitly configured as not reversible
+          reversible_recipes = recipes.select do |recipe_name, recipe_details|
+            recipe_details['is_reversible'].nil? || recipe_details['is_reversible']
+          end
+
+          unique_reversible_output_fragments = reversible_recipes.values.map { |r| r['output_fragment'] }.sort.uniq
+
+          # further refine by excluding recipes that are technically incapable of being reversed
+          reversible_recipes = reversible_recipes.select do |recipe_name, recipe_details|
+            # currently dont support multipe outputs, so cannot reverse recipes with multiple inputs
+            is_composite = !recipe_details['inputs'].nil? && recipe_details['inputs'].length != 1
+            # cannot reverse recipes where there are multipe ways of creating the same output
+            is_ambiguous = !unique_reversible_output_fragments.include?(recipe_details['output_fragment'])
+
+            !is_composite && !is_ambiguous
+          end
+
+          results = reversible_recipes.map do |recipe_name, recipe_details|
+            # here we know that if 'inputs' is specified it will have exactly 1 input
+            input_fragment = recipe_details["input_fragment"] || recipe_details["inputs"][0]["input_fragment"]
+            input_quantity = recipe_details["input_quantity"] || recipe_details["inputs"][0]["input_quantity"]
+
             new_recipe_details = {
               "input_fragment" => recipe_details["output_fragment"],
               "input_quantity" => recipe_details["output_quantity"],
-              "output_fragment" => recipe_details["input_fragment"],
-              "output_quantity" => recipe_details["input_quantity"]
+              "output_fragment" => input_fragment,
+              "output_quantity" => input_quantity
             }
             [recipe_name, new_recipe_details]
           end
           results.to_h
         end
-
-        def apply_recipe(recipe, input_quantity)
-          multiplier, remainder = input_quantity.divmod(recipe["input_quantity"])
-          {
-            recipe: recipe,
-            input_quantity: remainder,
-            output_quantity: multiplier * recipe["output_quantity"]
-          }
-        end
-
-      end
-    end
-  end
-end
+      end # class << self
+    end # module Recipe
+  end # module Packing
+end # module Seshbot

data/lib/seshbot/packing/version.rb

@@ -1,5 +1,5 @@
 module Seshbot
   module Packing
-    VERSION = '0.8.2'
+    VERSION = '0.9.1'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: seshbot-packing
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.9.1
 platform: ruby
 authors:
 - Shaun
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-03-16 00:00:00.000000000 Z
+date: 2021-04-07 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -28,6 +28,7 @@ files:
 - bin/console
 - bin/setup
 - lib/seshbot/packing.rb
+- lib/seshbot/packing/line_item.rb
 - lib/seshbot/packing/package.rb
 - lib/seshbot/packing/recipe.rb
 - lib/seshbot/packing/version.rb