peddler 2.4.5 → 3.0.0.beta1

data/lib/peddler/client.rb

@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-require 'jeff'
-require 'peddler/errors/builder'
-require 'peddler/marketplace'
-require 'peddler/operation'
-require 'peddler/parser'
-
-module Peddler
-  # An abstract client
-  #
-  # Subclass this to implement an MWS API section.
-  class Client
-    extend Forwardable
-    include Jeff
-
-    class << self
-      # @!visibility private
-      attr_accessor :parser, :path, :version
-
-      private
-
-      def inherited(base)
-        super
-        base.parser = parser
-        base.params params
-      end
-    end
-
-    params 'SellerId' => -> { merchant_id },
-           'MWSAuthToken' => -> { auth_token },
-           'Version' => -> { version }
-    self.parser = Parser
-
-    def_delegators :marketplace, :host, :encoding
-    def_delegators :'self.class', :parser, :version
-
-    # Creates a new client
-    # @param [Hash] opts
-    # @option opts [String] :aws_access_key_id
-    # @option opts [String] :aws_secret_access_key
-    # @option opts [String, Peddler::Marketplace] :marketplace
-    # @option opts [String] :merchant_id
-    # @option opts [String] :auth_token
-    def initialize(opts = {})
-      opts.each { |k, v| send("#{k}=", v) }
-    end
-
-    # The MWS Auth Token for a seller's account
-    # @note You can omit this if you are accessing your own seller account
-    # @return [String]
-    attr_accessor :auth_token
-
-    # The seller's Merchant ID
-    # @note Amazon also refers to this as Seller ID or Merchant Token
-    # @return [String]
-    attr_accessor :merchant_id
-
-    # The marketplace where you signed up as application developer
-    # @note You can pass the two-letter country code of the marketplace as
-    #   shorthand when setting
-    # @return [Peddler::Marketplace]
-    attr_reader :marketplace
-
-    # @!parse attr_writer :marketplace
-    def marketplace=(marketplace)
-      @marketplace =
-        if marketplace.is_a?(Marketplace)
-          marketplace
-        else
-          Marketplace.find(marketplace)
-        end
-    end
-
-    # The body of the HTTP request
-    # @return [String]
-    attr_reader :body
-
-    # @!parse attr_writer :body
-    def body=(str)
-      str ? add_content(str) : clear_content!
-    end
-
-    # @!visibility private
-    attr_writer :path
-
-    # @!visibility private
-    def path
-      @path ||= self.class.path
-    end
-
-    # @!visibility private
-    def defaults
-      @defaults ||= { expects: 200 }
-    end
-
-    # @!visibility private
-    def headers
-      @headers ||= {}
-    end
-
-    # @!visibility private
-    def aws_endpoint
-      "https://#{host}#{path}"
-    end
-
-    # @!visibility private
-    def operation(action = nil)
-      action ? @operation = Operation.new(action) : @operation
-    end
-
-    # @!visibility private
-    def run(&block)
-      opts = build_options
-      opts.store(:response_block, block) if block
-      res = post(opts)
-      self.body = nil if res.status == 200
-
-      parser.new(res, encoding)
-    rescue ::Excon::Error::HTTPStatus => e
-      handle_http_status_error(e)
-    end
-
-    private
-
-    def clear_content!
-      headers.delete('Content-Type')
-      @body = nil
-    end
-
-    def add_content(content)
-      @body = content
-      if content.encoding.names.include?('BINARY')
-        headers['Content-Type'] = 'application/octet-stream'
-      elsif content.start_with?('<?xml')
-        headers['Content-Type'] = 'text/xml'
-      else
-        headers['Content-Type'] =
-          "text/tab-separated-values; charset=#{encoding}"
-        @body = @body.encode(encoding)
-      end
-    end
-
-    def extract_options(args)
-      args.last.is_a?(Hash) ? args.pop : {}
-    end
-
-    def build_options
-      opts = defaults.merge(query: operation, headers: headers)
-      body ? opts.update(body: body) : opts
-    end
-
-    def handle_http_status_error(error)
-      new_error = Errors::Builder.call(error)
-      raise new_error || error
-    end
-  end
-end

data/lib/peddler/errors/builder.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require 'excon'
-require 'forwardable'
-require 'peddler/errors/class_generator'
-require 'peddler/errors/parser'
-
-module Peddler
-  module Errors
-    # @!visibility private
-    class Builder
-      extend Forwardable
-
-      DIGIT_AS_FIRST_CHAR = /^\d/.freeze
-      private_constant :DIGIT_AS_FIRST_CHAR
-
-      def_delegator :error, :response
-
-      def self.call(error)
-        new(error).build
-      end
-
-      attr_reader :error
-
-      def initialize(error)
-        @error = error
-      end
-
-      def build
-        parse_original_response
-        return if no_error_response?
-        return if bad_class_name?
-
-        error_class.new(error_message, error)
-      end
-
-      private
-
-      def bad_class_name?
-        error_name.match?(DIGIT_AS_FIRST_CHAR)
-      end
-
-      def no_error_response?
-        response.parse.nil?
-      end
-
-      def error_class
-        ClassGenerator.call(error_name)
-      end
-
-      def error_name
-        response.code
-      end
-
-      def error_message
-        response.message
-      end
-
-      def parse_original_response
-        error.instance_variable_set :@response, Parser.new(error.response)
-      end
-    end
-  end
-end

data/lib/peddler/errors/class_generator.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require 'singleton'
-require 'peddler/errors/error'
-
-module Peddler
-  module Errors
-    # @!visibility private
-    class ClassGenerator
-      include Singleton
-
-      def self.call(name)
-        instance.generate(name)
-      end
-
-      def initialize
-        @mutex = Mutex.new
-      end
-
-      def generate(name)
-        with_mutex do
-          if Errors.const_defined?(name)
-            error = Errors.const_get(name)
-            return error if error <= Error
-
-            raise TypeError, "#{name} must be a Peddler::Errors::Error"
-          end
-
-          Errors.const_set(name, Class.new(Error))
-        end
-      end
-
-      private
-
-      def with_mutex(&block)
-        @mutex.synchronize(&block)
-      end
-    end
-  end
-end

data/lib/peddler/errors/error.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-module Peddler
-  # @!visibility private
-  module Errors
-    # These error codes are common to all Amazon MWS API sections.
-    #
-    # @see https://docs.developer.amazonservices.com/en_US/dev_guide/DG_Errors.html
-    #
-    # There are quite a few other error types they do not explicitly document
-    # above. I decided not to define any for the sake of consistency and future
-    # maintenance.
-    CODES = %w[
-      AccessDenied
-      InputStreamDisconnected
-      InternalError
-      InvalidAccessKeyId
-      InvalidAddress
-      InvalidParameterValue
-      QuotaExceeded
-      RequestThrottled
-      SignatureDoesNotMatch
-    ].freeze
-
-    # @!visibility private
-    class Error < StandardError
-      extend Forwardable
-
-      attr_reader :cause
-
-      def initialize(msg = nil, cause = nil)
-        @cause = cause
-        super msg
-      end
-
-      def_delegator :cause, :response
-    end
-
-    CODES.each do |name|
-      const_set name, Class.new(Error)
-    end
-  end
-end

data/lib/peddler/errors/parser.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'peddler/xml_parser'
-
-module Peddler
-  module Errors
-    # @!visibility private
-    class Parser < XMLParser
-      def message
-        parse['Message']
-      end
-
-      def type
-        parse['Type']
-      end
-
-      def code
-        parse['Code']
-      end
-
-      private
-
-      def find_data
-        xml.dig('ErrorResponse', 'Error')
-      end
-    end
-  end
-end

data/lib/peddler/flat_file_parser.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require 'delegate'
-require 'csv'
-require 'digest/md5'
-require 'peddler/headers'
-
-module Peddler
-  # @!visibility private
-  class FlatFileParser < SimpleDelegator
-    include Headers
-
-    # http://stackoverflow.com/questions/8073920/importing-csv-quoting-error-is-driving-me-nuts
-    OPTIONS = { col_sep: "\t", quote_char: "\x00", headers: true }.freeze
-    private_constant :OPTIONS
-
-    attr_reader :content, :summary
-
-    def initialize(res, encoding)
-      super(res)
-      scrub_body!(encoding)
-      extract_content_and_summary
-    end
-
-    def parse(&blk)
-      CSV.parse(content, **OPTIONS, &blk) unless content.empty?
-    end
-
-    def records_count
-      summarize if summary
-    end
-
-    def valid?
-      headers['Content-MD5'] == Digest::MD5.base64digest(body)
-    end
-
-    private
-
-    def scrub_body!(encoding)
-      return if body.encoding == Encoding::UTF_8
-
-      self.body = body.dup.force_encoding(content_charset || encoding)
-    end
-
-    def extract_content_and_summary
-      @content = body.encode('UTF-8', invalid: :replace, undef: :replace)
-      return unless @content.match?(/\t\t.*\n\n/)
-
-      @summary, @content = @content.split("\n\n", 2)
-    end
-
-    def summarize
-      summary.split("\n\t")[1, 2].map { |line| line.split("\t\t") }.to_h
-    end
-  end
-end

data/lib/peddler/headers.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require 'time'
-
-module Peddler
-  # Parses useful metadata returned in response headers
-  module Headers
-    # The size of the response body in bytes
-    # @return [String, nil]
-    def content_length
-      return unless headers['Content-Length']
-
-      headers['Content-Length'].to_i
-    end
-
-    # The MD5 digest of the response body
-    # @return [String, nil]
-    def content_md5
-      headers['Content-MD5']
-    end
-
-    # The MIME type of the response
-    # @return [String, nil]
-    def content_media_type
-      return unless headers['Content-Type']
-
-      headers['Content-Type'].split(';').first
-    end
-
-    # The general category into which the MIME type falls
-    # @return [String, nil]
-    def content_type
-      return unless content_media_type
-
-      content_media_type.split('/').first
-    end
-
-    # The exact kind of data of the specified type the MIME type represents
-    # @return [String, nil]
-    def content_subtype
-      return unless content_media_type
-
-      content_media_type.split('/').last
-    end
-
-    # The character encoding of the response
-    # @return [Encoding, nil]
-    def content_charset
-      match_data = headers['Content-Type']&.match(/charset=(.*);?/)
-      return unless match_data
-
-      string = match_data[1].upcase
-      string = 'UTF-8' if string == 'UTF8'
-
-      Encoding.find(string)
-    end
-
-    # The max hourly request quota for the requested operation
-    # @return [Integer, nil]
-    def mws_quota_max
-      return unless headers['x-mws-quota-max']
-
-      headers['x-mws-quota-max'].to_i
-    end
-
-    # The remaining hourly request quota for the requested operation
-    # @return [Integer, nil]
-    def mws_quota_remaining
-      return unless headers['x-mws-quota-remaining']
-
-      headers['x-mws-quota-remaining'].to_i
-    end
-
-    # When the hourly request quota for the requested operation resets
-    # @return [Time, nil]
-    def mws_quota_resets_on
-      return unless headers['x-mws-quota-resetsOn']
-
-      Time.parse(headers['x-mws-quota-resetsOn'])
-    end
-
-    # The ID of the request
-    # @return [String, nil]
-    def mws_request_id
-      headers['x-mws-request-id']
-    end
-
-    # The timestamp of the request
-    # @return [Time, nil]
-    def mws_timestamp
-      return unless headers['x-mws-timestamp']
-
-      Time.parse(headers['x-mws-timestamp'])
-    end
-
-    # The context of the response
-    # @return [String, nil]
-    def mws_response_context
-      headers['x-mws-response-context']
-    end
-  end
-end

data/lib/peddler/marketplace.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module Peddler
-  # @!visibility private
-  # @see https://docs.developer.amazonservices.com/en_US/dev_guide/DG_Endpoints.html
-  class Marketplace
-    class << self
-      attr_reader :all
-
-      def find(key)
-        missing_key! unless key
-        marketplace = key.size == 2 ? find_by_country(key) : find_by_id(key)
-
-        marketplace || not_found!(key)
-      end
-
-      private
-
-      def find_by_country(code)
-        code = 'GB' if code == 'UK'
-        all.find { |marketplace| marketplace.country_code == code }
-      end
-
-      def find_by_id(id)
-        all.find { |marketplace| marketplace.id == id }
-      end
-
-      def missing_key!
-        raise ArgumentError, 'missing marketplace'
-      end
-
-      def not_found!(country_code)
-        raise ArgumentError, %("#{country_code}" is not a valid marketplace)
-      end
-    end
-
-    attr_reader :id, :country_code, :host
-
-    def initialize(id, country_code, host)
-      @id = id
-      @country_code = country_code
-      @host = host
-    end
-
-    def encoding
-      case country_code
-      when 'JP'
-        'Windows-31J'
-      else
-        'CP1252'
-      end
-    end
-
-    @all = [
-      ['A2Q3Y263D00KWC', 'BR', 'mws.amazonservices.com'],
-      ['A2EUQ1WTGCTBG2', 'CA', 'mws.amazonservices.com'],
-      ['A1AM78C64UM0Y8', 'MX', 'mws.amazonservices.com'],
-      ['ATVPDKIKX0DER', 'US', 'mws.amazonservices.com'],
-      ['A2VIGQ35RCS4UG', 'AE', 'mws.amazonservices.ae'],
-      ['A1PA6795UKMFR9', 'DE', 'mws-eu.amazonservices.com'],
-      ['ARBP9OOSHTCHU', 'EG', 'mws-eu.amazonservices.com'],
-      ['A1RKKUPIHCS9HS', 'ES', 'mws-eu.amazonservices.com'],
-      ['A13V1IB3VIYZZH', 'FR', 'mws-eu.amazonservices.com'],
-      ['A1F83G8C2ARO7P', 'GB', 'mws-eu.amazonservices.com'],
-      ['A21TJRUUN4KGV', 'IN', 'mws.amazonservices.in'],
-      ['APJ6JRA9NG5V4', 'IT', 'mws-eu.amazonservices.com'],
-      ['A1805IZSGTT6HS', 'NL', 'mws-eu.amazonservices.com'],
-      ['A17E79C6D8DWNP', 'SA', 'mws-eu.amazonservices.com'],
-      ['A33AVAJ2PDY3EV', 'TR', 'mws-eu.amazonservices.com'],
-      ['A2NODRKZP88ZB9', 'SE', 'mws-eu.amazonservices.com'],
-      ['A19VAU5U5O7RUS', 'SG', 'mws-fe.amazonservices.com'],
-      ['A39IBJ37TRP1C6', 'AU', 'mws.amazonservices.com.au'],
-      ['A1VC38T7YXB528', 'JP', 'mws.amazonservices.jp'],
-      ['A1C3SOZRARQ6R3', 'PL', 'mws-eu.amazonservices.com']
-    ].map do |values|
-      new(*values)
-    end
-  end
-end

data/lib/peddler/operation.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require 'delegate'
-require 'time'
-require 'peddler/structured_list'
-
-module Peddler
-  # @!visibility private
-  class Operation < SimpleDelegator
-    CAPITAL_LETTERS = /[A-Z]/.freeze
-    ALL_CAPS = %w[sku cod].freeze
-    private_constant :CAPITAL_LETTERS, :ALL_CAPS
-
-    def initialize(action)
-      super('Action' => action)
-    end
-
-    def structure!(*list_keys)
-      list_key = list_keys.shift
-      keys
-        .find_all { |key| key.end_with?(list_key) }
-        .each do |found_key|
-          builder = StructuredList.new(found_key, *list_keys)
-          vals = delete(found_key)
-          update(builder.build(vals))
-        end
-
-      self
-    end
-
-    def store(key, val, parent = nil)
-      key = [parent, camelize(key)].compact.join('.')
-      val = format_known_types(val)
-
-      if val.is_a?(Hash)
-        val.each { |keyval| store(*keyval, key) }
-      else
-        __getobj__.store(key, val)
-      end
-    end
-
-    def update(hsh)
-      hsh.each { |key, val| store(key, val) }
-      self
-    end
-
-    alias add update
-
-    private
-
-    def camelize(key)
-      return key unless key.is_a?(Symbol)
-      return key.to_s if key.match?(CAPITAL_LETTERS)
-
-      key
-        .to_s
-        .split('_')
-        .map { |token| capitalize(token) }
-        .join
-    end
-
-    def capitalize(word)
-      if ALL_CAPS.any?(word)
-        word.upcase
-      else
-        word.capitalize
-      end
-    end
-
-    def format_known_types(val)
-      val = val.utc.iso8601(2) if val.is_a?(Time)
-      val = val.iso8601 if val.is_a?(Date)
-      val = val.to_h if val.is_a?(Struct)
-
-      val
-    end
-  end
-end

data/lib/peddler/parser.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'peddler/flat_file_parser'
-require 'peddler/xml_response_parser'
-
-module Peddler
-  # @!visibility private
-  module Parser
-    class << self
-      # We're massaging data produced by a motley army of developers. It's
-      # messy.
-      def new(res, encoding)
-        # Don't parse if there's no body
-        return res unless res.body
-
-        if xml?(res)
-          XMLResponseParser.new(res)
-        else
-          # Amazon returns a variety of content types for flat files. I simply
-          # assume anything not XML is a flat file.
-          FlatFileParser.new(res, encoding)
-        end
-      end
-
-      def xml?(res)
-        return true if res.headers['Content-Type'].start_with?('text/xml')
-        return true if res.body.start_with?('<?xml')
-
-        false
-      end
-    end
-  end
-end

data/lib/peddler/structured_list.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Peddler
-  # @!visibility private
-  class StructuredList
-    def initialize(*keys)
-      @keys = keys
-    end
-
-    def build(vals)
-      Array(vals)
-        .flatten
-        .each_with_index
-        .reduce({}) { |hsh, (v, i)| hsh.merge(compose_key(i + 1) => v) }
-    end
-
-    private
-
-    def compose_key(index)
-      (@keys.dup << index).join('.')
-    end
-  end
-end