vin-validator 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a5df4ad9817a944b9e892d008fea1d0a8100ca175ce877c7bd5b5ea460aedf9
-  data.tar.gz: 12d2a78d042231773507ae62bb9dbf5937f55b1d927a1d7e5ed687c886c9bffb
+  metadata.gz: 38198acef62a76065fc57b5365744bb09b3c85561a7d2b6cbc61ad121caa4585
+  data.tar.gz: 241fedf88d2f32c952bb86ca5d8052daac1838406cd00aa39bd6a919a5a6eb17
 SHA512:
-  metadata.gz: 0a2fd2840b2e28a9e977af637e98b0e117839994625637824fa0bb810d1d5cd248bdad4c9b5e8f9582fd466e32bd5fef58c260f396b6064a42e30632bcd09dd6
-  data.tar.gz: e87b6a2d4d135d8db7d3060f0b406b0a2798a90d730270f1c7eb3efc8938656b2d06f5f91cdc8f70baed3ffed492d7988c74624f43560ca8b9993897c8d8cb09
+  metadata.gz: 12fb8d34b816c5c1d75462ded857db58cc54bb3de8c544e755968c07666f2f78717209d4212aa731d5cf8cd7e6b6dc4333d8929f3b1675abaafca17ba4525d2a
+  data.tar.gz: 7e99a3ba78f2e971c653aa4171465cd1de6491be6b1d369a8ca4d77e873d62f10dfde1533f42428a4f0551d64325683a6946544fb822b4c6cccc69bd8937e37e

data/CHANGELOG.adoc

@@ -0,0 +1,3 @@
+= 1.0.0
+
+* Intial Release

data/README.adoc

@@ -0,0 +1,91 @@
+= Vin-Validator
+
+Gem for gathering info on VINs, optionally using link:https://vpic.nhtsa.dot.gov/api/[NHTSA's API]
+
+== Installation
+
+Add this line to your application's Gemfile:
+
+[source,ruby]
+----
+gem 'vin-validator', require: false
+----
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install vin-validator
+
+== Usage
+
+[source,ruby]
+----
+just_a_vin = 'AA5325L1588827'
+other_vins = %w[13N153201K1533942 1E9AA5325L1588827 1RND48A27GR039983 1RND53A33KR049282]
+
+VinValidator::Knowledge.vin_info(just_a_vin).fetch(just_a_vin)
+
+VinValidator::Knowledge.vin_info(just_a_vin, true).fetch(just_a_vin)
+
+VinValidator::Knowledge.vin_info(other_vins)
+
+VinValidator::Knowledge.vin_info(other_vins, true)
+----
+
+Every call to ``VinValidator::Knowledge::vin_info`` will return a hash.
+Each key in the result is one of the VINs provided, and each value is another hash.
+
+Value hash:
+
+|===
+|Key |Value
+
+|``:errors``
+|``Array<VinValidator::Result>``
+
+|``:nhtsa_errors``
+|``Array<VinValidator::Result>``
+
+|``:vin``
+|``VinValidator::Result``
+
+|``:make``
+|``Array<VinValidator::Result>``
+
+|``:manufacturer``
+|``VinValidator::Result``
+
+|``:model``
+|``VinValidator::Result``
+
+|``:year``
+|``VinValidator::Result``
+
+|``:body_type``
+|``VinValidator::Result``
+
+|``:trailer_type``
+|``VinValidator::Result``
+
+|``:vehicle_type``
+|``VinValidator::Result``
+
+|``:gvw``
+|``VinValidator::Result``
+
+|``:suggested_vin``
+|``VinValidator::Result``
+|===
+
+``VinValidator::Result`` has 3 attributes: ``vin``, ``type``, and ``value``.
+
+* ``vin`` - The vin the result belongs to
+* ``type`` - The type of result (``error``, ``make``, ``year``, etc)
+* ``value`` - The value of the result
+
+== Changelog
+
+See xref:./CHANGELOG.adoc[CHANGELOG] see changes

data/lib/vin-validator.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
+require 'json'
 require_relative 'vin_validator/version'
+require_relative 'vin_validator/knowledge'
+require 'net/http'
 
 module VinValidator
 end

data/lib/vin_validator/api.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module VinValidator
+  class Api
+    class << self
+      # Fetches info about vins. GET request if single VIN is passed in.
+      # More details can be found at +https://vpic.nhtsa.dot.gov/api/Home+
+      #
+      # @param vins [Array<String>, String] vins to check
+      #
+      # @return [Hash]
+      #
+      def vin_info(vins)
+        check_nhtsa = block_given? ? yield : true
+        return {} unless check_nhtsa
+
+        vins_to_check = [vins].flatten.compact.uniq
+
+        api_results =
+          if vins_to_check.size == 1
+            # 1E9AA5325L1588827
+            [single_vin_info(vins_to_check.first)]
+          else
+            # 13N153201K1533942
+            # 1E9AA5325L1588827
+            # 1RND48A27GR039983
+            # 1RND53A33KR049282
+            multiple_vin_infos(vins_to_check)
+          end
+
+        results = {}
+        api_results.each do |result|
+          result[:Results].each do |details|
+            results[details[:VIN]] = details
+          end
+        end
+
+        # '1R1F24822YK501231' => {
+        #   ...
+        #   "TrailerBodyType": "",
+        #   ...
+        #   "VIN": "1R1F24822YK501231",
+        #   ...
+        #   }
+
+        return results
+      end
+
+      private
+
+        # @param vin [String]
+        #
+        # @return [Hash] info about given vin
+        #
+        def single_vin_info(vin)
+          parse_request(build_get_request(vin))
+        end
+
+        # @param vins [Array<String>]
+        #
+        # @return [Array<Hash>] info about given vins
+        #
+        def multiple_vin_infos(vins)
+          vins.each_slice(50).map do |vin_list|
+            parse_request(build_post_request(vin_list))
+          end
+        end
+
+        # @return [Stirng]
+        #
+        def root_api_url
+          'https://vpic.nhtsa.dot.gov/api/vehicles'
+        end
+
+        # @param vin [String]
+        #
+        # @return [Hash]
+        #
+        def build_get_request(vin)
+          url = "#{root_api_url}/DecodeVinValues/#{vin}?format=json"
+          uri = URI(url)
+
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          # Use 5 instead of 60 (default) seconds for NHTSA
+          http.read_timeout = 5
+
+          request = Net::HTTP::Get.new(uri)
+
+          return { http: http, request: request }
+        end
+
+        # @param vins [Array<String>]
+        #
+        # @return [Hash]
+        #
+        def build_post_request(vins)
+          url = "#{root_api_url}/DecodeVINValuesBatch"
+          uri = URI(url)
+
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          # Use 5 instead of 60 (default) seconds for NHTSA
+          http.read_timeout = 5
+
+          request = Net::HTTP::Post.new(uri)
+          request.set_form_data({ data: vins.join(';'), format: 'JSON' })
+
+          return { http: http, request: request }
+        end
+
+        # Sends and parses the request
+        #
+        # @return [Hash<Symbol>]
+        #
+        def parse_request(http_request)
+          response = http_request.fetch(:http).request(http_request.fetch(:request))
+
+          return JSON.parse(response.body, { symbolize_names: true })
+        end
+    end
+  end
+end

data/lib/vin_validator/knowledge.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require_relative './result'
+require_relative './maker'
+require_relative './wmi'
+require_relative './api'
+
+module VinValidator
+  class Knowledge
+    class << self
+      # Gathers/builds info for each vin provided
+      #
+      # @param vins [String, Array<String>]
+      # @param hit_nhtsa [Boolean] if `true`, query NHTSA. default: `false`
+      #
+      # @return [Hash]
+      #
+      def vin_info(vins, hit_nhtsa = false, &block)
+        results = hit_nhtsa ? VinValidator::Api.vin_info(vins, &block) : {}
+
+        Array(vins).to_h do |vin|
+          vin_results = results.fetch(vin, {})
+          [vin, build_results(vin, vin_results)]
+        end
+      end
+
+      private
+
+        # Does the basic checksum and valid character checking
+        #
+        # @param vin [String, Array<String>] the vin characters to check
+        #
+        # @return [Array<String>] the errors
+        #
+        def simple_vin_check(vin)
+          return ['Vin is not equal to 17 characters.'] if vin.length != 17
+
+          vin =
+            if vin.is_a?(Array)
+              vin.map(&:upcase)
+            else
+              vin.upcase.split('')
+            end
+
+          vin_errors = []
+
+          if vin.join('') !~ /^[a-z0-9]{17}$/i
+            vin_errors << 'Only numbers and letters are allowed in VINs'
+          end
+
+          # rubocop:disable Style/EachForSimpleLoop
+          (0..7).each do |slot|
+            # rubocop:enable Style/EachForSimpleLoop
+            # For 1-8, can't have 'I', 'O', or 'Q'
+            if /[ioq]/i =~ vin[slot].to_s
+              vin_errors << "'I', 'O', and 'Q' are not allowed in slot #{slot + 1}."
+            end
+          end
+
+          unless /[0-9x]/i =~ vin[8].to_s # For 9, only 0-9 and 'X' are allowed
+            vin_errors << "Only 0-9 and 'X' are allowed in slot 9."
+          end
+
+          if /[iquz0]/i =~ vin[9].to_s # For 10, can't have 'I', 'O', 'Q', 'U', 'Z', '0'
+            vin_errors << "'I', 'O', 'Q', 'U', 'Z', and 0 are not allowed in slot 10."
+          end
+
+          (10..13).each do |slot|
+            # For 11-14, can't have 'I', 'O', 'Q'
+            if /[ioq]/i =~ vin[slot].to_s
+              vin_errors << "'I', 'O', or 'Q' not allowed in slot #{slot + 1}."
+            end
+          end
+
+          # For 15-17, only 0-9
+          (14..16).each do |slot|
+            unless /[0-9]/i =~ vin[slot].to_s
+              vin_errors << "Only 0-9 allowed in slot #{slot + 1}."
+            end
+          end
+
+          vin_errors << 'Check digit is incorrect.' unless get_check_digit(vin) == vin[8]
+          vin_errors
+        end
+
+        # Calculates the character's value. From wikipedia
+        #
+        # @return [Number, Nil]
+        #
+        def transliterate(c)
+          '0123456789.ABCDEFGH..JKLMN.P.R..STUVWXYZ'.index(c) % 10
+        rescue
+          nil
+        end
+
+        # Calculates the expected check digit for the given vin
+        #
+        # @param vin [String]
+        #
+        # @return [String]
+        #
+        def get_check_digit(vin)
+          map = '0123456789X'
+          weights = '8765432X098765432'
+          sum = 0
+          (0..16).each do |i|
+            value_weight = transliterate(vin[i])
+            return nil if value_weight.nil?
+
+            sum += value_weight * map.index(weights[i])
+          end
+          return map[sum % 11]
+        end
+
+        # Combines T2 and NHTSA's results. Will attempt to create `VinValidator::Result`s
+        #
+        # @return [Hash]
+        #
+        def build_results(vin, vin_nhtsa_results)
+          vin_results =
+            begin
+              parse_nhtsa_results(vin, vin_nhtsa_results)
+            rescue
+              { errors: [] }
+            end
+
+          simple_errors = simple_vin_check(vin)
+          vin_results[:errors] += simple_errors.map do |err|
+            VinValidator::Result.new(vin: vin, type: :error, value: err)
+          end
+
+          reset_vin = !vin_results.has_key?(:vin) || vin_results.dig(:vin).nil?
+          reset_vin ||= vin_results.dig(:vin).value.nil?
+          reset_vin ||= vin_results.dig(:vin).value.empty?
+
+          if reset_vin
+            vin_results[:vin] = VinValidator::Result.new(vin: vin, type: :vin, value: vin)
+          end
+
+          reset_make = !vin_results.has_key?(:make)
+          reset_make ||= vin_results.dig(:make, 0).nil?
+          reset_make ||= vin_results.dig(:make, 0).value.nil?
+          reset_make ||= vin_results.dig(:make, 0).value.empty?
+
+          if reset_make
+            vin_results[:make] =
+              VinValidator::Wmi.where(wmi: vin.strip.split('')[0..2].join).map do |wmi|
+                VinValidator::Result.new(vin: vin, type: :make, value: wmi.maker.name)
+              end
+          end
+
+          return vin_results
+        end
+
+        # @param vin [String] vin to validate
+        # @param results [Hash] NHTSA results
+        #
+        # @return [Hash] errors and addtl info
+        #
+        def parse_nhtsa_results(vin, results)
+          return { errors: [] } if results.empty?
+
+          errors = []
+          errors += results[:ErrorText].split('; ') unless results[:ErrorCode] == '0'
+          errors += Array(results[:AdditionalErrorText])
+
+          return {
+            errors: [],
+            # `nhtsa_errors` because they find too many errors that shouldn't trigger
+            nhtsa_errors: errors.map { |err| VinValidator::Result.new(vin: vin, value: err, type: :error) },
+            vin: VinValidator::Result.new(vin: vin, value: results[:VIN], type: :vin),
+            make: Array(VinValidator::Result.new(vin: vin, value: results[:Make], type: :make)),
+            manufacturer: VinValidator::Result.new(vin: vin, value: results[:Manufacturer], type: :manufacturer),
+            model: VinValidator::Result.new(vin: vin, value: results[:Model], type: :model),
+            year: VinValidator::Result.new(vin: vin, value: results[:ModelYear], type: :year),
+            body_type: VinValidator::Result.new(vin: vin, value: results[:TrailerBodyType], type: :body_type),
+            trailer_type: VinValidator::Result.new(vin: vin, value: results[:TrailerType], type: :trailer_type),
+            vehicle_type: VinValidator::Result.new(vin: vin, value: results[:VehicleType], type: :vehicle_type),
+            gvw: VinValidator::Result.new(vin: vin, value: results[:GVWR], type: :gvw),
+            suggested_vin: VinValidator::Result.new(vin: vin, value: results[:SuggestedVIN], type: :suggested_vin)
+          }
+        end
+    end
+  end
+end

data/lib/vin_validator/maker.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module VinValidator
+  class Maker
+    class << self
+      def all
+        return @all if defined?(@all)
+
+        @all = JSON.parse(File.read('makers.json'), { symbolize_names: true }).to_h { |id, v| [id.to_s, new(**v)] }
+      end
+
+      def find(id)
+        all.fetch(id.to_s)
+      end
+
+      def where(wmi:)
+
+      end
+    end
+
+    # @return [Integer]
+    attr_accessor :id
+    # @return [String]
+    attr_accessor :name
+
+    # :nodoc:
+    def initialize(id:, name:)
+      @id = id
+      @name = name
+    end
+  end
+end

data/lib/vin_validator/result.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module VinValidator
+  class Result
+    # @return [String]
+    attr_accessor :vin
+    # @return [String]
+    attr_accessor :type
+    # @return [String]
+    attr_accessor :value
+
+    # :nodoc:
+    def initialize(vin:, type:, value:)
+      @vin = vin
+      @type = type
+      @value = value
+    end
+  end
+end

data/lib/vin_validator/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module VinValidator
-  VERSION = '0.0.1'
+  VERSION = '0.0.3'
 end

data/lib/vin_validator/wmi.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module VinValidator
+  class Wmi
+    class << self
+      def all
+        return @all if defined?(@all)
+
+        @all = JSON.parse(File.read('wmis.json'), { symbolize_names: true }).to_h { |id, v| [id.to_s, new(**v)] }
+      end
+
+      def find(id)
+        all.fetch(id.to_s)
+      end
+
+      def where(wmi:)
+        all.values.select { |w| w.wmi == wmi }
+      end
+    end
+
+    # @return [Integer]
+    attr_accessor :id
+    # @return [String]
+    attr_accessor :wmi
+    # @return [String, Nil]
+    attr_accessor :wmi_suffix
+    # @return [Integer]
+    attr_accessor :maker_id
+
+    # :nodoc:
+    def initialize(id:, wmi:, maker_id:, wmi_suffix: nil)
+      @id = id
+      @maker_id = maker_id
+      @wmi = wmi
+      @wmi_suffix = wmi_suffix
+    end
+
+    def maker
+      @maker ||= VinValidator::Maker.find(maker_id)
+    end
+  end
+end