spree_core 5.6.1 → 6.0.0.beta1

data/app/models/spree/external_reference.rb

@@ -0,0 +1,77 @@
+module Spree
+  # Maps a Spree record to its identity in an external system — the key an ERP,
+  # PIM, DAM or CRM knows it by. A record can carry one reference per system, so
+  # a product known to both a PIM and an ERP under different keys needs no
+  # per-system column.
+  #
+  # +system+ is a plain string key rather than a foreign key to
+  # {Spree::Integration}: data arrives from systems that have no live connector
+  # (a nightly CSV from a legacy PIM), and those still need somewhere to record
+  # their identity. Where a connector does exist the convention is to reuse its
+  # integration's +api_type+, so connector, references and settings page agree
+  # on the name.
+  class ExternalReference < Spree.base_class
+    has_prefix_id :extref
+
+    include Spree::SingleStoreResource
+    include Spree::Metadata
+
+    belongs_to :store, class_name: 'Spree::Store', inverse_of: :external_references
+    belongs_to :resource, polymorphic: true
+
+    normalizes :system, with: ->(value) { normalize_system(value) }
+    normalizes :external_id, with: ->(value) { value.to_s.strip }
+
+    # Turns either shape a caller may hold — the `{ system => external_id }`
+    # map the admin serializers render, or a `[{ system:, external_id: }]`
+    # list — into symbolized entries, dropping any that name no system.
+    #
+    # The single definition of the accepted shapes: the write path
+    # ({Spree::HasExternalReferences#assign_external_references}) and the API
+    # concern's upsert lookup both parse payloads through here.
+    #
+    # @param references [Hash, Array<Hash>, nil]
+    # @return [Array<Hash>] entries with :system, :external_id and optional :metadata
+    # The one statement of what a system key looks like: every lookup and
+    # write normalizes through here, or a writer's key and a reader's key
+    # could disagree about the same row.
+    #
+    # @return [String]
+    def self.normalize_system(value)
+      value.to_s.strip.downcase
+    end
+
+    def self.normalize_references(references)
+      return [] if references.blank?
+
+      entries =
+        if references.is_a?(Hash) && !references.key?(:system) && !references.key?('system')
+          references.map { |system, external_id| { system: system, external_id: external_id } }
+        else
+          Array(references).map { |entry| entry.respond_to?(:to_unsafe_h) ? entry.to_unsafe_h : entry }
+        end
+
+      entries.filter_map do |entry|
+        entry = entry.to_h.symbolize_keys.slice(:system, :external_id, :metadata)
+        entry[:system].blank? ? nil : entry
+      end
+    end
+
+    validates :system, :external_id, presence: true
+    validates :system,
+              format: { with: /\A[a-z0-9_]+\z/, message: :invalid_system_key },
+              allow_blank: true
+    # Both directions, each backed by a unique index: one reference per system
+    # per record, and one record per external id.
+    validates :resource_id,
+              uniqueness: { scope: [:store_id, :system, :resource_type, *spree_base_uniqueness_scope] },
+              allow_blank: true
+    validates :external_id,
+              uniqueness: { scope: [:store_id, :system, :resource_type, *spree_base_uniqueness_scope] },
+              allow_blank: true
+
+    self.whitelisted_ransackable_attributes = %w[system external_id resource_type]
+
+    scope :for_system, ->(system) { where(system: normalize_system(system)) }
+  end
+end

data/app/models/spree/external_video.rb

@@ -0,0 +1,117 @@
+module Spree
+  # Value object that reads a YouTube or Vimeo link and tells you which
+  # provider it belongs to, which video it points at, and how to embed it.
+  #
+  # Spree does this once, at the write boundary, so the URL is validated before
+  # it is stored and every storefront reads the same derived values instead of
+  # re-implementing link parsing.
+  class ExternalVideo
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+
+    YOUTUBE_HOSTS = %w[youtube.com www.youtube.com m.youtube.com youtu.be www.youtu.be].freeze
+    VIMEO_HOSTS = %w[vimeo.com www.vimeo.com player.vimeo.com].freeze
+
+    YOUTUBE_ID_FORMAT = /\A[\w-]{11}\z/
+    VIMEO_ID_FORMAT = /\A\d+\z/
+
+    attribute :provider, :string
+    attribute :video_id, :string
+
+    # Reads a URL and returns the video it describes, or nil when the URL is
+    # blank, malformed, or points somewhere Spree doesn't support.
+    #
+    # @param url [String, nil]
+    # @return [Spree::ExternalVideo, nil]
+    def self.parse(url)
+      return nil if url.blank?
+
+      uri = begin
+        URI.parse(url.strip)
+      rescue URI::InvalidURIError
+        return nil
+      end
+
+      return nil unless uri.scheme.in?(%w[http https])
+
+      host = uri.host&.downcase
+      return nil if host.blank?
+
+      if host.in?(YOUTUBE_HOSTS)
+        youtube_from(uri, host)
+      elsif host.in?(VIMEO_HOSTS)
+        vimeo_from(uri)
+      end
+    end
+
+    # @return [Boolean] whether the URL is one Spree can embed
+    def self.supported?(url)
+      parse(url).present?
+    end
+
+    # Path shapes that actually carry a video id. Anything else on the domain —
+    # /c/name, /@handle, /playlist — is not a video, and treating its last
+    # segment as an id yields an embed URL that plays nothing.
+    YOUTUBE_ID_PATHS = %w[embed shorts live v].freeze
+
+    def self.youtube_from(uri, host)
+      # Ignore empty segments so a trailing slash — ordinary when a URL is
+      # copied from the address bar — parses like the same link without one.
+      segments = uri.path.split('/').reject(&:blank?)
+
+      video_id =
+        if host.include?('youtu.be')
+          # A short link is the id and nothing else.
+          segments.first if segments.one?
+        elsif uri.path.chomp('/') == '/watch'
+          URI.decode_www_form(uri.query.to_s).to_h['v']
+        elsif segments.size == 2 && segments.first.in?(YOUTUBE_ID_PATHS)
+          segments.last
+        end
+
+      return nil unless video_id.to_s.match?(YOUTUBE_ID_FORMAT)
+
+      new(provider: 'youtube', video_id: video_id)
+    end
+    private_class_method :youtube_from
+
+    def self.vimeo_from(uri)
+      # /ID, /video/ID, /channels/name/ID all end in the numeric id.
+      video_id = uri.path.split('/').reject(&:blank?).last
+
+      return nil unless video_id.to_s.match?(VIMEO_ID_FORMAT)
+
+      new(provider: 'vimeo', video_id: video_id)
+    end
+    private_class_method :vimeo_from
+
+    # @return [String] URL for an iframe player
+    def embed_url
+      case provider
+      when 'youtube' then "https://www.youtube.com/embed/#{video_id}"
+      when 'vimeo' then "https://player.vimeo.com/video/#{video_id}"
+      end
+    end
+
+    # @return [String] canonical watch URL on the provider's own site
+    def watch_url
+      case provider
+      when 'youtube' then "https://www.youtube.com/watch?v=#{video_id}"
+      when 'vimeo' then "https://vimeo.com/#{video_id}"
+      end
+    end
+
+    # Provider-hosted still frame. YouTube serves one at a predictable URL;
+    # Vimeo requires an API call, so it has none here and the merchant uploads
+    # a poster instead.
+    #
+    # `hqdefault` is the only size YouTube guarantees for every video —
+    # `maxresdefault` 404s on anything without an HD source, which would leave
+    # a broken image as the video's only still.
+    #
+    # @return [String, nil]
+    def thumbnail_url
+      return "https://img.youtube.com/vi/#{video_id}/hqdefault.jpg" if provider == 'youtube'
+    end
+  end
+end

data/app/models/spree/fee.rb

@@ -0,0 +1,40 @@
+module Spree
+  # An extensible charge (surcharge, handling, gift wrap, COD, payment fee).
+  # May target a line item or fulfillment, or be order-level (both adjustable
+  # FKs nil). Fees are taxable — the tax provider writes TaxLine rows against
+  # them. Ad-hoc credits are manual Discounts, never negative fees (amount is
+  # enforced non-negative by validation + DB CHECK).
+  class Fee < Spree.base_class
+    include Spree::TypedAdjustmentLine
+
+    # Extensions may append their own kinds — the list is validated, not frozen.
+    # `duty` rows are written by a duties provider's adjuster and snapshot the
+    # classification they were calculated from in `metadata` — never re-derive
+    # a duty from the live catalog.
+    KINDS = %w[surcharge handling gift_wrap cod payment duty]
+
+    has_prefix_id :fee
+
+    # Adjustable — optional: both nil means an order-level fee
+    belongs_to :line_item, class_name: 'Spree::LineItem', optional: true
+    belongs_to :fulfillment, class_name: 'Spree::Fulfillment', optional: true
+
+    has_many :tax_lines, class_name: 'Spree::TaxLine', dependent: :destroy
+
+    validates :amount, numericality: { greater_than_or_equal_to: 0 }
+    validates :kind, presence: true, inclusion: { in: ->(_fee) { KINDS }, allow_blank: true }
+
+    scope :for_line_items, -> { where.not(line_item_id: nil) }
+    scope :for_fulfillments, -> { where.not(fulfillment_id: nil) }
+    scope :order_level, -> { where(line_item_id: nil, fulfillment_id: nil) }
+
+    # @return [Spree::LineItem, Spree::Fulfillment, nil] nil for order-level fees
+    def adjustable
+      line_item || fulfillment
+    end
+
+    def order_level?
+      line_item_id.nil? && fulfillment_id.nil?
+    end
+  end
+end

data/app/models/spree/freight_summary/line.rb

@@ -0,0 +1,257 @@
+module Spree
+  class FreightSummary
+    # One variant's contribution to a freight summary.
+    #
+    # Built once from the live catalog and thereafter carried as plain data,
+    # so an order's frozen summary keeps reporting the cartons it actually
+    # shipped in even after the variant is repacked.
+    class Line
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+
+      attribute :variant_id, :string
+      attribute :sku, :string
+      attribute :name, :string
+      attribute :units, :integer, default: 0
+      attribute :cartons, :integer
+      attribute :pallets, :integer
+      # The divisors behind the two counts above, carried so a summary split
+      # across consignments can be recombined without consulting the catalog
+      # it was frozen away from.
+      attribute :units_per_carton, :integer
+      attribute :cartons_per_pallet, :integer
+      # The part of the weight that scales with cartons rather than units —
+      # the declared gross where the merchant recorded one, else the empty
+      # carton's own weight. Carried for the same reason as the divisors: it
+      # is what lets two part-full cartons collapse into one without keeping
+      # both packagings' weight.
+      attribute :weight_per_carton, :decimal
+      attribute :volume, :decimal, default: 0
+      attribute :weight, :decimal, default: 0
+      # False when the variant declares no carton, so volume and weight came
+      # from unit dimensions instead.
+      attribute :complete, :boolean, default: false
+
+      # @param variant [Spree::Variant]
+      # @param quantity [Integer]
+      # @return [Spree::FreightSummary::Line]
+      def self.build(variant, quantity)
+        quantity = quantity.to_i
+        cartons = variant.cartons_for(quantity)
+        carton_volume = variant.carton_volume
+
+        if cartons && carton_volume
+          from_cartons(variant, quantity, cartons, carton_volume)
+        else
+          from_units(variant, quantity)
+        end
+      end
+
+      # The measured path: the variant declares a carton with geometry, so
+      # volume and weight are the cartons the order actually fills.
+      def self.from_cartons(variant, quantity, cartons, carton_volume)
+        new(
+          **identity(variant),
+          units: quantity,
+          cartons: cartons,
+          pallets: pallets_for(variant, cartons),
+          volume: carton_volume * cartons,
+          weight: carton_weight_for(variant, cartons, quantity),
+          weight_per_carton: weight_per_carton_for(variant),
+          complete: true
+        )
+      end
+      private_class_method :from_cartons
+
+      # The fallback: no carton on the variant, so the goods are measured
+      # loose. Real enough to quote against, and flagged as incomplete.
+      def self.from_units(variant, quantity)
+        unit_volume = Spree::Measurement.cubic_meters(
+          variant.width, variant.height, variant.depth, unit: variant.dimensions_unit
+        )
+        cartons = variant.cartons_for(quantity)
+
+        new(
+          **identity(variant),
+          units: quantity,
+          cartons: cartons,
+          # A line that counts cartons still says how they stack. Leaving it
+          # blank would drop the pallet count for the whole summary, not just
+          # for this line.
+          pallets: (pallets_for(variant, cartons) if cartons),
+          weight_per_carton: (weight_per_carton_for(variant) if cartons),
+          volume: (unit_volume || 0) * quantity,
+          # A merchant who recorded what a packed carton weighs knows more
+          # than the loose goods do, even when the carton itself is
+          # unmeasured — using the goods' weight there understates the load.
+          weight: cartons ? carton_weight_for(variant, cartons, quantity) : unit_weight(variant) * quantity,
+          complete: false
+        )
+      end
+      private_class_method :from_units
+
+      # Adds together the lines the same variant produced in several
+      # consignments.
+      #
+      # Cartons and pallets are re-derived from the combined units rather than
+      # summed, because each part was rounded up when it was built: a variant
+      # packed twelve to a carton, split three units and nine, is one carton
+      # in total and not two. The divisors ride on the line itself, so a
+      # frozen snapshot can be recombined years later without asking today's
+      # catalog — which is exactly what freezing it was meant to avoid.
+      #
+      # @param parts [Array<Spree::FreightSummary::Line>]
+      # @return [Spree::FreightSummary::Line]
+      def self.combine(parts)
+        first = parts.first
+        units = parts.sum(&:units)
+        recombined = divide(units, first.units_per_carton)
+        # `presence` is no help on an Integer — zero is present — so the
+        # "no part counted cartons" case has to be spelled out, or a line
+        # nobody packed reports zero cartons where every unmerged line
+        # reports none at all.
+        counted = parts.filter_map(&:cartons)
+        cartons = recombined || (counted.sum if counted.any?)
+        pallets = cartons && divide(cartons, first.cartons_per_pallet)
+
+        new(
+          variant_id: first.variant_id,
+          sku: first.sku,
+          name: first.name,
+          units: units,
+          units_per_carton: first.units_per_carton,
+          cartons_per_pallet: first.cartons_per_pallet,
+          cartons: cartons,
+          pallets: pallets,
+          # Volume follows the recombined carton count for the same reason
+          # the count itself does: adding two part-full cartons' volumes
+          # reports space the combined shipment does not take.
+          volume: combined_volume(parts, recombined),
+          weight: combined_weight(parts, cartons),
+          weight_per_carton: parts.filter_map(&:weight_per_carton).first,
+          complete: parts.all?(&:complete?)
+        )
+      end
+
+      # Goods weight scales with units, so summing the parts is right for it;
+      # the packaging scales with cartons, so each carton the merge collapses
+      # must give its share back — otherwise two part-full cartons folded into
+      # one keep both packagings' weight. A snapshot frozen before the
+      # component was recorded has nil here and keeps the plain sum.
+      def self.combined_weight(parts, cartons)
+        summed = parts.sum(&:weight)
+        per_carton = parts.filter_map(&:weight_per_carton).first
+        return summed if cartons.nil? || per_carton.nil?
+
+        collapsed = parts.filter_map(&:cartons).sum - cartons
+        return summed unless collapsed.positive?
+
+        summed - (per_carton * collapsed)
+      end
+      private_class_method :combined_weight
+
+      # Per-carton volume from whichever part recorded one, scaled to the
+      # combined count. Falls back to the plain sum for lines measured loose,
+      # where volume is per unit and adding is right.
+      def self.combined_volume(parts, cartons)
+        summed = parts.sum(&:volume)
+        return summed if cartons.nil?
+
+        measured = parts.detect { |part| part.complete? && part.cartons.to_i.positive? && part.volume.to_d.positive? }
+        return summed if measured.nil?
+
+        (measured.volume.to_d / measured.cartons) * cartons
+      end
+      private_class_method :combined_volume
+
+      # A part of anything still ships as a whole one.
+      def self.divide(quantity, divisor)
+        return if divisor.to_i.zero?
+
+        (quantity / divisor.to_f).ceil
+      end
+      private_class_method :divide
+
+      def self.identity(variant)
+        {
+          variant_id: variant.prefixed_id,
+          sku: variant.sku,
+          name: variant.descriptive_name,
+          units_per_carton: variant.units_per_carton,
+          cartons_per_pallet: variant.cartons_per_pallet
+        }
+      end
+      private_class_method :identity
+
+      # Nil when the variant does not say how its cartons stack — the summary
+      # then reports no pallet count at all rather than a partial one.
+      def self.pallets_for(variant, cartons)
+        divide(cartons, variant.cartons_per_pallet)
+      end
+      private_class_method :pallets_for
+
+      # A packed carton's declared gross weight where the merchant recorded
+      # one — that figure already includes the box. Otherwise the goods plus
+      # the empty carton's own weight, so the packaging is not simply lost
+      # from a shipment the summary calls fully measured.
+      def self.carton_weight_for(variant, cartons, quantity)
+        declared = Spree::Measurement.to_kilograms(variant.carton_weight, unit: variant.weight_unit)
+        return declared * cartons if declared&.positive?
+
+        (unit_weight(variant) * quantity) + (carton_tare(variant) * cartons)
+      end
+      private_class_method :carton_weight_for
+
+      # The carton-scaling component of this variant's weight: the declared
+      # gross when one is recorded (it counts per carton, goods included),
+      # else the empty carton's own weight (the goods then count per unit).
+      def self.weight_per_carton_for(variant)
+        declared = Spree::Measurement.to_kilograms(variant.carton_weight, unit: variant.weight_unit)
+        return declared if declared&.positive?
+
+        carton_tare(variant)
+      end
+      private_class_method :weight_per_carton_for
+
+      # The empty carton's own weight, in the kilograms the summary reports.
+      def self.carton_tare(variant)
+        Spree::Measurement.to_kilograms(
+          variant.carton_package_type&.weight, unit: variant.carton_package_type&.weight_unit
+        ) || 0
+      end
+      private_class_method :carton_tare
+
+      def self.unit_weight(variant)
+        Spree::Measurement.to_kilograms(variant.weight, unit: variant.weight_unit) || 0
+      end
+      private_class_method :unit_weight
+
+      # @return [Boolean]
+      def cartons?
+        cartons.to_i.positive?
+      end
+
+      # @return [Boolean]
+      def complete?
+        !!complete
+      end
+
+      def as_json(*)
+        {
+          'variant_id' => variant_id,
+          'sku' => sku,
+          'name' => name,
+          'units' => units,
+          'cartons' => cartons,
+          'pallets' => pallets,
+          'units_per_carton' => units_per_carton,
+          'cartons_per_pallet' => cartons_per_pallet,
+          'weight_per_carton' => weight_per_carton && BigDecimal(weight_per_carton.to_s).to_s('F'),
+          'volume' => BigDecimal(volume.to_s).to_s('F'),
+          'weight' => BigDecimal(weight.to_s).to_s('F'),
+          'complete' => complete
+        }
+      end
+    end
+  end
+end

data/app/models/spree/freight_summary.rb

@@ -0,0 +1,180 @@
+module Spree
+  # What a cart or a package looks like to a freight forwarder: how many
+  # units, how many cartons those fill, how many pallets those stack onto,
+  # the cubic meters they occupy and what the whole thing weighs.
+  #
+  # These are the numbers a wholesale shipment is quoted and tiered on, and
+  # they are not derivable from the retail shipping data — a case of 48 bottles
+  # is one carton, not 48 parcels. A variant declares its carton
+  # (docs/plans/6.0-b2b-wholesale-shipping.md) and the rollup follows the
+  # chain Unit -> Carton -> Pallet -> CBM / weight.
+  #
+  # Lines whose variant declares no carton fall back to unit volume and
+  # weight and mark the summary {#complete?} false, so the numbers stay
+  # useful while saying plainly that some of the catalog is unmeasured.
+  #
+  # A purchase reads the copy the freight provider froze onto its selected
+  # delivery rate, and never re-derives it from the live catalog. No freight
+  # rate, no summary.
+  class FreightSummary
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+
+    attribute :lines, default: -> { [] }
+
+    class << self
+      # Rolls up stock package contents.
+      #
+      # @param contents [Array<Spree::Stock::ContentItem>]
+      # @return [Spree::FreightSummary]
+      def build(contents)
+        from_pairs(Array(contents).filter_map do |item|
+          variant = item.variant
+          [variant, item.quantity] if variant
+        end)
+      end
+
+
+      # Combines the summaries several fulfillments froze into the one load
+      # the forwarder sees.
+      #
+      # Lines for the same variant are added together rather than listed
+      # twice, because carton and pallet counts were each rounded up when the
+      # line was built: three cartons in one consignment and three in another
+      # is six cartons on one pallet, not two pallets.
+      #
+      # @param summaries [Array<Spree::FreightSummary>]
+      # @return [Spree::FreightSummary]
+      def merge(summaries)
+        lines = Array(summaries).flat_map(&:lines).
+                group_by(&:variant_id).
+                map { |_variant_id, grouped| grouped.length == 1 ? grouped.first : Line.combine(grouped) }
+
+        new(lines: lines)
+      end
+
+      # Rebuilds a summary from its serialized form — the frozen copy carried
+      # in a delivery rate's metadata.
+      #
+      # @param payload [Hash, nil]
+      # @return [Spree::FreightSummary, nil]
+      def from_metadata(payload)
+        return if payload.blank?
+
+        payload = payload.with_indifferent_access
+        # Only keys this version of Line declares. A frozen snapshot outlives
+        # the code that wrote it by design, so an attribute renamed or dropped
+        # later must read as absent rather than raise on every historical
+        # order the moment it is serialized.
+        known = Spree::FreightSummary::Line.attribute_names.map(&:to_sym)
+        lines = Array(payload[:lines]).map do |line|
+          Spree::FreightSummary::Line.new(line.symbolize_keys.slice(*known))
+        end
+
+        new(lines: lines)
+      end
+
+      private
+
+      # One line per variant, whatever the packer split it into. A stock
+      # package holds a separate content item for the on-hand and backordered
+      # halves of the same variant, and each half would round its own part
+      # carton up — reporting three cartons for thirty units that fill two.
+      def from_pairs(pairs)
+        quantities = Hash.new(0)
+        variants = {}
+        pairs.each do |variant, quantity|
+          next unless variant && quantity.to_i.positive?
+
+          variants[variant.id] ||= variant
+          quantities[variant.id] += quantity.to_i
+        end
+
+        lines = quantities.map { |variant_id, quantity| Spree::FreightSummary::Line.build(variants[variant_id], quantity) }
+
+        new(lines: lines)
+      end
+    end
+
+    # @return [Integer]
+    def total_units
+      @total_units ||= sum_of(:units).to_i
+    end
+
+    # @return [Integer]
+    def total_cartons
+      @total_cartons ||= sum_of(:cartons).to_i
+    end
+
+    # Pallets are only meaningful when every carton-bearing line says how it
+    # stacks; one silent line would understate the load.
+    #
+    # @return [Integer, nil]
+    def total_pallets
+      return @total_pallets if defined?(@total_pallets)
+
+      carton_lines = lines.select(&:cartons?)
+      @total_pallets =
+        unless carton_lines.empty? || carton_lines.any? { |line| line.pallets.nil? }
+          carton_lines.sum(&:pallets)
+        end
+    end
+
+    # @return [BigDecimal] cubic meters
+    def total_volume
+      @total_volume ||= sum_of(:volume)
+    end
+
+    # @return [BigDecimal] kilograms
+    def total_weight
+      @total_weight ||= sum_of(:weight)
+    end
+
+    # True when every line was measured from its carton. False means some of
+    # the figures above came from unit dimensions instead, which under-reports
+    # the space packaging takes.
+    #
+    # @return [Boolean]
+    def complete?
+      lines.any? && lines.all?(&:complete?)
+    end
+
+    # True when there is nothing here worth reporting as freight — no lines,
+    # or lines that measured to nothing because the catalog records no
+    # dimensions. A retail cart of unmeasured goods has no freight summary
+    # rather than one full of zeros, which would read as a shipment that
+    # takes up no space.
+    #
+    # @return [Boolean]
+    def empty?
+      lines.empty? || (total_volume.zero? && total_weight.zero? && total_cartons.zero?)
+    end
+
+    # The serialized form frozen onto a delivery rate at completion.
+    #
+    # @return [Hash]
+    def as_json(*)
+      {
+        'total_units' => total_units,
+        'total_cartons' => total_cartons,
+        'total_pallets' => total_pallets,
+        'total_volume' => decimal_string(total_volume),
+        'total_weight' => decimal_string(total_weight),
+        'complete' => complete?,
+        'lines' => lines.map(&:as_json)
+      }
+    end
+
+    private
+
+    # Plain decimal notation. BigDecimal's default renders 0.06 as "0.6e-1",
+    # which is what a client would print beside "CBM".
+    def decimal_string(value)
+      BigDecimal(value.to_s).to_s('F')
+    end
+
+    def sum_of(attribute)
+      lines.sum { |line| line.public_send(attribute) || 0 }
+    end
+  end
+end