physical 0.4.8 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45adbe9fa036b31165e380d114a9742467b551368e2a2dfc720452f2fba97e4c
-  data.tar.gz: 351f94658f866fe313b7499bcacef7de4a00c8370587dbbde9d81b093f6dd04d
+  metadata.gz: 03d9eb10ac73675e3aa2bac745e7a6d8a30f4b9c0c6cb810d4dac0235d0cc55f
+  data.tar.gz: ed902ddd5a9349009a43d0a883a5526f7097d759e742c6ff43b8baf904765f63
 SHA512:
-  metadata.gz: 7fd937c2f74862b1d28a0f819622e8d7a29b141bca24b175707adea171ef1a7e95f86494757fe32d9d24088356ebc31967688a0b1c6b895171f0e5a746fd4e35
-  data.tar.gz: df819d350b08f636b8afd2d56294982564f2662205b091b429fd58cc1d1c7db507a385a04966b2c153c336ae5eb46887ae1f9f226267ae227db21a69ef2ecb36
+  metadata.gz: 52d08252ebda560e9abf682eb011c5e2281afbf0c3eead4acc650b9af8714555f465ffc9c613318eb2bed9e86caf72edddde1ad8edb5f26aea2233b7ebc38b96
+  data.tar.gz: cfdb971e4bdf9d1ce7c830b8f6da93614e630251ca7307f91baddf05353f43e1c1ef51aa84dc3db505ffb8221bf7fde68ee1e6348462e4fd9cacc9c820c2efb8

data/CHANGELOG.md

@@ -6,6 +6,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+## [0.5.0] - 2023-12-19
+
+### Added
+- Introduce `Physical::Structure` class [#31]
+
+### Changed
+- Use legitimate state/zip in location factory [#30]
+
+## [0.4.9] - 2023-08-02
+
+### Added
+- Extract cuboid property handling into mixin [#25]
+- Add properties to `Physical::Location` [#26]
+- Add pallets to `Physical::Shipment` [#29]
+
+### Changed
+- Faster package weight and volume calculations [#23]
+
 ## [0.4.8] - 2023-03-21
 
 ### Added

data/lib/physical/cuboid.rb

@@ -4,6 +4,8 @@ require 'measured'
 
 module Physical
   class Cuboid
+    include PropertyReaders
+
     attr_reader :dimensions, :length, :width, :height, :weight, :id, :properties
 
     def initialize(id: nil, dimensions: [], weight: Measured::Weight(0, :g), properties: {})
@@ -33,27 +35,6 @@ module Physical
 
     private
 
-    NORMALIZED_METHOD_REGEX = /(\w+)\??$/.freeze
-
-    def method_missing(method)
-      symbolized_properties = properties.symbolize_keys
-      method_name = normalize_method_name(method)
-      if symbolized_properties.key?(method_name)
-        symbolized_properties[method_name]
-      else
-        super
-      end
-    end
-
-    def respond_to_missing?(method, *args)
-      method_name = normalize_method_name(method)
-      properties.symbolize_keys.key?(method_name) || super
-    end
-
-    def normalize_method_name(method)
-      method.to_s.sub(NORMALIZED_METHOD_REGEX, '\1').to_sym
-    end
-
     def fill_dimensions(dimensions)
       dimensions.fill(dimensions.length..2) do |index|
         @dimensions[index] || Measured::Length(self.class::DEFAULT_LENGTH, :cm)

data/lib/physical/location.rb

@@ -4,6 +4,8 @@ require 'carmen'
 
 module Physical
   class Location
+    include PropertyReaders
+
     ADDRESS_TYPES = %w(residential commercial po_box).freeze
 
     attr_reader :country,
@@ -20,7 +22,8 @@ module Physical
                 :address_type,
                 :company_name,
                 :latitude,
-                :longitude
+                :longitude,
+                :properties
 
     def initialize(
       name: nil,
@@ -37,7 +40,8 @@ module Physical
       email: nil,
       address_type: nil,
       latitude: nil,
-      longitude: nil
+      longitude: nil,
+      properties: {}
     )
 
       @country = if country.is_a?(Carmen::Country)
@@ -65,6 +69,7 @@ module Physical
       @address_type = address_type
       @latitude = latitude
       @longitude = longitude
+      @properties = properties
     end
 
     def residential?

data/lib/physical/package.rb

@@ -3,24 +3,32 @@
 module Physical
   class Package
     extend Forwardable
-    attr_reader :container, :items, :void_fill_density, :id
+    attr_reader :id, :container, :items, :void_fill_density, :items_weight, :used_volume, :description
 
-    def initialize(id: nil, container: nil, items: [], void_fill_density: Measured::Density(0, :g_ml), dimensions: nil, weight: nil, properties: {})
+    def initialize(id: nil, container: nil, items: [], void_fill_density: Measured::Density(0, :g_ml), dimensions: nil, weight: nil, description: nil, properties: {})
       @id = id || SecureRandom.uuid
       @void_fill_density = Types::Density[void_fill_density]
       @container = container || Physical::Box.new(dimensions: dimensions || [], weight: weight || Measured::Weight(0, :g), properties: properties)
+      @description = description
+
       @items = Set[*items]
+      @items_weight = @items.map(&:weight).reduce(Measured::Weight(0, :g), &:+)
+      @used_volume = @items.map(&:volume).reduce(Measured::Volume(0, :ml), &:+)
     end
 
     delegate [:dimensions, :width, :length, :height, :properties, :volume] => :container
 
     def <<(other)
       @items.add(other)
+      @items_weight += other.weight
+      @used_volume += other.volume
     end
     alias_method :add, :<<
 
     def >>(other)
       @items.delete(other)
+      @items_weight -= other.weight
+      @used_volume -= other.volume
     end
     alias_method :delete, :>>
 
@@ -29,29 +37,19 @@ module Physical
     end
 
     # Cost is optional. We will only return an aggregate if all items
-    # have cost defined. Otherwise we will retun nil.
+    # have cost defined. Otherwise we will return nil.
     # @return Money
     def items_value
       items_cost = items.map(&:cost)
       items_cost.reduce(&:+) if items_cost.compact.size == items_cost.size
     end
 
-    # @return [Measured::Weight]
-    def items_weight
-      items.map(&:weight).reduce(Measured::Weight(0, :g), &:+)
-    end
-
     def void_fill_weight
       return Measured::Weight(0, :g) if container.volume.value.infinite?
 
       Measured::Weight(void_fill_density.convert_to(:g_ml).value * remaining_volume.convert_to(:ml).value, :g)
     end
 
-    # @return [Measured::Volume]
-    def used_volume
-      items.map(&:volume).reduce(Measured::Volume(0, :ml), &:+)
-    end
-
     def remaining_volume
       container.inner_volume - used_volume
     end

data/lib/physical/property_readers.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Physical
+  module PropertyReaders
+    private
+
+    NORMALIZED_METHOD_REGEX = /(\w+)\??$/.freeze
+
+    def method_missing(method)
+      symbolized_properties = properties.symbolize_keys
+      method_name = normalize_method_name(method)
+      if symbolized_properties.key?(method_name)
+        symbolized_properties[method_name]
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, *args)
+      method_name = normalize_method_name(method)
+      properties.symbolize_keys.key?(method_name) || super
+    end
+
+    def normalize_method_name(method)
+      method.to_s.sub(NORMALIZED_METHOD_REGEX, '\1').to_sym
+    end
+  end
+end

data/lib/physical/shipment.rb

@@ -6,16 +6,24 @@ module Physical
                 :origin,
                 :destination,
                 :service_code,
+                :pallets,
+                :structures,
                 :packages,
                 :options
 
-    def initialize(id: nil, origin: nil, destination: nil, service_code: nil, packages: [], options: {})
+    def initialize(id: nil, origin: nil, destination: nil, service_code: nil, pallets: [], structures: [], packages: [], options: {})
       @id = id || SecureRandom.uuid
       @origin = origin
       @destination = destination
       @service_code = service_code
+      @structures = structures
       @packages = packages
       @options = options
+
+      return unless pallets.any?
+
+      warn "[DEPRECATION] `pallets` is deprecated.  Please use `structures` instead."
+      @pallets = pallets
     end
   end
 end

data/lib/physical/spec_support/factories/location_factory.rb

@@ -4,16 +4,17 @@ FactoryBot.define do
   factory :physical_location, class: 'Physical::Location' do
     transient do
       country_code { 'US' }
-      region_code { 'IL' }
+      region_code { 'VA' }
     end
 
     name { 'Jane Doe' }
     company_name { 'Company' }
     address1 { '11 Lovely Street' }
-    address2 { 'South' }
+    address2 { 'Suite 100' }
     city { 'Herndon' }
-    sequence(:zip, 10_001, &:to_s)
+    zip { '20170' }
     phone { '555-555-0199' }
+    email { 'jane@company.com' }
     region { country.subregions.coded(region_code) }
     country { Carmen::Country.coded(country_code) }
     initialize_with { new(**attributes) }

data/lib/physical/spec_support/factories/shipment_factory.rb

@@ -4,8 +4,14 @@ FactoryBot.define do
   factory :physical_shipment, class: "Physical::Shipment" do
     origin { FactoryBot.build(:physical_location) }
     destination { FactoryBot.build(:physical_location) }
+    pallets { build_list(:physical_pallet, 1) } # deprecated, will be removed
     packages { build_list(:physical_package, 2) }
     service_code { "usps_priority_mail" }
     initialize_with { new(**attributes) }
+
+    trait :freight do
+      structures { build_list(:physical_structure, 1) }
+      service_code { "tforce_freight" }
+    end
   end
 end

data/lib/physical/spec_support/factories/structure_factory.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :physical_structure, class: "Physical::Structure" do
+    container { FactoryBot.build(:physical_pallet) }
+    packages { build_list(:physical_package, 2) }
+    initialize_with { new(**attributes) }
+  end
+end

data/lib/physical/spec_support/shared_examples/a_cuboid.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "a cuboid" do
+  subject(:cuboid) { described_class.new(**args) }
+
+  it_behaves_like "has property readers"
+
+  let(:args) do
+    {
+      dimensions: [
+        Measured::Length.new(1.1, :cm),
+        Measured::Length.new(3.3, :cm),
+        Measured::Length.new(2.2, :cm)
+      ]
+    }
+  end
+
+  it { is_expected.to be_a(Physical::Cuboid) }
+  it { is_expected.to respond_to(:id) }
+
+  describe "#dimensions" do
+    subject(:dimensions) { cuboid.dimensions }
+
+    it "has dimensions as Measured::Length objects with rational values" do
+      expect(dimensions).to eq(
+        [
+          Measured::Length.new(1.1, :cm),
+          Measured::Length.new(3.3, :cm),
+          Measured::Length.new(2.2, :cm)
+        ]
+      )
+    end
+
+    context "when given a one-element dimensions array" do
+      let(:args) do
+        {
+          dimensions: [Measured::Length(2, :cm)]
+        }
+      end
+
+      specify "the other dimensions are filled up with default length" do
+        expect(dimensions).to eq(
+          [
+            Measured::Length.new(2, :cm),
+            Measured::Length.new(default_length, :cm),
+            Measured::Length.new(default_length, :cm)
+          ]
+        )
+      end
+    end
+
+    context "when given a two-element dimensions array" do
+      let(:args) do
+        {
+          dimensions: [1, 2].map { |d| Measured::Length(d, :cm) }
+        }
+      end
+
+      it "the last dimension is filled up with default length" do
+        expect(dimensions).to eq(
+          [
+            Measured::Length.new(1, :cm),
+            Measured::Length.new(2, :cm),
+            Measured::Length.new(default_length, :cm)
+          ]
+        )
+      end
+    end
+
+    context "when given no arguments" do
+      let(:args) { {} }
+
+      it "assumes cm as the dimension_unit and the default length as value" do
+        expect(dimensions).to eq(
+          [
+            Measured::Length.new(default_length, :cm),
+            Measured::Length.new(default_length, :cm),
+            Measured::Length.new(default_length, :cm)
+          ]
+        )
+      end
+    end
+  end
+
+  describe "dimension methods" do
+    it "has getter methods for each dimension as Measured::Length object" do
+      expect(cuboid.length).to eq(Measured::Length.new(1.1, :cm))
+      expect(cuboid.width).to eq(Measured::Length.new(3.3, :cm))
+      expect(cuboid.height).to eq(Measured::Length.new(2.2, :cm))
+    end
+  end
+
+  describe "#weight" do
+    subject(:weight) { cuboid.weight }
+
+    context "with no weight given" do
+      let(:args) { {} }
+      it { is_expected.to eq(Measured::Weight(0, :g)) }
+    end
+
+    context "with a weight" do
+      let(:args) { { weight: Measured::Weight(1, :lb) } }
+      it { is_expected.to eq(Measured::Weight(453.59237, :g)) }
+    end
+  end
+
+  describe "#volume" do
+    subject(:volume) { cuboid.volume }
+
+    context "if all three dimensions are given" do
+      let(:args) do
+        {
+          dimensions: [1.1, 2.1, 3.2].map { |d| Measured::Length(d, :cm) }
+        }
+      end
+
+      it { is_expected.to eq(Measured::Volume(7.392, :ml)) }
+    end
+
+    context "if a dimension is missing" do
+      let(:args) do
+        {
+          dimensions: [1.1, 2.1].map { |d| Measured::Length(d, :cm) }
+        }
+      end
+
+      it { is_expected.to eq(Measured::Volume(default_length, :ml)) }
+    end
+  end
+
+  describe "#density" do
+    subject(:density) { cuboid.density.value.to_f }
+
+    let(:args) do
+      {
+        dimensions: dimensions,
+        weight: weight
+      }
+    end
+
+    context "if volume is larger than 0" do
+      let(:dimensions) do
+        [1.1, 2.1, 3.2].map { |d| Measured::Length(d, :in) }
+      end
+
+      context "if weight is 1" do
+        let(:weight) { Measured::Weight(1, :pound) }
+
+        it "returns the density in gramms per cubiq centimeter (ml)" do
+          is_expected.to eq(3.7445758536530196)
+        end
+      end
+
+      context "if weight is 0" do
+        let(:weight) { Measured::Weight(0, :pound) }
+
+        it { is_expected.to eq(0.0) }
+      end
+    end
+
+    context "if volume is 0" do
+      let(:dimensions) do
+        [1.1, 2.1].map { |d| Measured::Length(d, :in) }
+      end
+
+      let(:weight) { Measured::Weight(1, :pound) }
+      let(:expected_volume) { default_length.zero? ? BigDecimal::INFINITY : 0 }
+
+      it { is_expected.to eq(expected_volume) }
+    end
+
+    context "if volume is infinite" do
+      let(:dimensions) do
+        [1.1, 2.1].map { |d| Measured::Length(d, :in) }
+      end
+
+      let(:weight) { Measured::Weight(1, :pound) }
+      let(:expected_volume) { default_length.zero? ? BigDecimal::INFINITY : 0 }
+
+      it { is_expected.to eq(expected_volume) }
+    end
+  end
+
+  describe "#==" do
+    let(:args) { Hash[id: 123] }
+    let(:other_cuboid) { described_class.new(**args) }
+    let(:non_cuboid) { double(id: 123) }
+
+    it "compares cuboids" do
+      aggregate_failures do
+        expect(cuboid == other_cuboid).to be(true)
+        expect(cuboid == non_cuboid).to be(false)
+        expect(cuboid.nil?).to be(false)
+      end
+    end
+  end
+end

data/lib/physical/spec_support/shared_examples/has_property_readers.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'has property readers' do
+  subject(:instance) { described_class.new(**args) }
+
+  describe "#properties" do
+    subject(:properties) { instance.properties }
+
+    let(:args) do
+      {
+        properties: { flammable: true }
+      }
+    end
+
+    it { is_expected.to eq({ flammable: true }) }
+  end
+
+  describe "properties methods" do
+    context "if method is a property" do
+      let(:args) do
+        {
+          properties: { already_packaged: true }
+        }
+      end
+
+      it "returns its value" do
+        expect(instance.already_packaged).to be(true)
+      end
+
+      it { is_expected.to respond_to(:already_packaged?) }
+    end
+
+    context "if method is a string property" do
+      let(:args) do
+        {
+          properties: { "already_packaged" => true }
+        }
+      end
+
+      it "returns its value" do
+        expect(instance.already_packaged).to be(true)
+      end
+
+      it { is_expected.to respond_to(:already_packaged?) }
+    end
+
+    context "if method is a boolean property" do
+      let(:args) do
+        {
+          properties: { already_packaged: true }
+        }
+      end
+
+      it "it is also accessible by its predicate method" do
+        expect(instance.already_packaged?).to be(true)
+      end
+
+      it { is_expected.to respond_to(:already_packaged?) }
+
+      context "with a falsey value" do
+        let(:args) do
+          {
+            properties: { already_packaged: false }
+          }
+        end
+
+        it "returns its value" do
+          expect(instance.already_packaged).to be(false)
+        end
+      end
+    end
+
+    context "if method is not a property" do
+      let(:args) do
+        {
+          properties: {}
+        }
+      end
+
+      it "raises method missing" do
+        expect { instance.already_packaged? }.to raise_error(NoMethodError)
+      end
+
+      it { is_expected.not_to respond_to(:already_packaged?) }
+    end
+  end
+end

data/lib/physical/spec_support/shared_examples.rb

@@ -1,45 +1,4 @@
 # frozen_string_literal: true
 
-RSpec.shared_examples 'a cuboid' do
-  let(:args) do
-    {
-      dimensions: [
-        Measured::Length.new(1.1, :cm),
-        Measured::Length.new(3.3, :cm),
-        Measured::Length.new(2.2, :cm)
-      ]
-    }
-  end
-
-  it { is_expected.to be_a(Physical::Cuboid) }
-
-  it "has dimensions as Measured::Length objects with rational values" do
-    expect(subject.dimensions).to eq(
-      [
-        Measured::Length.new(1.1, :cm),
-        Measured::Length.new(3.3, :cm),
-        Measured::Length.new(2.2, :cm)
-      ]
-    )
-  end
-
-  it "has getter methods for each dimension as Measured::Length object" do
-    expect(subject.length).to eq(Measured::Length.new(1.1, :cm))
-    expect(subject.width).to eq(Measured::Length.new(3.3, :cm))
-    expect(subject.height).to eq(Measured::Length.new(2.2, :cm))
-  end
-
-  describe "#==" do
-    let(:args) { Hash[id: 123] }
-    let(:other_cuboid) { described_class.new(**args) }
-    let(:non_cuboid) { double(id: 123) }
-
-    it "compares cuboids" do
-      aggregate_failures do
-        expect(subject == other_cuboid).to be(true)
-        expect(subject == non_cuboid).to be(false)
-        expect(subject.nil?).to be(false)
-      end
-    end
-  end
-end
+require "physical/spec_support/shared_examples/a_cuboid"
+require "physical/spec_support/shared_examples/has_property_readers"

data/lib/physical/structure.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Physical
+  class Structure
+    extend Forwardable
+    attr_reader :id, :container, :packages, :packages_weight, :used_volume
+
+    def initialize(id: nil, container: nil, packages: [], dimensions: nil, weight: nil, properties: {})
+      @id = id || SecureRandom.uuid
+      @container = container || Physical::Pallet.new(dimensions: dimensions || [], weight: weight || Measured::Weight(0, :g), properties: properties)
+
+      @packages = Set[*packages]
+      @packages_weight = @packages.map(&:weight).reduce(Measured::Weight(0, :g), &:+)
+      @used_volume = @packages.map(&:volume).reduce(Measured::Volume(0, :ml), &:+)
+    end
+
+    delegate [:dimensions, :width, :length, :height, :properties, :volume] => :container
+
+    def <<(other)
+      @packages.add(other)
+      @packages_weight += other.weight
+      @used_volume += other.volume
+    end
+    alias_method :add, :<<
+
+    def >>(other)
+      @packages.delete(other)
+      @packages_weight -= other.weight
+      @used_volume -= other.volume
+    end
+    alias_method :delete, :>>
+
+    def weight
+      container.weight + packages_weight
+    end
+
+    # Cost is optional. We will only return an aggregate if all packages
+    # have items value defined. Otherwise we will return nil.
+    # @return Money
+    def packages_value
+      packages_cost = packages.map(&:items_value)
+      packages_cost.reduce(&:+) if packages_cost.compact.size == packages_cost.size
+    end
+
+    def remaining_volume
+      container.inner_volume - used_volume
+    end
+
+    def density
+      return Measured::Density(Float::INFINITY, :g_ml) if container.volume.value.zero?
+      return Measured::Density(0.0, :g_ml) if container.volume.value.infinite?
+
+      Measured::Density(weight.convert_to(:g).value / container.volume.convert_to(:ml).value, :g_ml)
+    end
+  end
+end

data/lib/physical/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Physical
-  VERSION = "0.4.8"
+  VERSION = "0.5.0"
 end

data/lib/physical.rb

@@ -4,6 +4,7 @@ require "money"
 require "measured/density"
 require "physical/types"
 require "physical/version"
+require "physical/property_readers"
 require "physical/cuboid"
 require "physical/box"
 require "physical/package"
@@ -11,6 +12,7 @@ require "physical/pallet"
 require "physical/item"
 require "physical/location"
 require "physical/shipment"
+require "physical/structure"
 
 module Physical
   # Your code goes here...

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: physical
 version: !ruby/object:Gem::Version
-  version: 0.4.8
+  version: 0.5.0
 platform: ruby
 authors:
 - Martin Meyerhoff
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-21 00:00:00.000000000 Z
+date: 2023-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: carmen
@@ -199,6 +199,7 @@ files:
 - lib/physical/location.rb
 - lib/physical/package.rb
 - lib/physical/pallet.rb
+- lib/physical/property_readers.rb
 - lib/physical/shipment.rb
 - lib/physical/spec_support/factories/box_factory.rb
 - lib/physical/spec_support/factories/item_factory.rb
@@ -206,7 +207,11 @@ files:
 - lib/physical/spec_support/factories/package_factory.rb
 - lib/physical/spec_support/factories/pallet_factory.rb
 - lib/physical/spec_support/factories/shipment_factory.rb
+- lib/physical/spec_support/factories/structure_factory.rb
 - lib/physical/spec_support/shared_examples.rb
+- lib/physical/spec_support/shared_examples/a_cuboid.rb
+- lib/physical/spec_support/shared_examples/has_property_readers.rb
+- lib/physical/structure.rb
 - lib/physical/test_support.rb
 - lib/physical/types.rb
 - lib/physical/version.rb
@@ -230,7 +235,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.4.22
 signing_key:
 specification_version: 4
 summary: A facade to deal with physical packages