tracking_number 0.10.5 → 3.0.0

data/lib/tracking_number/base.rb

@@ -1,15 +1,16 @@
 module TrackingNumber
   class Base
-    attr_accessor :tracking_number
-    attr_accessor :original_number
+    attr_accessor :tracking_number, :original_number, :partner, :partner_data
+
+    PartnerStruct = Struct.new(:shipper, :carrier)
 
     def initialize(tracking_number)
       @original_number = tracking_number
-      @tracking_number = tracking_number.strip.gsub(" ", "").upcase
+      @tracking_number = tracking_number.strip.gsub(' ', '').upcase
     end
 
     def self.search(body)
-      valids = self.scan(body).uniq.collect { |possible| new(possible) }.select { |t| t.valid? }
+      valids = scan(body).uniq.collect { |possible| new(possible) }.select { |t| t.valid? }
 
       uniques = {}
       valids.each do |t|
@@ -20,48 +21,316 @@ module TrackingNumber
     end
 
     def self.scan(body)
-      patterns = [self.const_get("SEARCH_PATTERN")].flatten
-      possibles = patterns.collect do |pattern|
-        body.scan(pattern).uniq.flatten
+      # matches with match groups within the match data
+      matches = []
+
+      body.upcase.scan(const_get(:SEARCH_PATTERN)) do
+        # get the match data instead, which is needed with these types of regexes
+        matches << $~
+      end
+
+      if matches
+        matches.collect { |m| m[0] }
+      else
+        []
+      end
+    end
+
+    def serial_number
+      return match_group('SerialNumber') unless self.class.const_get('VALIDATION')
+
+      format_info   = self.class.const_get(:VALIDATION)[:serial_number_format]
+      raw_serial    = match_group('SerialNumber')
+
+      if format_info && format_info[:prepend_if] && raw_serial.match(Regexp.new(format_info[:prepend_if][:matches_regex]))
+        return "#{format_info[:prepend_if][:content]}#{raw_serial}"
+      # elsif format_info && format_info[:prepend_if_missing]
+
+      end
+
+      raw_serial
+    end
+
+    def check_digit
+      match_group('CheckDigit')
+    end
+
+    def decode
+      decoded = {}
+      (matches.try(:names) || []).each do |name|
+        sym = name.underscore.to_sym
+        decoded[sym] = matches[name]
       end
 
-      possibles.flatten.compact.uniq
+      decoded
     end
 
     def valid?
       return false unless valid_format?
       return false unless valid_checksum?
-      return true
+      return false unless valid_optional_checks?
+
+      true
     end
 
     def valid_format?
-      !matches.nil? && !matches.empty?
+      !matches.nil?
     end
 
-    def decode
-      {}
-    end
+    def valid_optional_checks?
+      additional_check = self.class.const_get('VALIDATION')[:additional]
+      return true unless additional_check
 
-    def matches
-      []
+      exist_checks = (additional_check[:exists] ||= [])
+      exist_checks.all? { |w| matching_additional[w] }
     end
 
     def valid_checksum?
-      false
+      return false unless valid_format?
+
+      checksum_info = self.class.const_get(:VALIDATION)[:checksum]
+      return true unless checksum_info
+
+      name            = checksum_info[:name]
+      method_name     = "validates_#{name}?"
+
+      TrackingNumber::ChecksumValidations.send(method_name, serial_number, check_digit, checksum_info)
+    end
+
+    def checksum?
+      !!self.class.const_get(:VALIDATION)[:checksum]
+    end
+
+    LENGTH_WEIGHT = 0.1
+    CHECKSUM_WEIGHT = 5.0
+
+    def confidence
+      (checksum? ? CHECKSUM_WEIGHT : 0) + tracking_number.length * LENGTH_WEIGHT
     end
 
     def to_s
-      self.tracking_number
+      tracking_number
     end
 
     def inspect
-      "#<%s:%#0x %s>" % [self.class.to_s, self.object_id, tracking_number]
+      format('#<%s:%#0x %s%s>', self.class.to_s, object_id, tracking_number, partnership_inspect)
+    end
+
+    def partnership_inspect
+      if shipper? ^ carrier?
+        ' (partnership)'
+      else
+        ''
+      end
+    end
+
+    def info
+      Info.new({
+        courier: courier_info,
+        service_type: service_type,
+        service_description: service_description,
+        destination_zip: destination_zip,
+        shipper_id: shipper_id,
+        package_type: package_type,
+        tracking_url: tracking_url,
+        partners: partners,
+        decode: decode
+      })
+    end
+
+    def courier_code
+      self.class.const_get(:COURIER_CODE).to_sym
+    end
+
+    def courier_name
+      if matching_additional['Courier']
+        matching_additional['Courier'][:courier]
+      elsif self.class.constants.include?(:COURIER_INFO)
+        self.class.const_get(:COURIER_INFO)[:name]
+      end
+    end
+
+    alias carrier courier_code # OG tracking_number gem used :carrier.
+    alias carrier_code courier_code
+    alias carrier_name courier_name
+
+    def courier_info
+      basics = { name: courier_name, code: courier_code }
+
+      if info = matching_additional['Courier']
+        basics.merge!(name: info[:courier], url: info[:courier_url], country: info[:country])
+      end
+
+      @courier ||= Info.new(basics)
+    end
+
+    def partnership?
+      partners.present?
+    end
+
+    def shipper?
+      return true unless partnership?
+
+      partners.shipper == self
+    end
+
+    def carrier?
+      return true unless partnership?
+
+      partners.carrier == self
     end
-  end
 
-  class Unknown < Base
-    def carrier
-      :unknown
+    def partners
+      return unless self.class.const_defined?(:PARTNERS)
+
+      partner_hash = {}
+
+      return unless (partner_tn = find_matching_partner)
+      possible_twin = partner_tn.send(:find_matching_partner, self.class.const_get("ID"))
+
+      if possible_twin.instance_of?(self.class) && possible_twin.tracking_number == tracking_number
+        partner_hash[partner_data[:partner_type].to_sym] = partner_tn
+        partner_hash[partner_tn.partner_data[:partner_type].to_sym] = self
+      end
+
+      PartnerStruct.new(partner_hash[:shipper], partner_hash[:carrier]) if partner_hash.keys.any?
+    end
+
+    def service_type
+      @service_type ||= Info.new(matching_additional['Service Type']).name if matching_additional['Service Type']
+    end
+
+    def service_description
+      @service_description ||= Info.new(matching_additional['Service Type']).description if matching_additional['Service Type']
+    end
+
+    def package_type
+      @package_type ||= Info.new(matching_additional['Container Type']).name if matching_additional['Container Type']
+    end
+
+    def destination_zip
+      match_group('DestinationZip')
+    end
+
+    def shipper_id
+      match_group('ShipperId')
+    end
+
+    def tracking_url
+      url = nil
+      if matching_additional['Courier']
+        url = matching_additional['Courier'][:tracking_url]
+      elsif self.class.const_defined?(:TRACKING_URL)
+        url = self.class.const_get(:TRACKING_URL)
+      end
+
+      url.sub('%s', tracking_number) if url
+    end
+
+    def matching_additional
+      additional = self.class.const_get(:ADDITIONAL) || []
+
+      relevant_sections = {}
+
+      additional.each do |additional_info|
+        next unless matches && matches.length > 0 # skip if no match groups
+
+        value = matches[additional_info[:regex_group_name]].gsub(/\s/, '') # match is empty
+        next unless value
+        next unless additional_info[:lookup]
+
+        matches = additional_info[:lookup].find do |i|
+          if i[:matches]
+            value == i[:matches]
+          elsif i[:matches_regex]
+            value =~ Regexp.new(i[:matches_regex])
+          end
+        end
+
+        # has matching value
+        relevant_sections[additional_info[:name]] = matches
+      end
+
+      relevant_sections
+    end
+
+    protected
+
+    def match_all(items)
+      items.all? do |i|
+        if i[:matches] && matches[i[:regex_group_name]]
+          matches[i[:regex_group_name]] == i[:matches]
+        elsif i[:matches_regex] && matches[i[:regex_group_name]]
+          matches[i[:regex_group_name]] =~ Regexp.new(i[:matches_regex])
+        else
+          false
+        end
+      end
+    end
+
+    def match_any(items)
+      items.find do |i|
+        if i[:matches] && matches[i[:regex_group_name]]
+          matches[i[:regex_group_name]] == i[:matches]
+        elsif i[:matches_regex] && matches[i[:regex_group_name]]
+          matches[i[:regex_group_name]] =~ Regexp.new(i[:matches_regex])
+        else
+          false
+        end
+      end
+    end
+
+    def matches
+      @matches ||= if self.class.constants.include?(:VERIFY_PATTERN)
+                     tracking_number.match(self.class.const_get(:VERIFY_PATTERN))
+                   else
+                     []
+                   end
+    end
+
+    def match_group(name)
+      matches[name].gsub(/\s/, '')
+    rescue StandardError
+      nil
+    end
+
+    def find_matching_partner(partner_id = nil)
+      partner_info = if partner_id 
+        (self.class.const_get(:PARTNERS) || []).select { |info| info[:partner_id]&.to_sym == partner_id.to_sym }
+      else
+        self.class.const_get(:PARTNERS) || []
+      end
+
+      partner_info.each do |partner_data|
+        klass = find_tracking_class_by_id(partner_data[:partner_id])
+
+        return false unless klass
+
+        tn = klass.new(tracking_number)
+        valid = if partner_data.dig(:validation, :matches_all)
+                  tn.valid? && match_all(partner_data.dig(:validation, :matches_all))
+                elsif partner_data.dig(:validation, :matches_any)
+                  tn.valid? && match_any(partner_data.dig(:validation, :matches_any))
+                else
+                  tn.valid?
+                end
+
+        next unless valid
+
+        @partner = tn
+        @partner_data = partner_data
+        break
+      end
+
+      return @partner
+    end
+
+    def find_tracking_class_by_id(id)
+      return unless id
+
+      TrackingNumber::TYPES.detect do |type|
+        type.const_get('ID') == id
+      end
     end
   end
 end

data/lib/tracking_number/checksum_validations.rb

@@ -0,0 +1,119 @@
+module TrackingNumber
+  module ChecksumValidations
+    class << self
+      def validates_s10?(sequence, check_digit, extras = {})
+        weighting = [8,6,4,2,3,5,9,7]
+
+        total = 0
+        sequence.chars.to_a.zip(weighting).each do |(a,b)|
+          total += a.to_i * b.to_i
+        end
+
+        remainder = total % 11
+        check = case remainder
+        when 1
+          0
+        when 0
+          5
+        else
+          11 - remainder
+        end
+
+        return check.to_i == check_digit.to_i
+      end
+
+      def validates_sum_product_with_weightings_and_modulo?(sequence, check_digit, extras = {})
+        weighting = extras[:weightings] || []
+
+        total = 0
+        sequence.chars.to_a.zip(weighting).each do |(a,b)|
+          total += a.to_i * b
+        end
+        return (total % extras[:modulo1] % extras[:modulo2]) == check_digit.to_i
+      end
+
+      def validates_mod10?(sequence, check_digit, extras = {})
+        total = 0
+        characters = if extras[:reverse]
+          sequence.chars.reverse
+        else
+          sequence.chars
+        end
+
+        characters.each_with_index do |c, i|
+          x = if c[/[0-9]/] # numeric
+            c.to_i
+          else
+            (c[0].ord - 3) % 10
+          end
+
+          if extras[:odds_multiplier] && i.odd?
+            x *= extras[:odds_multiplier].to_i
+          elsif extras[:evens_multiplier] && i.even?
+            x *= extras[:evens_multiplier].to_i
+          end
+
+          total += x
+        end
+
+        check = (total % 10)
+        check = (10 - check) unless (check.zero?)
+
+        return (check.to_i == check_digit.to_i)
+      end
+
+      def validates_mod7?(sequence, check_digit, extras = {})
+        # standard mod 7 check
+        return true if sequence.to_i % 7 == check_digit.to_i
+      end
+
+      def validates_mod_37_36?(sequence, check_digit, extras = {})
+        # From https://esolutions.dpd.com/dokumente/DPD_Parcel_Label_Specification_2.4.1_EN.pdf
+
+        mod = 36
+        weights = {A: 10, B: 11, C: 12, D: 13, E: 14, F: 15, G: 16, H: 17, I: 18, J: 19, K: 20, L: 21, M: 22, N: 23, O: 24, P: 25, Q: 26, R: 27, S: 28, T: 29, U: 30, V: 31, W: 32, X: 33, Y: 34, Z: 35}
+        cd = mod
+        sequence.chars.to_a.each do |char, i|
+          val = (char =~ /[A-Za-z]/  ? weights[char.to_sym] : char.to_i)
+
+          cd = val + cd
+          cd = cd - mod if cd > mod
+          cd = cd * 2
+          cd = cd - (mod + 1) if cd > mod
+        end
+
+        cd = (mod + 1) - cd
+        cd = 0 if cd == mod
+        computed = if cd >= 10
+                     weights.find { |a, val| val == cd }[0].to_s
+                   else
+                     cd.to_s
+                   end
+
+        computed == check_digit
+      end
+
+      def validates_luhn?(sequence, check_digit, extras = {})
+        total = 0
+        sequence.chars.reverse.each_with_index do |c, i|
+          x = c.to_i
+
+          if i.even?
+            x *= 2
+          end
+
+          if x > 9
+            x -= 9
+          end
+
+          total += x
+        end
+
+        check = (total % 10)
+        check = (10 - check) unless (check.zero?)
+
+        return (check.to_i == check_digit.to_i)
+      end
+    end
+  end
+end

data/lib/tracking_number/info.rb

@@ -0,0 +1,26 @@
+module TrackingNumber
+  class Info
+    def initialize(info_hash = {})
+      info_hash.keys.each do |key|
+        self.instance_variable_set("@#{key}", info_hash[key])
+        self.class_eval { attr_accessor key }
+      end
+
+      if info_hash.keys.size == 1
+        @default = info_hash[info_hash.keys.first]
+      end
+    end
+
+    def method_missing(name, *args)
+      self.instance_variable_get("@#{name}")
+    end
+
+    def to_s
+      @default || @name
+    end
+
+    def to_json
+
+    end
+  end
+end

data/lib/tracking_number/loader.rb

@@ -0,0 +1,82 @@
+module TrackingNumber
+  module Loader
+    class << self
+      def load_tracking_number_data(couriers_path = File.join(File.dirname(__FILE__), '../data/couriers/'))
+        mapping_data = []
+        tracking_number_types = []
+        Dir.glob(File.join(couriers_path, '/*.json')).each do |file|
+          courier_info = read_courier_info(file)
+
+          courier_info[:tracking_numbers].each do |tracking_info|
+            klass = create_class(courier_info, tracking_info)
+
+            # Do some basic checks on the data file
+            throw 'missing test numbers' unless has_test_numbers?(tracking_info)
+            throw 'missing regex match groups' unless test_numbers_return_required_groups?(tracking_info,
+                                                                                           Regexp.new(klass::VERIFY_PATTERN))
+            const = register_class(klass, tracking_info[:name])
+
+            tracking_number_types.push(const)
+            mapping_data << {
+              class: const,
+              name: courier_info[:name],
+              courier_code: courier_info[:courier_code],
+              info: tracking_info
+            }
+          end
+        end
+
+        TrackingNumber.const_set('TYPES', tracking_number_types)
+
+        mapping_data
+      end
+
+      private
+
+      def has_test_numbers?(tracking)
+        tracking[:test_numbers] && tracking[:test_numbers][:valid]
+      end
+
+      def test_numbers_return_required_groups?(tracking, regex)
+        test_number = tracking[:test_numbers][:valid][0]
+        matches = test_number.match(regex)
+
+        matches['SerialNumber']
+      end
+
+      def read_courier_info(file)
+        JSON.parse(File.read(file)).deep_symbolize_keys!
+      end
+
+      def create_class(courier_info, tracking_info)
+        klass = Class.new(TrackingNumber::Base)
+        klass.const_set('COURIER_CODE', courier_info[:courier_code])
+        info = courier_info.dup
+        info.delete(:tracking_numbers)
+        klass.const_set('COURIER_INFO', info)
+
+        pattern = tracking_info[:regex]
+        pattern = tracking_info[:regex].join if tracking_info[:regex].is_a?(Array)
+
+        verify_pattern = "^#{pattern}$"
+        search_pattern = "\\b#{pattern}\\b"
+
+        klass.const_set('SEARCH_PATTERN', Regexp.new(search_pattern))
+        klass.const_set('VERIFY_PATTERN', Regexp.new(verify_pattern))
+
+        klass.const_set('VALIDATION', tracking_info[:validation])
+        klass.const_set('ADDITIONAL', tracking_info[:additional])
+        klass.const_set('TRACKING_URL', tracking_info[:tracking_url])
+        klass.const_set('PARTNERS', tracking_info[:partners])
+        klass.const_set('ID', tracking_info[:id])
+
+        klass
+      end
+
+      def register_class(klass, tracking_name)
+        klass_name = tracking_name.gsub(/[^0-9A-Za-z]/, '')
+        TrackingNumber.const_set(klass_name, klass)
+      end
+    end
+  end
+end

data/lib/tracking_number/partnership.rb

@@ -0,0 +1,7 @@
+module TrackingNumber
+  class Partnership
+    def initialize(tracking_numbers)
+      
+    end
+  end
+end

data/lib/tracking_number/unknown.rb

@@ -0,0 +1,45 @@
+module TrackingNumber
+  class Unknown < Base
+    COURIER_CODE = :unknown
+
+    def carrier
+      COURIER_CODE
+    end
+
+    def courier_name
+      "Unknown"
+    end
+
+    def valid?
+      false
+    end
+
+    def valid_format?
+      false
+    end
+
+    def valid_checksum?
+      false
+    end
+
+    def shipper?
+      false
+    end
+
+    def carrier?
+      false
+    end
+
+    def partnership?
+      false
+    end
+
+    def decode
+      {}
+    end
+
+    def matching_additional
+      {}
+    end
+  end
+end

data/lib/tracking_number/version.rb

@@ -1,3 +1,3 @@
 module TrackingNumber
-  VERSION = "0.10.5"
+  VERSION = "3.0.0"
 end