acts_as_fifo_lifo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 82b246066063db6e8bba14109b13951be0b077e767661e60d580143a1083e12e
+  data.tar.gz: da151bdb155f6b43125aae53f3ad31d6834d0c63e08487db8aaa6ad549321178
+SHA512:
+  metadata.gz: ea09a13a508720420749418a33c1d6bf925f966588fd02fc9a9392fe97858a99395ce0d34eee823d02f29f7d33c83039ab302193058f509ebed693abccf1b11d
+  data.tar.gz: 3306b8b63055604ffeb81852a686d1e4db673a7f6a43c64bfd5c59c8095199dbf2e660fc68be1a061ac255f4ad08e1362bb201169b93a00fbabf92080ca3ce2b

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Rem
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,82 @@
+# ActsAsFifoLifo
+
+A Rails gem providing FIFO (First In, First Out) and LIFO (Last In, First Out) inventory calculation methods for ActiveRecord models.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "acts_as_fifo_lifo"
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install acts_as_fifo_lifo
+```
+
+## Usage
+
+Include the module in your ActiveRecord model and configure the field mappings:
+
+```ruby
+class StockTransaction < ApplicationRecord
+  acts_as_fifo_lifo item_field: :item_id,
+    qty_field: :quantity,
+    cost_field: :unit_cost,
+    time_field: :created_at,
+    batch_field: :batch_number,
+    storage_field: :storage_id,
+    operation_field: :operation_id,
+    operation_type_field: :operation_type
+
+end
+```
+
+## Demo application:
+
+[FIFO LIFO Warehouse Application](https://github.com/fatshinobi/fifo_lifo_warehouse)
+
+### Available Methods
+
+#### `get_batches_for(item_id, store_id, qty, time_at, method: "fifo")`
+
+Returns an ordered list of batches needed to satisfy a quantity request.
+
+```ruby
+StockTransaction.get_batches_for(1, 1, 100, Time.current, method: "fifo")
+# => [{ batch_number: "B001", qty: 50, cost: 10.5, batch_time: 2024-01-01 10:00:00 }, ...]
+```
+
+#### `stock_balance_by_batches_calculation(storage_id: nil, item_id: nil, to_time: nil, fields_info: {})`
+
+Returns stock balance grouped by storage, item, and batch in a nested structure.
+
+#### `stock_balance_by_items_calculation(storage_id: nil, item_id: nil, to_time: nil, fields_info: {})`
+
+Returns stock balance grouped by storage and item with mean cost calculation.
+
+#### `stock_movement_calculation(storage_id: nil, item_id: nil, start_time: nil, end_time: nil, fields_info: {})`
+
+Returns stock movement with running balance, grouped by storage, item, and transaction.
+
+#### `stock_balance_for_items(item_id: nil, to_time: nil, limit: nil, fields_info: {})`
+
+Returns an ActiveRecord::Relation with aggregate stock data per item (total_qty and mean_cost).
+
+#### `stock_balance_for_items_calculation(item_id: nil, to_time: nil, fields_info: {})`
+
+Transforms item stock balance records into a structured array format.
+
+## Contributing
+
+Contribution directions go here.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/setup"
+
+require "bundler/gem_tasks"

data/lib/acts_as_fifo_lifo/railtie.rb

@@ -0,0 +1,4 @@
+module ActsAsFifoLifo
+  class Railtie < ::Rails::Railtie
+  end
+end

data/lib/acts_as_fifo_lifo/version.rb

@@ -0,0 +1,3 @@
+module ActsAsFifoLifo
+  VERSION = "0.1.0"
+end

data/lib/acts_as_fifo_lifo.rb

@@ -0,0 +1,387 @@
+require "acts_as_fifo_lifo/version"
+require "acts_as_fifo_lifo/railtie"
+
+module ActsAsFifoLifo
+  extend ActiveSupport::Concern
+
+  class_methods do
+    # Configures FIFO/LIFO behavior field mappings for the model.
+    #
+    # Stores field name mappings as class-level instance variables for use in
+    # FIFO/LIFO calculation methods. All parameters are required keyword arguments.
+    #
+    # @param item_field [Symbol,String] Field name for the item identifier
+    # @param qty_field [Symbol,String] Field name for the quantity
+    # @param cost_field [Symbol,String] Field name for the cost
+    # @param time_field [Symbol,String] Field name for the timestamp
+    # @param batch_field [Symbol,String] Field name for the batch identifier
+    # @param storage_field [Symbol,String] Field name for the storage identifier
+    # @param operation_field [Symbol,String] Field name for the operation identifier
+    # @param operation_type_field [Symbol,String] Field name for the operation type
+    def acts_as_fifo_lifo(item_field:, qty_field:, cost_field:, time_field:, batch_field:, storage_field:, operation_field:, operation_type_field:)
+      @fifo_item_field   = item_field
+      @fifo_qty_field    = qty_field
+      @fifo_cost_field   = cost_field
+      @fifo_time_field   = time_field
+      @fifo_batch_field  = batch_field
+      @fifo_storage_field = storage_field
+      @fifo_operation_field = operation_field
+      @fifo_operation_type_field = operation_type_field
+    end
+
+    # Returns an ordered list of batches needed to satisfy a quantity request.
+    # Each element is a hash with :batch_number, :qty, :cost, and :batch_time keys.
+    #
+    # @param item_id [Integer] the identifier of the item
+    # @param store_id [Integer] the identifier of the storage location
+    # @param qty [Integer] the required quantity
+    # @param time_at [Time,DateTime,String] the reference timestamp for filtering transactions
+    # @param method [String] "fifo" for ascending order or "lifo" for descending order
+    # @return [Array<Hash{batch_number: String, qty: Integer, cost: Float, batch_time: Time}>]
+    def get_batches_for(item_id, store_id, qty, time_at, method: "fifo")
+      base_scope = where(
+        @fifo_item_field => item_id,
+        @fifo_storage_field => store_id
+      )
+
+       order_direction = method == "fifo" ? "ASC" : "DESC"
+
+       batch_records = base_scope
+         .group(@fifo_batch_field)
+         .select(
+           @fifo_batch_field,
+           "SUM(#{@fifo_qty_field}) AS total_qty",
+           "MIN(#{@fifo_cost_field}) AS total_cost",
+           "MIN(#{@fifo_time_field}) AS first_time"
+         )
+         .where("#{@fifo_time_field} <= ?", time_at)
+         .having("SUM(#{@fifo_qty_field}) > 0")
+         .order("first_time #{order_direction}")
+
+       result = []
+       remaining = qty
+
+       batch_records.each do |rec|
+         batch_number = rec.send(@fifo_batch_field)
+         batch_qty = rec.total_qty.to_i
+         batch_cost = rec.total_cost.to_f
+         batch_time = rec.first_time
+
+         take = [ batch_qty, remaining ].min
+          result << { batch_number: batch_number, qty: take, cost: batch_cost.round(2), batch_time: batch_time }
+         remaining -= take
+         break if remaining <= 0
+       end
+
+      result
+    end
+
+    # Calculates stock balance grouped by storage, item and batch.
+    # Returns a nested array of hashes with :details and :children keys.
+    # Each element represents a storage location (Level 1), containing items (Level 2),
+    # which in turn contain batches (Level 3) with their qty and cost.
+    #
+    # @param storage_id [Integer, nil] optional storage location filter
+    # @param item_id [Integer, nil] optional item filter
+    # @param to_time [Time, nil] optional upper bound timestamp for transactions
+    # @param fields_info [Hash] association field configuration for :storages and :items
+    # @return [Array<Hash{details: Hash, children: Array>]: nested structure with storage->items->batches
+    def stock_balance_by_batches_calculation(storage_id: nil, item_id: nil, to_time: nil, fields_info: {})
+      storage_include = fields_info.dig(:storages, :include) || :storage
+      item_include = fields_info.dig(:items, :include) || :item
+      storage_field = fields_info.dig(:storages, :field) || :name
+      item_field = fields_info.dig(:items, :field) || :name
+
+      base_scope = all
+
+      base_scope = base_scope.where(@fifo_storage_field => storage_id) if storage_id.present?
+      base_scope = base_scope.where(@fifo_item_field => item_id) if item_id.present?
+      base_scope = base_scope.where(@fifo_time_field => ...to_time) if to_time.present?
+
+      records = base_scope.group(@fifo_storage_field, @fifo_item_field, @fifo_batch_field)
+        .select(
+          @fifo_storage_field,
+          @fifo_item_field,
+          @fifo_batch_field,
+          "SUM(#{@fifo_qty_field}) AS total_qty",
+          "MIN(#{@fifo_cost_field}) AS batch_cost"
+        )
+
+      records = records.includes(storage_include, item_include)
+
+      nested_records = records.group_by(&@fifo_storage_field.to_sym).transform_values do |storage_group|
+        storage_group.group_by(&@fifo_item_field.to_sym)
+      end
+
+      results = []
+      nested_records.each do |storage_id, items_hash|
+        storage_name = items_hash.first.dig(1, 0)&.send(storage_include)&.send(storage_field) || "Storage #{storage_id}"
+        # Level 1: Storage level
+        storage_hash = { details: { item: storage_name, qty: 0, batch_cost: "", cost: 0 }, children: [] }
+
+        items_hash.each do |item_id, records|
+          item_name = records.first&.send(item_include)&.send(item_field) || "Item #{item_id}"
+
+          # Level 2: Item level
+          item_hash = { details: { item: item_name, qty: 0, batch_cost: "", cost: 0 }, children: [] }
+          item_hash[:details][:cost] = item_hash[:details][:cost].round(2)
+          item_hash[:details][:mean_cost] = item_hash[:details][:mean_cost].round(2) if item_hash[:details][:mean_cost].is_a?(Numeric)
+          storage_hash[:children] << item_hash
+
+          # Level 3: Batch records level (each record contains your select aliases)
+          records.each do |record|
+              batch_cost = record.batch_cost.to_f.round(2)
+              item_hash[:children] << { details: { item: record.batch_number, qty: record.total_qty.to_i, batch_cost: batch_cost, cost: (batch_cost * record.total_qty.to_i).round(2) }, children: [] }
+              item_hash[:details][:qty] += record.total_qty.to_i
+
+              batch_cost = record.batch_cost.to_f.round(2)
+              total_batch_cost = (batch_cost * record.total_qty.to_i).round(2)
+              item_hash[:details][:cost] = (item_hash[:details][:cost] + total_batch_cost).round(2)
+              storage_hash[:details][:qty] += record.total_qty.to_i
+              storage_hash[:details][:cost] = (storage_hash[:details][:cost] + total_batch_cost).round(2)
+          end
+        end
+          storage_hash[:details][:cost] = storage_hash[:details][:cost].round(2)
+          storage_hash[:details][:mean_cost] = storage_hash[:details][:mean_cost].round(2) if storage_hash[:details][:mean_cost].is_a?(Numeric)
+          results << storage_hash
+      end
+      results
+    end
+
+    # Calculates stock balance grouped by storage and item.
+    # Returns a nested array of hashes with :details and :children keys.
+    # Each element represents a storage location containing items with their mean cost.
+    #
+    # @param storage_id [Integer, nil] optional storage location filter
+    # @param item_id [Integer, nil] optional item filter
+    # @param to_time [Time, nil] optional upper bound timestamp for transactions
+    # @param fields_info [Hash] association field configuration for :storages and :items
+    # @return [Array<Hash{details: Hash, children: Array>]: nested structure with storage->items
+    def stock_balance_by_items_calculation(storage_id: nil, item_id: nil, to_time: nil, fields_info: {})
+      storage_include = fields_info.dig(:storages, :include) || :storage
+      item_include = fields_info.dig(:items, :include) || :item
+      storage_field = fields_info.dig(:storages, :field) || :name
+      item_field = fields_info.dig(:items, :field) || :name
+
+      base_scope = all
+
+      base_scope = base_scope.where(@fifo_storage_field => storage_id) if storage_id.present?
+      base_scope = base_scope.where(@fifo_item_field => item_id) if item_id.present?
+      base_scope = base_scope.where(@fifo_time_field => ...to_time) if to_time.present?
+
+      records = base_scope.group(@fifo_storage_field, @fifo_item_field)
+        .select(
+          @fifo_storage_field,
+          @fifo_item_field,
+          "SUM(#{@fifo_qty_field}) AS total_qty",
+          "SUM(#{@fifo_cost_field} * #{@fifo_qty_field}) / SUM(#{@fifo_qty_field}) AS item_cost"
+        )
+
+       records = records.includes(storage_include, item_include)
+       results = []
+
+       nested = records.group_by(&@fifo_storage_field.to_sym).transform_values do |storage_group|
+         storage_group.group_by(&@fifo_item_field.to_sym)
+       end
+
+       nested.each do |storage_id, items_hash|
+         first_record = items_hash.values.first.first
+         storage_name = first_record&.send(storage_include)&.send(storage_field) || "Storage #{storage_id}"
+
+         storage_hash = { details: { item: storage_name, qty: 0, mean_cost: "", cost: 0.0 }, children: [] }
+
+         items_hash.each do |item_id, recs|
+           first_item = recs.first
+           item_name = first_item&.send(item_include)&.send(item_field) || "Item #{item_id}"
+           item_hash = { details: { item: item_name, qty: 0, mean_cost: 0.0, cost: 0.0 }, children: [] }
+
+           recs.each do |record|
+             qty = record.total_qty.to_i
+             cost_per = record.item_cost.to_f
+             total_cost = (qty * cost_per).round(2)
+             item_hash[:details][:qty] += qty
+             item_hash[:details][:cost] += total_cost
+             if item_hash[:details][:qty] > 0
+                mean = item_hash[:details][:cost] / item_hash[:details][:qty]
+                item_hash[:details][:mean_cost] = mean.round(2)
+             end
+             storage_hash[:details][:qty] += qty
+              storage_hash[:details][:cost] += total_cost
+           end
+
+           storage_hash[:children] << item_hash
+         end
+
+         results << storage_hash
+       end
+
+       results
+    end
+
+    # Calculates stock movement returning a three-level nested structure.
+    # Groups by storage (Level 1), then by item (Level 2), then by batch/transaction (Level 3).
+    # Each transaction record includes running balance computed from the initial balance plus
+    # all preceding transactions in chronological order.
+    #
+    # @param storage_id [Integer, nil] optional storage location filter
+    # @param item_id [Integer, nil] optional item filter
+    # @param start_time [Time, nil] lower bound timestamp for transactions
+    # @param end_time [Time, nil] upper bound timestamp for transactions
+    # @param fields_info [Hash] association field configuration for :storages and :items
+    # @return [Array<Hash{details: Hash, children: Array>]: nested structure with storage->items->transactions
+    def stock_movement_calculation(storage_id: nil, item_id: nil, start_time: nil, end_time: nil, fields_info: {})
+      storage_include = fields_info.dig(:storages, :include) || :storage
+      item_include = fields_info.dig(:items, :include) || :item
+      storage_field = fields_info.dig(:storages, :field) || :name
+      item_field = fields_info.dig(:items, :field) || :name
+
+      balances = balance_for(start_time, item_id = item_id, store_id = storage_id)
+
+      base_scope = all
+      base_scope = base_scope.where(@fifo_storage_field => storage_id) if storage_id.present?
+      base_scope = base_scope.where(@fifo_item_field => item_id) if item_id.present?
+      base_scope = base_scope.where(@fifo_time_field => start_time..end_time) if start_time.present? && end_time.present?
+
+      records = base_scope
+        .select(
+          @fifo_storage_field,
+          @fifo_item_field,
+          @fifo_batch_field,
+          @fifo_time_field,
+          @fifo_qty_field,
+          @fifo_cost_field,
+          @fifo_operation_field,
+          @fifo_operation_type_field
+        )
+        .order(@fifo_time_field => :asc)
+
+      records = records.includes(storage_include, item_include)
+
+      nested = records.group_by(&@fifo_storage_field.to_sym).transform_values do |storage_group|
+        storage_group.group_by(&@fifo_item_field.to_sym)
+      end
+
+      results = []
+      nested.each do |storage_id_key, items_hash|
+        first_record = items_hash.values.first.first
+        storage_name = first_record&.send(storage_include)&.send(storage_field) || "Storage #{storage_id_key}"
+        storage_hash = { details: { item: storage_name, time: "", operation: "", qty: 0, cost: "", balance: 0 }, children: [] }
+
+        items_hash.each do |item_id_key, recs|
+          first_item = recs.first
+          item_name = first_item&.send(item_include)&.send(item_field) || "Item #{item_id_key}"
+          item_balance = balances[[ item_id_key, storage_id_key ]] || 0
+          item_hash = { details: { item: item_name, time: "", operation: "", qty: 0, cost: "", balance: item_balance }, children: [] }
+
+          running_balance = item_balance
+          recs.each do |record|
+            qty = record.send(@fifo_qty_field).to_i
+            cost = record.send(@fifo_cost_field).to_f
+            running_balance += qty
+
+              item_hash[:children] << {
+                details: {
+                  item: record.send(@fifo_batch_field),
+                  time: record.send(@fifo_time_field).strftime("%F %T"),
+                  operation: "#{record.send(@fifo_operation_type_field)} ##{record.send(@fifo_operation_field)}",
+                  qty: qty,
+                  cost: cost.round(2),
+                  balance: running_balance
+                },
+                children: []
+              }
+
+            item_hash[:details][:qty] += qty
+          end
+
+          storage_hash[:children] << item_hash
+
+          storage_hash[:details][:qty] += item_hash[:details][:qty]
+          storage_hash[:details][:balance] += item_hash[:details][:balance]
+        end
+
+        results << storage_hash
+      end
+      results
+    end
+
+    # Computes initial stock balances for items at a given point in time.
+    # Returns a hash mapping [item_id, storage_id] pairs to their balance quantities.
+    #
+    # @param to_time [Time] the reference timestamp for the balance calculation
+    # @param item_id [Integer, nil] optional item filter
+    # @param store_id [Integer, nil] optional storage location filter
+    # @return [Hash{Array<item_id, storage_id> => Integer] mapping of item-storage pairs to quantities
+    def balance_for(to_time, item_id = nil, store_id = nil)
+      item_scope = item_id.present? ? where(@fifo_item_field => item_id) : all
+      store_scope = store_id.present? ? item_scope.where(@fifo_storage_field => store_id) : item_scope
+
+      result = store_scope
+        .where("#{@fifo_time_field} <= ?", to_time)
+        .group(@fifo_storage_field, @fifo_item_field)
+        .select(
+          @fifo_storage_field,
+          @fifo_item_field,
+          "SUM(#{@fifo_qty_field}) AS total_qty"
+        )
+
+      result.each_with_object({}) do |record, hash|
+        item_id_key = record.send(@fifo_item_field)
+        store_id_key = record.send(@fifo_storage_field)
+        hash[[ item_id_key, store_id_key ]] = record.total_qty.to_i
+      end
+    end
+
+    # Queries aggregate stock data for items using mean cost calculation.
+    # Returns an ActiveRecord::Relation with total_qty and mean_cost selected per item.
+    #
+    # @param item_id [Integer, nil] optional item filter
+    # @param to_time [Time, nil] optional upper bound timestamp for transactions
+    # @param limit [Integer, nil] optional limit on number of results
+    # @param fields_info [Hash] association field configuration for :items
+    # @return [ActiveRecord::Relation] query scope for further chaining or execution
+    def stock_balance_for_items(item_id: nil, to_time: nil, limit: nil, fields_info: {})
+      scope = all
+      scope = scope.where(@fifo_item_field => item_id) if item_id.present?
+      scope = scope.where("#{@fifo_time_field} <= ?", to_time) if to_time.present?
+      scope = scope.group(@fifo_item_field)
+        .select(
+          @fifo_item_field,
+          "SUM(#{@fifo_qty_field}) AS total_qty",
+          "SUM(#{@fifo_cost_field} * #{@fifo_qty_field}) / SUM(#{@fifo_qty_field}) AS mean_cost"
+        )
+      scope = scope.order("total_qty DESC")
+      item_include = fields_info.dig(:items, :include) || :item
+
+      scope = scope.includes(item_include)
+      scope = scope.limit(limit) if limit.present?
+      scope
+    end
+
+    # Transforms item stock balance records into a structured format.
+    # Wraps each item's data in a :details/:children hash structure.
+    #
+    # @param item_id [Integer, nil] optional item filter
+    # @param to_time [Time, nil] optional upper bound timestamp for transactions
+    # @param fields_info [Hash] association field configuration for :items
+    # @return [Array<Hash{details: Hash, children: Array>]: array of item summaries with qty and mean_cost
+    def stock_balance_for_items_calculation(item_id: nil, to_time: nil, fields_info: {})
+      records = stock_balance_for_items(item_id: item_id, to_time: to_time, fields_info: fields_info)
+      item_include = fields_info.dig(:items, :include) || :item
+      item_field = fields_info.dig(:items, :field) || :name
+
+      records.map do |record|
+        {
+          details: {
+            item: record.send(item_include)&.send(item_field),
+            qty: record.total_qty,
+            cost: record.mean_cost.round(2)
+          },
+          children: []
+        }
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, ActsAsFifoLifo

data/lib/tasks/acts_as_fifo_lifo_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :acts_as_fifo_lifo do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: acts_as_fifo_lifo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rem
+bindir: bin
+cert_chain: []
+date: 2026-05-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.1.3
+description: A Rails gem for handling FIFO (First-In, First-Out) and LIFO (Last-In,
+  First-Out) inventory management operations.
+email:
+- r3mnik@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/acts_as_fifo_lifo.rb
+- lib/acts_as_fifo_lifo/railtie.rb
+- lib/acts_as_fifo_lifo/version.rb
+- lib/tasks/acts_as_fifo_lifo_tasks.rake
+homepage: https://github.com/fatshinobi/acts_as_fifo_lifo/tree/main
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/fatshinobi/acts_as_fifo_lifo/tree/main
+  source_code_uri: https://github.com/fatshinobi/acts_as_fifo_lifo/tree/main
+  changelog_uri: https://github.com/fatshinobi/acts_as_fifo_lifo/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Gem to process FIFO & LIFO operations in inventory management.
+test_files: []