tracking_number 0.10.5 → 1.0.0.pre1

data/lib/tracking_number/base.rb

@@ -1,3 +1,7 @@
+require 'checksum_validations'
+require 'pry'
+require 'active_support'
+
 module TrackingNumber
   class Base
     attr_accessor :tracking_number
@@ -20,34 +24,80 @@ 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.scan(self.const_get(:SEARCH_PATTERN)){
+        #get the match data instead, which is needed with these types of regexes
+        matches << $~
+      }
+
+      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
+        if 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[:prepend_if_missing]
+
+        end
+      end
+
+      return raw_serial
+    end
+
+    def check_digit
+      match_group("CheckDigit")
+    end
+
+    def decode
+      decoded = {}
+      (self.matches.try(:names) || []).each do |name|
+        sym = name.underscore.to_sym
+        decoded[sym] = self.matches[name]
       end
 
-      possibles.flatten.compact.uniq
+      decoded
     end
 
     def valid?
       return false unless valid_format?
       return false unless valid_checksum?
+      return false unless valid_optional_checks?
       return 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 self.valid_format?
+      checksum_info   = self.class.const_get(:VALIDATION)[:checksum]
+      return true unless checksum_info
+
+      name            = checksum_info[:name]
+      method_name     = "validates_#{name}?"
+
+      ChecksumValidations.send(method_name, serial_number, check_digit, checksum_info)
     end
 
     def to_s
@@ -57,11 +107,115 @@ module TrackingNumber
     def inspect
       "#<%s:%#0x %s>" % [self.class.to_s, self.object_id, tracking_number]
     end
-  end
 
-  class Unknown < Base
-    def carrier
-      :unknown
+    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,
+        :package_description => package_description
+      })
+    end
+
+    def courier_code
+      self.class.const_get(:COURIER_CODE).to_sym
+    end
+
+    def courier_name
+      if matching_additional["Courier"]
+        matching_additional["Courier"][:courier]
+      else
+        if self.class.constants.include?(:COURIER_INFO)
+          self.class.const_get(:COURIER_INFO)[:name]
+        end
+      end
+    end
+
+    alias_method :carrier, :courier_code #OG tracking_number gem used :carrier.
+    alias_method :carrier_code, :courier_code
+    alias_method :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 service_type
+      if matching_additional["Service Type"]
+        @service_type ||= Info.new(matching_additional["Service Type"]).name
+      end
+    end
+
+    def service_description
+      if matching_additional["Service Type"]
+        @service_description ||= Info.new(matching_additional["Service Type"]).description
+      end
     end
+
+    def package_type
+      if matching_additional["ContainerType"]
+        @package_type ||= Info.new(matching_additional["Container Type"]).package_info.name
+      end
+    end
+
+    def destination_zip
+      match_group("DestinationZip")
+    end
+
+    def shipper_id
+      match_group("ShipperId")
+    end
+
+    def matching_additional
+      additional = self.class.const_get(:ADDITIONAL) || []
+
+      relevant_sections = {}
+
+      additional.each do |info|
+        if self.matches && self.matches.length > 0
+          if value = self.matches[info[:regex_group_name]].gsub(/\s/, "")
+            # has matching value
+            matches = info[:lookup].find do |i|
+              if i[:matches]
+                value == i[:matches]
+              elsif i[:matches_regex]
+                value =~ Regexp.new(i[:matches_regex])
+              end
+            end
+
+            relevant_sections[info[:name]] = matches
+          end
+        end
+      end
+
+      relevant_sections
+    end
+
+    protected
+
+    def matches
+      if self.class.constants.include?(:VERIFY_PATTERN)
+        self.tracking_number.match(self.class.const_get(:VERIFY_PATTERN))
+      else
+        []
+      end
+    end
+
+    def match_group(name)
+      begin
+        self.matches[name].gsub(/\s/, '')
+      rescue
+        nil
+      end
+    end
+
   end
 end

data/lib/tracking_number/info.rb

@@ -0,0 +1,18 @@
+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 to_s
+      @default || @name
+    end
+  end
+end

data/lib/tracking_number/unknown.rb

@@ -0,0 +1,33 @@
+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 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 = "1.0.0.pre1"
 end

data/test/test_helper.rb

@@ -2,6 +2,7 @@ require 'simplecov'
 SimpleCov.start
 require 'rubygems'
 require 'minitest/autorun'
+require 'minitest/reporters'
 require 'shoulda'
 require 'active_model'
 
@@ -9,6 +10,8 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'tracking_number'
 
+Minitest::Reporters.use! [Minitest::Reporters::DefaultReporter.new(:color => true)]
+
 class Minitest::Test
   def possible_numbers(tracking)
     tracking = tracking.to_s
@@ -33,7 +36,7 @@ class Minitest::Test
   def should_detect_number_variants(valid_number, type)
     possible_strings(valid_number).each do |string|
       results = type.search(string)
-      assert_equal 1, results.size, "could not find #{type} #{valid_number} in #{string}"
+      assert_equal 1, results.size, "could not find #{type} #{valid_number} in #{string} using search regex: #{type::SEARCH_PATTERN}"
     end
   end
 
@@ -44,8 +47,13 @@ class Minitest::Test
     assert t.valid?
   end
 
+  def should_be_invalid_number(invalid_number, type, carrier)
+    t = TrackingNumber.new(invalid_number)
+    assert !t.valid?
+  end
+
   def should_fail_on_check_digit_changes(valid_number)
-    digits = valid_number.chars.to_a
+    digits = valid_number.gsub(/\s/, "").chars.to_a
     last = digits.pop.to_i
     digits << (last  < 2 ? last + 3 : last - 3).to_s
     invalid_number = digits.join

data/test/tracking_number_data_test.rb

@@ -0,0 +1,161 @@
+require 'test_helper'
+
+def load_courier_data(name = :all)
+  if name == :all
+    Dir.glob(File.join(File.dirname(__FILE__), "../lib/data/couriers/*.json")).collect do |file|
+      JSON.parse(File.read(file)).deep_symbolize_keys!
+    end
+  else
+    return JSON.parse(File.join(File.dirname(__FILE__), "../lib/data/couriers/#{name}.json"))
+  end
+end
+
+class TrackingNumberDataTest < Minitest::Test
+  load_courier_data(:all).each do |courier_info|
+    courier_name = courier_info[:name]
+
+    courier_code = courier_info[:courier_code].to_sym
+
+    courier_info[:tracking_numbers].each do |tracking_info|
+      klass_name = tracking_info[:name].gsub(/[^0-9A-Za-z]/, '')
+      klass = "TrackingNumber::#{klass_name}".constantize
+      context "[#{tracking_info[:name]}]" do
+
+        single_valid_number = tracking_info[:test_numbers][:valid].first
+
+        tracking_info[:test_numbers][:valid].each do |valid_number|
+          should "validate #{valid_number} with #{klass_name}" do
+            t = klass.new(valid_number)
+            assert_equal courier_code, t.carrier
+            assert t.valid?, "should be valid"
+          end
+
+          should "detect #{valid_number} as #{klass_name}" do
+            #TODO fix this multiple matching thing
+            matches = TrackingNumber.search(valid_number)
+            assert matches.collect(&:class).include?(klass)
+          end
+
+          if tracking_info[:validation][:checksum]
+            # only run this test if number format has checksum
+            should "fail on check digit changes with #{valid_number}" do
+              should_fail_on_check_digit_changes(valid_number)
+            end
+          end
+
+          should "detect #{valid_number} regardless of spacing" do
+            should_detect_number_variants(valid_number, "TrackingNumber::#{klass_name}".constantize)
+          end
+
+          should "return correct courier code on #{valid_number} when calling #courier_code" do
+            t = klass.new(valid_number)
+            assert_equal courier_info[:courier_code].to_sym, t.courier_code
+            assert_equal courier_info[:courier_code].to_sym, t.courier_code
+          end
+
+          should "return correct courier name on #{valid_number} when calling #courier_name" do
+            t = klass.new(valid_number)
+
+            if (t.matching_additional["Courier"])
+              assert_equal t.matching_additional["Courier"][:courier], t.courier_name
+            else
+              assert_equal courier_name, t.courier_name
+            end
+          end
+
+          should "not throw an error when calling #service_type on #{valid_number}" do
+            t = klass.new(valid_number)
+            service_type = t.service_type
+            assert service_type.is_a?(String) || service_type.nil?
+          end
+
+          should "not throw an error when calling #destination on #{valid_number}" do
+            t = klass.new(valid_number)
+            assert t.destination_zip.is_a?(String) || t.destination_zip.nil?
+          end
+
+          should "not throw an error when calling #shipper on #{valid_number}" do
+            t = klass.new(valid_number)
+            assert t.shipper_id.is_a?(String) || t.shipper_id.nil?
+          end
+
+          should "not throw an error when calling #package_type on #{valid_number}" do
+            t = klass.new(valid_number)
+            assert t.package_type.is_a?(String) || t.package_type.nil?
+          end
+          #
+          # should "not throw an error when calling #info on #{valid_number}" do
+          #   t = klass.new(valid_number)
+          #   info = t.info
+          #   assert info.is_a?(String)
+          # end
+
+          should "not throw an error when calling #decode on #{valid_number}" do
+            t = klass.new(valid_number)
+            decode = t.decode
+            assert decode.is_a?(Hash)
+          end
+
+        end
+
+        tracking_info[:test_numbers][:invalid].each do |invalid_number|
+          should "not validate #{invalid_number} with #{klass_name}" do
+            t = klass.new(invalid_number)
+            assert !t.valid?, "should not be valid"
+          end
+
+          should "not throw an error when calling #service_type on invalid number #{invalid_number}" do
+            t = klass.new(invalid_number)
+            service_type = t.service_type
+            assert service_type.is_a?(String) || service_type.nil?
+          end
+
+          should "not throw an error when calling #destination_zip on invalid number #{invalid_number}" do
+            t = klass.new(invalid_number)
+            destination = t.destination_zip
+            assert  destination.is_a?(String) || destination.nil?
+          end
+
+          should "not throw an error when calling #shipper_id on invalid number #{invalid_number}" do
+            t = klass.new(invalid_number)
+            shipper = t.shipper_id
+            assert shipper.is_a?(String) || shipper.nil?
+          end
+
+          should "not throw an error when calling #package_type on invalid number #{invalid_number}" do
+            t = klass.new(invalid_number)
+            assert t.package_type.is_a?(String) || t.package_type.nil?
+          end
+
+          # should "not throw an error when calling #info on invalid number #{invalid_number}" do
+          #   t = klass.new(invalid_number)
+          #   info = t.info
+          #   assert info.is_a?(String)
+          # end
+
+          should "not throw an error when calling #decode on invalid number #{invalid_number}" do
+            t = klass.new(invalid_number)
+            decode = t.decode
+            assert decode.is_a?(Hash)
+          end
+        end
+      end
+    end
+  end
+
+  test_numbers = []
+  load_courier_data(:all).each do |courier_info|
+    courier_info[:tracking_numbers].each do |tracking_info|
+      test_numbers << tracking_info[:test_numbers][:valid]
+    end
+  end
+
+  test_numbers.flatten!
+
+  test_numbers.each do |number|
+    matches = TrackingNumber.detect_all(number)
+    if (matches.size > 1)
+      puts "WARNING: #{number.gsub(/\s/, '')} matched multiple types => #{matches.collect { |m| m.class.to_s.split("::").last}}"
+    end
+  end
+end