structs to model values in our domain

response_values.rb

module PaymentProcessor
  module Response
    class ResponseStruct < Struct
      def self.build(args)
        return if args.blank?
        
        # this filters the fields from the response that we don't need or want.
        # but it also keeps the kwargs strict.
        new(args.slice(*members)
      end
    end
    
    class CustomerSummary
      def initialize(data)
        @data = transform_data(data)
        @order_summary = build_order_summary
        @card_profile = build_card_profile
      end
      
      private
      
      def build_order_summary
        orders = @data.dig(:customer, :order_summary)
        
        case orders
        in Array
          orders.map do |order|
            method_name = detect_order_type(order)
            send(method_name, order)
          end
        in Object
          method_name = detect_order_type(orders)
          [send(method_name, orders)]
        end
      end
      
      def detect_order_type(order)
        if order.key?(:package_name)
          :build_package_set
        elsif order.key?(:etificate)
          :etificate
        else
          :tbs
        end
      end
      
      PackageSet = ResponseStruct.new(
        :package_name,
        :package_sku,
        :trial_start_date,
        :trial_end_date,
        # other package set attributes
        keyword_init: true
      ) do
          def name
            package_name
          end
        
          def offer_code
            package_sku
          end
        end
      def build_package_set(order)
        PackageSet.build(order)  
      end
      
      Etificate = ResponseStruct.new(
        :efiticate_name,
        :etificate_sku,
        :donor_email,
        :donee_email,
        # other etificate attributes
        keyword_init: true
        ) do
          def name
            etificate_name
          end
          
          def offer_code
            etificate_sku
          end
        end
      def build_etificate(order)
        Etificate.build(order)
      end
      
      TimeBaseSubscription = ResponseStruct.new(
        :order_name,
        :sku,
        :order_specific_thing,
        # other tbs attributes
        keyword_init: true
        )do
          def name
            order_name
          end
          
          def offer_code
            sku
          end
        end
      def build_tbs(order)
        TimeBaseSubscription.build(order)
      end
      
      CardProfile = ResponseStruct.new(
        :cc_last_four,
        :cc_name,
        :cc_type,
        keyword_init: true
        )
      def build_card_profile
        cc_info = @data.dig(:customer, :card_profile)
        CardProfile.build(cc_info)
      end
    end
  end
end