seshbot-packing 0.8.5 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1df1737c878348a458089c20c950a5a2c0a8fdd501736904f8a4c89cc83e92ad
-  data.tar.gz: bb96a3429acfbda5e066652600df576f6cf3a0a4e303ee3c6a68a1841eb984e8
+  metadata.gz: 81b8dec69884aa8fe05b60a8541246a1c7c72876a0a1e5870baa5c017797097e
+  data.tar.gz: b2df5af90b433af11660e0c73827a4f0be65d35e6abe0fec7a402ede54dd77d6
 SHA512:
-  metadata.gz: 8557f78b9e1092f5ea8d776399d2ebc9b1163cd184a45e28482abf2635788b57e27f7dc6fd7d32e7b6b013eb62f86dddb71f3ff64c77f74e71c36278a24e6403
-  data.tar.gz: 52d32265eedae66704b42a43a6183a47bf4268007b463a6cc2529cc291b09c10ef5353b15b725add93931d7f273053fbfc46700a70e43091218b8106017f9e4d
+  metadata.gz: c52c6926758c54f7eaf8465e5b95c9357cdb1210b36d00d9ae2b11d02824a5e5d63b686eac9b60b4c77d044f5f6348bc8dcb7472e34adceb2c11721b335ff3c1
+  data.tar.gz: d4213856cfdc2364c24f05b447ababaa6c4003d195f78d083bbd4d735a5986f56911e93c6793d8f12817360e4f8170177a1e1aafe27d1b0e436a07bf70ff242a

data/.gitignore

@@ -9,3 +9,12 @@
 /spec/reports/
 /tmp/
 *.gem
+
+# Ignore all logfiles and tempfiles.
+/log/*
+!/log/.keep
+!/tmp/.keep
+
+.idea/
+.DS_Store
+ngrok

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.5)
+    seshbot-packing (0.9.3)
 
 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,148 +5,194 @@ module Seshbot
   module Packing
     class Error < StandardError; end
     class << self
+      @@logger = nil
       def logger
-        logger = Logger.new(STDERR)
-        logger.level = 1
-        logger
+        if @@logger.nil?
+          if defined?(Rails)
+            @@logger = Rails.logger
+          else
+            @@logger = Logger.new(STDERR)
+            @@logger.level = 1
+          end
+        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 "bundling - 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 - Bundling Items: #{items.map(&:to_s)}. Fulfilled at: #{fulfilled_at || '(no fulfillment date)'}#{is_legacy_str}"
+
+        results = []
+
+        if is_legacy
+          results = _bundle_items_legacy(recipes, items)
+        else
+          phases = recipes.values.map { |r| r['phase'] || 0 }.map(&:to_i).uniq.sort
 
-      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 = 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 "bundling - Bundled result:"
+        logger.debug " - IN: #{items.map(&:to_s)}"
+        logger.debug " - OUT: #{results.map(&:to_s)}"
+
+        results
       end
 
-      def packaged_size(sku)
-        size_regex = /-(K?[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 unbundle_items(recipes, items, fulfilled_at: nil)
+        logger.debug "bundling - Unbundling Items: #{items.map(&:to_s)}"
 
-        # this is everything inside the (..) in the regex (everything except the leading '-')
-        result = match.captures[0]
-        # HACK! for legacy reasons, we don't consider K to be part of the size.
-        result.gsub!(/^K/, '')
+        results = []
 
-        if result == "B502"
-          result = "B306"
-        end
-        if result == "B504"
-          result = "B312"
+        phases = recipes.values.map { |r| r['phase'] || 0 }.map(&:to_i).uniq.sort.reverse
+
+        results = items
+        phases.each do |phase|
+          phase_recipes = recipes.select { |name, recipe| (recipe['phase'] || 0) == phase }.to_h
+
+          logger.debug "bundling - PHASE #{phase}"
+
+          # get a list of items merged together by variant type (e.g., 10xBIGI-C301 + 5xBISS-C301 => 15xBUND-C301))
+          merged_items = LineItem.merge_line_items(results)
+          results = unpack(recipes, merged_items)
         end
-        raise "Cannot determine packaged size for SKU: #{sku}" if result.nil?
 
-        result
+        logger.debug "bundling - Unbundle result:"
+        logger.debug " - IN: #{items.map(&:to_s)}"
+        logger.debug " - OUT: #{results.map(&:to_s)}"
+
+        results
       end
 
-      def bundle_items(recipes, 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 unpack(recipes, items)
+        prev_result = items
+
+        (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
+
+          prev_result = new_result
+        end
+        error_message = "bundling - could not unpack - infinite loop? (latest: #{prev_result.map(&:to_s)})"
+        logger.error error_message
+        raise error_message
+      end
+
+      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 = "bundling - 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-23T08: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(recipes, product_type_counts)
-          product_type_counts = pack(recipes, 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 "bundling - 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 "bundling - Substituting:"
+        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(recipes, 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(recipes, 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
-
-
-      def unpack(recipes, product_type_counts)
-        final_result = product_type_counts
-
-        while true
-          new_result = pack_single_step(recipes, final_result, unpacking: true)
-          break if new_result == final_result
+        results = new_remaining_items + separated_c324s
 
-          final_result = new_result
-        end
-        final_result
+        results
       end
 
-      def pack_single_step(recipes, product_type_counts, unpacking:)
-        result = Hash.new(0)
-        product_type_counts.each do |sku_fragment, qty|
-          recipe = Recipe::find_best_recipe(recipes, 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(recipes, 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(recipes, 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 "bundling - 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,59 +2,146 @@ module Seshbot
   module Packing
     module Recipe
       class << self
-        def find_best_recipe(recipes_hash, sku_fragment, qty, unpacking: false)
-          recipes = find_recipes(recipes_hash, sku_fragment, qty, unpacking: unpacking)
+        def find_best_recipe(recipes_hash, items, unpacking: false)
+          recipes = _find_recipes(recipes_hash, items, 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)
+          best_recipe = nil
+          best_recipe_output_quantity = nil
+          best_recipe_inputs_quantity = nil
+          recipes.each do |recipe_name, recipe|
+            recipe_inputs = recipe['inputs'].nil? ? [recipe] : recipe['inputs']
 
-            # if there was no 'best' until now, just set it (makes the next step a bit simpler)
-            best_recipe_quantities ||= recipe_quantities
+            recipe_factor = _calculate_recipe_factor(recipe, items)
+            recipe_output_quantity = recipe_factor * recipe['output_quantity']
+            recipe_inputs_quantity = recipe_factor * recipe_inputs.map { |r| r['input_quantity'] }.sum
 
             # 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
+              #
+              # the below code uses output as the main feature, but if they are equal uses the number of inputs
+              #
+
+              output_equal = recipe_output_quantity == best_recipe_output_quantity
+
+              # when packing, fewer outputs are better
+              output_better = unpacking ?
+                  recipe_output_quantity > best_recipe_output_quantity :
+                  recipe_output_quantity < best_recipe_output_quantity
+
+              # when packing, more inputs are better
+              inputs_better = unpacking ?
+                  recipe_inputs_quantity < best_recipe_inputs_quantity :
+                  recipe_inputs_quantity > best_recipe_inputs_quantity
+
+              output_equal ? inputs_better : output_better
+            end
 
             if is_best
-              best_recipe_quantities = recipe_quantities
+              best_recipe_output_quantity = recipe_output_quantity
+              best_recipe_inputs_quantity = recipe_inputs_quantity
+              best_recipe = recipe
             end
           end
-          best_recipe_quantities[:recipe] if best_recipe_quantities
+          best_recipe
+        end
+
+        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
+
+          # now add input
+          results << LineItem.new(recipe['output_fragment'], recipe['output_quantity'] * factor)
+
+          # consolidate 
+          results = LineItem.merge_line_items(results)
+        end
+
+        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, sku_fragment, qty, unpacking: false)
-          recipes = reverse_recipes(recipes) if unpacking
-          recipes.select do |name, recipe|
-            recipe["input_fragment"] == sku_fragment && qty >= recipe["input_quantity"]
+        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
-          # recipes.select { |name, recipe| recipe[:input_fragment] == sku_fragment && qty >= recipe[:input_quantity] }
         end
 
-        def reverse_recipes(recipes)
-          results = recipes.map do |recipe_name, recipe_details|
+        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.5'
+    VERSION = '0.9.4'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: seshbot-packing
 version: !ruby/object:Gem::Version
-  version: 0.8.5
+  version: 0.9.4
 platform: ruby
 authors:
 - Shaun
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-03-29 00:00:00.000000000 Z
+date: 2021-04-22 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