fitment 0.1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 21354fe7c73dd378577343e9bd1b41597e1bd9974fec3cecd9b40b5c57474e51
+  data.tar.gz: 562137377c7d88d67d5b9e8ce8084a9e20f2a93e75521b0cd16e28073bf8db71
+SHA512:
+  metadata.gz: e0b44ed21aa425d258493f1849602f3f4c131127e79674efcfc914b96cb8c51d1dc99c540bed33f5c3b572093ac02770a355d1b20743ce1d709cc9228d51da9b
+  data.tar.gz: 3a09c6b0fefdd10cbdc0f3b5c2011fe7082a8db62a568359c39baa0abe5c74422a58437549def0a6cc87a1a92a72caf7ef48d76fa70e9e9a3eba7610e4a3ab52

data/Rakefile

@@ -0,0 +1,87 @@
+require 'rake/testtask'
+
+Rake::TestTask.new :test do |t|
+  t.pattern = "test/*.rb"
+  t.warning = true
+end
+
+task default: :test
+
+desc "Run example scripts"
+task :examples do
+  Dir['examples/**/*.rb'].each { |filepath|
+    puts
+    sh "ruby -Ilib #{filepath}"
+    puts
+  }
+end
+
+#
+# METRICS
+#
+
+begin
+  require 'flog_task'
+  FlogTask.new do |t|
+    t.threshold = 400
+    t.dirs = ['lib']
+    t.verbose = true
+  end
+rescue LoadError
+  warn 'flog_task unavailable'
+end
+
+begin
+  require 'flay_task'
+
+  # Monkey patch here because flay doesn't respect dirs anymore
+  # created mostly by adam12 in #ruby on Libera.Chat
+
+  module FlayTaskExt
+    def define
+      desc "Analyze for code duplication in: #{dirs.join(", ")}"
+      task name do
+        require "flay"
+        flay = Flay.run(dirs)
+        flay.report if verbose
+
+        raise "Flay total too high! #{flay.total} > #{threshold}" if
+          flay.total > threshold
+      end
+      self
+    end
+  end
+
+  FlayTask.prepend(FlayTaskExt)
+
+  FlayTask.new do |t|
+    t.threshold = 100
+    t.dirs = ['lib']
+    t.verbose = true
+  end
+rescue LoadError
+  warn 'flay_task unavailable'
+end
+
+begin
+  require 'roodi_task'
+  RoodiTask.new config: '.roodi.yml', patterns: ['lib/**/*.rb']
+rescue LoadError
+  warn "roodi_task unavailable"
+end
+
+#
+# GEM BUILD / PUBLISH
+#
+
+begin
+  require 'buildar'
+
+  Buildar.new do |b|
+    b.gemspec_file = 'fitment.gemspec'
+    b.version_file = 'VERSION'
+    b.use_git = true
+  end
+rescue LoadError
+  warn "buildar tasks unavailable"
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0.1

data/examples/audi_s3.rb

@@ -0,0 +1,22 @@
+require 'fitment/combo'
+
+FC = Fitment::Combo
+
+stock18 = FC.new_with_params(225, 40, 18, 8, 46)
+stock19 = FC.new_with_params(235, 35, 19, 8, 49)
+after18 = FC.new_with_params(245, 40, 18, 8, 45)
+after19 = FC.new_with_params(245, 35, 19, 8, 49)
+
+puts 'Tire      Wheel     Increase'
+puts '----------------------------'
+puts [stock19, 'Baseline, Factory 19'].join(' ')
+puts [after18, stock19.increase(after18).inspect].join(' ')
+puts [after19, stock19.increase(after19).inspect].join(' ')
+puts
+
+puts 'Tire      Wheel     Increase'
+puts '----------------------------'
+puts [stock18, 'Baseline, Factory 18'].join(' ')
+puts [after18, stock18.increase(after18).inspect].join(' ')
+puts [stock19, stock18.increase(stock19).inspect].join(' ')
+puts [after19, stock18.increase(after19).inspect].join(' ')

data/fitment.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name = 'fitment'
+  s.summary = "Simple, fast, and comprehensive wheel and tire fitment analysis"
+  s.description = "Use this tool to fill out your fenders and get flush"
+  s.authors = ["Rick Hull"]
+  s.homepage = "https://github.com/rickhull/fitment"
+  s.license = "LGPL-3.0"
+
+  s.required_ruby_version = "~> 2"
+
+  s.version = File.read(File.join(__dir__, 'VERSION')).chomp
+
+  s.files = %w[fitment.gemspec VERSION README.md Rakefile]
+  s.files += Dir['lib/**/*.rb']
+  s.files += Dir['test/**/*.rb']
+  s.files += Dir['examples/**/*.rb']
+end

data/lib/fitment/combo.rb

@@ -0,0 +1,227 @@
+require 'fitment'
+
+Fitment.autoload :Tire, 'fitment/tire'
+Fitment.autoload :Wheel, 'fitment/wheel'
+Fitment.autoload :OffsetWheel, 'fitment/wheel'
+
+module Fitment
+  class Combo
+    class ValidationError < RuntimeError; end
+    class DiameterMismatch < ValidationError; end
+    class WidthMismatch < ValidationError; end
+    class MinError < WidthMismatch; end
+    class Max45Error < WidthMismatch; end
+    class MaxError < WidthMismatch; end
+
+    # we'll go from 6" to 10" rim width, with emphasis on 7" to 9"
+    # a set of 3 tire widths for each rim width: min, max45, max
+    # max45 is the maximum width listed at 45% aspect ratio (no higher)
+    # data below is from https://www.tyresizecalculator.com
+    # path: /charts/tire-width-for-a-wheel-rim-size-chart
+    BY_RIM_WIDTH = [[6.0, 175, 185, 225],
+                    [6.5, 195, 195, 235],
+                    [7.0, 195, 215, 255],
+                    [7.5, 205, 225, 265],
+                    [8.0, 225, 245, 275],
+                    [8.5, 235, 255, 295],
+                    [9.0, 255, 275, 305],
+                    [9.5, 255, 285, 315],
+                    [10.0, 275, 295, 295]]
+
+    BELOW_6 = [[3.5, 125, nil, 135],
+               [4.0, 135, nil, 145],
+               [4.5, 145, nil, 165],
+               [5.0, 155, nil, 185],
+               [5.5, 165, 165, 205]]
+
+    ABOVE_10 = [[10.5, 285, 315, 315],
+                [11.0, 305, 315, 345],
+                [11.5, 315, 335, 345],
+                [12.0, 325, 345, 345],
+                [12.5, 345, 345, 345],
+                [13.0, 355, 355, 355]]
+
+    # smoothness / continuity corrections for likely data anomalies
+    BY_RIM_WIDTH[1][1] = 185 # not 195
+    BY_RIM_WIDTH[7][1] = 265 # not 255
+    BY_RIM_WIDTH[8][3] = 325 # not 295
+    ABOVE_10[0][3] = 335     # not 315
+
+    #
+    # Now, let's model the above table with equations
+    # For every x (rim width inches), we have 3 ys (tire width millimeters)
+    # min, max45, max
+    #
+
+    MODELS = {
+      # Linear: y = a + bx (or: mx + b)
+      simple: [20, 40, 75],            # assume 25.4 slope
+      basic: [20.689, 38.467, 74.022], # assume 25.4 slope
+      linear: [[13.222, 26.333],       # r2 = 0.9917
+               [12.333, 28.667],       # r2 = 0.9941
+               [71.889, 25.667]],      # r2 = 0.9926
+    }
+    # Determined via CompSci gem: CompSci::Fit.best(xs, ys)
+    MODELS[:best] = [[:linear, *MODELS[:linear][0]], # r2 = 0.9917; y = a + bx
+                     [:power, 33.389, 0.95213],      # r2 = 0.9943; y = ax^b
+                     [:power, 59.621, 0.74025]]      # r2 = 0.9939; y = ax^b
+    # uses BELOW_6 and ABOVE_10
+    MODELS[:extended] = [[:linear,       30.165, 24.647], # r2 = 0.9954
+                         [:logarithmic, -229.62, 228.82], # r2 = 0.9951
+                         [:logarithmic, -103.60, 183.05]] # r2 = 0.9908
+
+    # rounds to e.g. 235, 245, 255, etc. (per industry convention)
+    def self.snap(flt)
+      ((flt - 5) / 10.0).round * 10 + 5
+    end
+
+    # linear model, given a rim width in inches, determine:
+    # * minimum tire width in mm
+    # * maximum tire width limited to 45% aspect ratio
+    # * maximum tire width above 45% aspect ratio (big truck tires)
+    # * models: :actual, :simple, :basic, :linear, :best, :extended
+    def self.tire_widths(rim_width_in, model = :actual)
+      if model == :actual
+        (BY_RIM_WIDTH + BELOW_6 + ABOVE_10).each { |row|
+          return row[1..3] if rim_width_in == row[0]
+        }
+        raise("no match for model :actual, width #{rim_width_in}")
+      end
+      params = MODELS.fetch(model)
+      case model
+      when :simple, :basic
+        b = MM_PER_INCH
+        params.map { |a| snap(a + b * rim_width_in) }
+      when :linear
+        params.map { |(a, b)| snap(a + b * rim_width_in) }
+      when :best, :extended
+        params.map { |(model, a, b)|
+          snap(case model
+               when :logarithmic
+                 a + b * Math.log(rim_width_in)
+               when :linear
+                 a + b * rim_width_in
+               when :power
+                 a * rim_width_in ** b
+               else
+                 raise("unknown model: #{model}")
+               end)
+        }
+      else
+        raise("unknown model: #{model}")
+      end
+    end
+
+    def self.new_with_params(tread_with, ratio, diameter, width, offset,
+                             et: true)
+      tire = Tire.new(tread_with, ratio, diameter)
+      wheel = et ?
+                Wheel.new(diameter, width, offset) :
+                OffsetWheel.new(diameter, width, offset)
+      Combo.new(wheel: wheel, tire: tire)
+    end
+
+    def self.new_with_offset(t, r, d, w, o)
+      self.new_with_params(t, r, d, w, o, et: false)
+    end
+
+    TIRE_EXCESS = 15 # extra rubber material near the bead relevant to fitment
+
+    attr_accessor :tire, :wheel, :model
+
+    def initialize(tire:, wheel:, model: :actual)
+      @tire = tire
+      @wheel = wheel
+      @model = model
+    end
+
+    def to_s
+      [@tire, @wheel].join(' ')
+    end
+
+    def validate_diameter!
+      wd, twd = @wheel.diameter, @tire.wheel_diameter
+      raise(DiameterMismatch, "wheel: %i; tire: %i" % [wd, twd]) if wd != twd
+      true
+    end
+
+    def validate_width!
+      msg = "tire width %i %s %s %i for wheel width %i"
+
+      min, max45, max = self.class.tire_widths(@wheel.width, @model)
+      raise(MinError, "no min available for width %i" % @wheel.width) if !min
+      if @tire.width < min
+        raise(MinError, msg % [@tire.width, '<', 'min', min, @wheel.width])
+      end
+      if max45 and @tire.ratio <= 45 and @tire.width > max45
+        raise(Max45Error, msg % [@tire.width, '>', 'max45', max45, @wheel.width])
+      end
+      raise(MaxError, "no max available for width %i" % @wheel.width) if !max
+      if @tire.width > max
+        raise(MaxError, msg % [@tire.width, '>', 'max', max, @wheel.width])
+      end
+      true
+    end
+
+    def validate!
+      validate_diameter!
+      validate_width!
+    end
+
+    def short_width
+      Fitment.mm(@wheel.width) + TIRE_EXCESS * 2
+    end
+
+    def short_height
+      Fitment.mm(@wheel.diameter) + TIRE_EXCESS * 2
+    end
+
+    def short_box
+      [short_width.round(2), short_height.round(2)]
+    end
+
+    def tall_width
+      @tire.width
+    end
+
+    def tall_height
+      @tire.od_mm
+    end
+
+    def tall_box
+      [tall_width.round(2), tall_height.round(2)]
+    end
+
+    def bounding_box
+      [[short_width, tall_width].max,
+       [short_height, tall_height].max,]
+    end
+
+    # returns [inside increase, outside increase, diameter increase] for each
+    # of :wheel and :tire
+    #
+    def increase(other)
+      short_width_increase = other.short_width - self.short_width
+      short_height_increase = other.short_height - self.short_height
+      tall_width_increase = other.tall_width - self.tall_width
+      tall_height_increase = other.tall_height - self.tall_height
+
+      # smaller et on other wheel moves it outside; more inside clearance
+      et_decrease = self.wheel.et - other.wheel.et
+
+      halfwidth = short_width_increase * 0.5
+      wheel = [halfwidth - et_decrease, # inner expansion
+               halfwidth + et_decrease, # outer expansion
+               short_height_increase]   # height increase
+
+      halfwidth = tall_width_increase * 0.5
+      tire = [halfwidth - et_decrease,  # inside expansion
+              halfwidth + et_decrease,  # outside expansion
+              tall_height_increase]     # height increase
+
+      { wheel: wheel.map { |flt| flt.round(2) },
+        tire: tire.map { |flt| flt.round(2) }, }
+    end
+    alias_method(:clearance, :increase)
+  end
+end

data/lib/fitment/tire.rb

@@ -0,0 +1,70 @@
+require 'fitment'
+
+module Fitment
+  class Tire
+    def self.ratio_int(ratio_flt)
+      (ratio_flt * 100.0 / 5).round * 5
+    end
+
+    def self.ratio_flt(ratio_int)
+      ratio_int / 100.0
+    end
+
+    # mm
+    def self.sidewall_height(width_mm, ratio_flt)
+      width_mm * ratio_flt
+    end
+
+    # inches
+    def self.overall_diameter(width_mm, ratio_flt, wheel_in)
+      2 * Fitment.in(sidewall_height(width_mm, ratio_flt)) + wheel_in
+    end
+
+    # the aspect ratio is stored as an integer for easy assignment and
+    # comparison, and converted to a float for calculations
+    attr_reader :width, :ratio, :wheel_diameter
+
+    def initialize(width_mm, ratio, wheel_in)
+      @width = width_mm
+      if ratio < 0.99 and ratio > 0.1
+        @ratio = self.class.ratio_int(ratio)
+      elsif ratio.is_a? Integer and ratio%5 == 0 and ratio > 10 and ratio < 99
+        @ratio = ratio
+      else
+        raise("unexpected ratio: #{ratio}")
+      end
+      @wheel_diameter = wheel_in
+    end
+
+    def to_s
+      [[@width, @ratio].join('/'), @wheel_diameter].join('R')
+    end
+
+    def ratio_flt
+      self.class.ratio_flt(@ratio)
+    end
+
+    # sidewall height, (mm) and in
+    def sh_mm
+      self.class.sidewall_height(@width, ratio_flt).round(1)
+    end
+    alias_method :sidewall_height, :sh_mm
+
+    def sh_in
+      Fitment.in(sh_mm).round(2)
+    end
+
+    # overall diameter, mm and (in)
+    def od_in
+      self.class.overall_diameter(@width, ratio_flt, @wheel_diameter).round(2)
+    end
+    alias_method :overall_diameter, :od_in
+
+    alias_method(:series, :ratio)
+    alias_method(:aspect_ratio, :ratio)
+
+    def od_mm
+      Fitment.mm(od_in).round(1)
+    end
+  end
+end

data/lib/fitment/wheel.rb

@@ -0,0 +1,50 @@
+require 'fitment'
+
+module Fitment
+  class Wheel
+    def self.et(offset_in, width_in)
+      (-1 * Fitment.mm(offset_in - width_in / 2)).round
+    end
+
+    def self.offset(et_mm, width_in)
+      (width_in / 2 - Fitment.in(et_mm)).round(2)
+    end
+
+    attr_reader :diameter, :width, :et
+    attr_accessor :bolt_pattern
+
+    def initialize(diameter_in, width_in, et = 0, bolt_pattern: "")
+      @diameter = diameter_in
+      @width = width_in
+      @et = et
+      @bolt_pattern = bolt_pattern
+    end
+
+    def to_s
+      "#{@diameter}x#{@width} ET#{et}  #{@bolt_pattern}".strip
+    end
+
+    def offset
+      self.class.offset(@et, @width)
+    end
+  end
+
+  class OffsetWheel < Wheel
+    attr_reader :offset
+
+    def initialize(diameter_in, width_in, offset_in, bolt_pattern: "")
+      @diameter = diameter_in
+      @width = width_in
+      @offset = offset_in
+      @bolt_pattern = bolt_pattern
+    end
+
+    def to_s
+      "#{@diameter}x#{@width} #{@offset}\" offset  #{@bolt_pattern}".strip
+    end
+
+    def et
+      self.class.et(@offset, @width)
+    end
+  end
+end

data/lib/fitment.rb

@@ -0,0 +1,19 @@
+module Fitment
+  MM_PER_INCH = 25.4
+
+  def self.in(mm)
+    mm.to_f / MM_PER_INCH
+  end
+
+  def self.mm(inches)
+    inches.to_f * MM_PER_INCH
+  end
+
+  # https://www.tiresandco.ca/tire-equivalence-advice.html
+  # [min, ideal, ideal, max]
+  # this is a simple linear model: y = a + bx; a = 55; b = 20
+  # [min, min+10, min+20, min+30]
+  def self.tire_widths(rim_width_in)
+    Array.new(4) { |i| (55 + 20 * rim_width_in + i * 10).round }
+  end
+end

data/test/combo.rb

@@ -0,0 +1,175 @@
+require 'fitment/combo'
+require 'minitest/autorun'
+
+include Fitment
+
+describe Combo do
+  describe "validating tire width against wheel width" do
+    # below should match Combo::BY_RIM_WIDTH
+    ACTUAL = {
+      5.0 => [155, nil, 185],
+      8.0 => [225, 245, 275],
+      9.5 => [265, 285, 315],
+      12.0 => [325, 345, 345],
+    }
+
+    it "snaps to industry standard mm widths" do
+      expect(Combo.snap(254.3)).must_equal 255
+      expect(Combo.snap(250)).must_equal 255
+      expect(Combo.snap(249.9)).must_equal 245
+      expect(Combo.snap(240)).must_equal 245
+      expect(Combo.snap(239.9)).must_equal 235
+    end
+
+    it "uses an :actual tire model" do
+      expect(Combo.tire_widths(5.0, :actual)).must_equal ACTUAL[5.0]
+      expect(Combo.tire_widths(8.0, :actual)).must_equal ACTUAL[8.0]
+      expect(Combo.tire_widths(9.5, :actual)).must_equal ACTUAL[9.5]
+      expect(Combo.tire_widths(12.0, :actual)).must_equal ACTUAL[12.0]
+    end
+
+    it "uses an :extended tire model" do
+      expect(Combo.tire_widths(5.0, :extended)).must_equal [155, 135, 195]
+      expect(Combo.tire_widths(8.0, :extended)).must_equal ACTUAL[8.0]
+      expect(Combo.tire_widths(9.5, :extended)).must_equal [265, 285, 305]
+      expect(Combo.tire_widths(12.0, :extended)).must_equal [325, 335, 355]
+    end
+
+    it "uses a :best tire model" do
+      expect(Combo.tire_widths(5.0, :best)).must_equal [145, 155, 195]
+      expect(Combo.tire_widths(8.0, :best)).must_equal ACTUAL[8.0]
+      expect(Combo.tire_widths(9.5, :best)).must_equal ACTUAL[9.5]
+      expect(Combo.tire_widths(12.0, :best)).must_equal [325, 355, 375]
+    end
+
+    it "uses a :linear tire model" do
+      expect(Combo.tire_widths(5.0, :linear)).must_equal [145, 155, 205]
+      expect(Combo.tire_widths(8.0, :linear)).must_equal ACTUAL[8.0]
+      expect(Combo.tire_widths(9.5, :linear)).must_equal ACTUAL[9.5]
+      expect(Combo.tire_widths(12.0, :linear)).must_equal [325, 355, 375]
+    end
+
+    it "uses a :basic tire model" do
+      expect(Combo.tire_widths(5.0, :basic)).must_equal [145, 165, 205]
+      expect(Combo.tire_widths(8.0, :basic)).must_equal ACTUAL[8.0]
+      expect(Combo.tire_widths(9.5, :basic)).must_equal [265, 275, 315]
+      expect(Combo.tire_widths(12.0, :basic)).must_equal [325, 345, 375]
+    end
+
+    it "uses a :simple tire model" do
+      expect(Combo.tire_widths(5.0, :simple)).must_equal [145, 165, 205]
+      expect(Combo.tire_widths(8.0, :simple)).must_equal ACTUAL[8.0]
+      expect(Combo.tire_widths(9.5, :simple)).must_equal ACTUAL[9.5]
+      expect(Combo.tire_widths(12.0, :simple)).must_equal [325, 345, 375]
+    end
+  end
+
+  describe "real world combo examples" do
+    before do
+      @stock18 = Combo.new_with_params(225, 40, 18, 8, 46)
+      @stock19 = Combo.new_with_params(235, 35, 19, 8, 49)
+
+      @after18 = Combo.new_with_params(245, 40, 18, 8, 45)
+      @after19 = Combo.new_with_params(245, 35, 19, 8, 49)
+
+      @audi = [@stock18, @stock19, @after18, @after19]
+    end
+
+    it "validates the examples" do
+      @audi.each { |combo| expect(combo.validate!).must_equal(true) }
+    end
+
+    it "has a short box" do
+      @audi.each { |combo|
+        expect(combo.short_width).must_be(:>, Fitment.mm(combo.wheel.width))
+        expect(combo.short_height).must_be(:>,
+                                           Fitment.mm(combo.wheel.diameter))
+      }
+    end
+
+    it "has a tall box" do
+      @audi.each { |combo|
+        expect(combo.tall_width).must_equal(combo.tire.width)
+        expect(combo.tall_height).must_equal(combo.tire.od_mm)
+      }
+    end
+
+    it "calculates dimensional increase for a new combo" do
+      new_18 = @stock19.increase(@after18)
+
+      new_18_wheel = new_18.fetch(:wheel)
+      expect(new_18_wheel).must_be_kind_of Array
+      expect(new_18_wheel.length).must_equal 3
+      expect(new_18_wheel[0]).must_be(:<, 0) # smaller et, more inner clearance
+      expect(new_18_wheel[1]).must_be(:>, 0) # smaller et, less outer clearance
+      expect(new_18_wheel[2]).must_be(:<, 0) # smaller diameter wheel
+
+      new_18_tire = new_18.fetch(:tire)
+      expect(new_18_tire).must_be_kind_of Array
+      expect(new_18_tire.length).must_equal 3
+      expect(new_18_tire[0]).must_be(:>, 0) # wider tire outweighs smaller et
+      expect(new_18_tire[1]).must_be(:>, 0) # wider tire and smaller et
+      expect(new_18_tire[1]).must_be(:>, new_18_tire[0]) # smaller et
+      expect(new_18_tire[2]).must_be(:>, 0) # big aspect ratio
+
+      new_19 = @stock19.increase(@after19)
+
+      new_19_wheel = new_19.fetch(:wheel)
+      expect(new_19_wheel).must_be_kind_of Array
+      expect(new_19_wheel.length).must_equal 3
+      expect(new_19_wheel[0]).must_be_within_epsilon(0.0) # same wheel
+      expect(new_19_wheel[1]).must_be_within_epsilon(0.0) # same wheel
+      expect(new_19_wheel[2]).must_be_within_epsilon(0.0) # same wheel
+
+      new_19_tire = new_19.fetch(:tire)
+      expect(new_19_tire).must_be_kind_of Array
+      expect(new_19_tire.length).must_equal 3
+      expect(new_19_tire[0]).must_be(:>, 0) # wider tire, same et
+      expect(new_19_tire[1]).must_be(:>, 0) # wider tire, same et
+      expect(new_19_tire[2]).must_be(:>, 0) # same aspect ratio on wider tire
+    end
+  end
+
+  describe "unlikely combos" do
+    it "validates a truck tire" do
+      truck = Combo.new_with_offset(275, 55, 16, 8, 4)
+      expect(truck.validate!).must_equal true
+
+      too_wide = Combo.new_with_offset(325, 55, 16, 8, 4)
+      expect { too_wide.validate! }.must_raise Combo::MaxError
+    end
+
+    it "rejects wheel size mismatch" do
+      @tire19 = Tire.new(255, 35, 19)
+      @wheel18 = Wheel.new(18, 8, 45)
+      @tire17 = Tire.new(205, 40, 17)
+
+
+      loose = Combo.new(wheel: @wheel18, tire: @tire19)
+      expect { loose.validate_diameter! }.must_raise Combo::DiameterMismatch
+
+      tight = Combo.new(wheel: @wheel18, tire: @tire17)
+      expect { tight.validate_diameter! }.must_raise Combo::DiameterMismatch
+
+      okay = Combo.new(wheel: @wheel18, tire: Tire.new(225, 40, 18))
+      expect(okay.validate_diameter!).must_equal true
+    end
+
+    it "rejects width mismatch" do
+      @wide_tire = Tire.new(315, 35, 18)
+      @narrow_wheel = Wheel.new(18, 6)
+      @narrow_tire = Tire.new(185, 45, 18)
+      @wide_wheel = Wheel.new(18, 11)
+
+      loose  = Combo.new(wheel: @narrow_wheel, tire: @wide_tire)
+      narrow = Combo.new(wheel: @narrow_wheel, tire: @narrow_tire)
+      tight  = Combo.new(wheel: @wide_wheel,   tire: @narrow_tire)
+      wide   = Combo.new(wheel: @wide_wheel,   tire: @wide_tire)
+
+      expect { loose.validate_width! }.must_raise Combo::WidthMismatch
+      expect(narrow.validate_width!).must_equal true
+      expect { tight.validate_width! }.must_raise Combo::WidthMismatch
+      expect(wide.validate_width!).must_equal true
+    end
+  end
+end

data/test/fitment.rb

@@ -0,0 +1,27 @@
+require 'fitment'
+require 'minitest/autorun'
+
+describe Fitment do
+  it "has a conversion constant" do
+    expect(Fitment::MM_PER_INCH).must_equal 25.4
+  end
+
+  it "converts mm to inches and vice versa" do
+    expect(Fitment.in 25.4).must_be_within_epsilon 1.0
+    expect(Fitment.mm 1).must_equal 25.4
+    expect(Fitment.mm 12).must_equal 25.4 * 12
+  end
+
+  it "has a simple linear tire to wheel fitment model" do
+    # from https://www.tiresandco.ca/tire-equivalence-advice.html
+    src_data = {
+      6.0 => [175, 185, 195, 205],
+      8.5 => [225, 235, 245, 255],
+      12.5 => [305, 315, 325, 335],
+    }
+
+    src_data.each { |rim_width, tire_widths|
+      expect(Fitment.tire_widths(rim_width)).must_equal tire_widths
+    }
+  end
+end

data/test/tire.rb

@@ -0,0 +1,82 @@
+require 'fitment/tire'
+require 'minitest/autorun'
+
+T = Fitment::Tire
+
+describe T do
+  before do
+    @w = 245
+    @r = 35
+    @d = 18
+    @t = T.new(@w, @r, @d)
+    @sh_mm = 85.8
+    @od_in = 24.75
+  end
+
+  it "calculates sidewall height" do
+    expect(T.sidewall_height(255, 0.45)).must_be_within_epsilon 255 * 0.45
+    expect(T.sidewall_height(195, 0.55)).must_be_within_epsilon 195 * 0.55
+  end
+
+  it "calculates overall diameter" do
+    expect(T.overall_diameter(255, 0.45, 17)
+          ).must_be_within_epsilon 26.03543307086614
+    expect(T.overall_diameter(255, 0.45, 18)
+          ).must_be_within_epsilon 27.03543307086614
+  end
+
+  it "initializes with width, ratio, and wheel diameter" do
+    expect(@t).must_be_kind_of(T)
+    expect(@t.width).must_equal @w
+    expect(@t.ratio).must_equal @r
+    expect(@t.wheel_diameter).must_equal @d
+  end
+
+  it "intializes with ratio between 0 and 1" do
+    t = T.new(225, 0.35, 18)
+    expect(t).must_be_kind_of(T)
+    expect(t.ratio).must_equal 35
+  end
+
+  it "has a sidewall height in mm and inches" do
+    expect(@t.sidewall_height).must_equal @sh_mm
+    expect(@t.sh_mm).must_equal @sh_mm
+    expect(@t.sh_in).must_be(:<, @sh_mm)
+  end
+
+  it "has an overall diameter in mm and inches" do
+    expect(@t.overall_diameter).must_equal @od_in
+    expect(@t.od_in).must_equal @od_in
+    expect(@t.od_mm).must_be(:>, @od_in)
+  end
+
+  describe "2018 Audi S3" do
+    before do
+      @stock18 = T.new(225, 40, 18)
+      @stock19 = T.new(235, 35, 19)
+
+      @after18 = T.new(245, 40, 18)
+      @after19 = T.new(245, 35, 19)
+    end
+
+    it "compares differences" do
+      expect(@stock18.width).must_be(:<, @stock19.width)
+      expect(@stock18.width).must_be(:<, @after18.width)
+      expect(@stock18.overall_diameter).must_be(:<, @stock19.overall_diameter)
+      expect(@stock18.overall_diameter).must_be(:<, @after18.overall_diameter)
+      expect(@stock18.sidewall_height).must_be(:>, @stock19.sidewall_height)
+      expect(@stock18.sidewall_height).must_be(:<, @after18.sidewall_height)
+
+      expect(@stock19.width).must_be(:<, @after18.width)
+      expect(@stock19.width).must_be(:<, @after19.width)
+      expect(@stock19.overall_diameter).must_be(:<, @after18.overall_diameter)
+      expect(@stock19.overall_diameter).must_be(:<, @after19.overall_diameter)
+      expect(@stock19.sidewall_height).must_be(:<, @after18.sidewall_height)
+      expect(@stock19.sidewall_height).must_be(:<, @after19.sidewall_height)
+
+      expect(@after18.width).must_equal(@after19.width)
+      expect(@after18.overall_diameter).must_be(:<, @after19.overall_diameter)
+      expect(@after18.sidewall_height).must_be(:>, @after19.sidewall_height)
+    end
+  end
+end

data/test/wheel.rb

@@ -0,0 +1,58 @@
+require 'fitment/wheel'
+require 'minitest/autorun'
+
+include Fitment
+
+describe Wheel do
+  it "calculates ET given offset" do
+    expect(Wheel.et(3.5, 8)).must_be_kind_of(Numeric)
+  end
+
+  it "calculates offset given ET" do
+    expect(Wheel.offset(45, 8)).must_be_kind_of(Numeric)
+  end
+
+  it "initializes with diameter and width" do
+    d,w = 18,8
+    wheel = Wheel.new(d, w)
+    expect(wheel).must_be_kind_of Wheel
+    expect(wheel.diameter).must_equal d
+    expect(wheel.width).must_equal w
+    expect(wheel.et).must_equal 0
+    expect(wheel.bolt_pattern).must_equal ""
+  end
+
+  it "initializes with optional ET" do
+    d,w,et = 18,8,35
+    wet = Wheel.new(d, w, et)
+    expect(wet).must_be_kind_of Wheel
+    expect(wet.et).must_equal et
+  end
+
+  it "initializes with optional bolt_pattern" do
+    d,w,bp = 18,8,"5x112"
+    wbp = Wheel.new(d, w, bolt_pattern: bp)
+    expect(wbp).must_be_kind_of Wheel
+    expect(wbp.bolt_pattern).must_equal bp
+  end
+
+  it "allows updates to bolt_pattern" do
+    d,w,bp = 18,8,"5x112"
+    wbp = Wheel.new(d, w)
+    expect(wbp).must_be_kind_of Wheel
+    expect(wbp.bolt_pattern).must_equal ""
+    wbp.bolt_pattern = bp
+    expect(wbp.bolt_pattern).must_equal bp
+  end
+
+  describe OffsetWheel do
+    it "initializes with required offset" do
+      d,w,offset = 20,9,6
+      expect { OffsetWheel.new(d, w) }.must_raise ArgumentError
+      offset = 4
+      wof = OffsetWheel.new(d, w, offset)
+      expect(wof).must_be_kind_of OffsetWheel
+      expect(wof.offset).must_equal offset
+    end
+  end
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: fitment
+version: !ruby/object:Gem::Version
+  version: 0.1.0.1
+platform: ruby
+authors:
+- Rick Hull
+autorequire:
+bindir: bin
+cert_chain: []
+date: 1980-01-01 00:00:00.000000000 Z
+dependencies: []
+description: Use this tool to fill out your fenders and get flush
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- VERSION
+- examples/audi_s3.rb
+- fitment.gemspec
+- lib/fitment.rb
+- lib/fitment/combo.rb
+- lib/fitment/tire.rb
+- lib/fitment/wheel.rb
+- test/combo.rb
+- test/fitment.rb
+- test/tire.rb
+- test/wheel.rb
+homepage: https://github.com/rickhull/fitment
+licenses:
+- LGPL-3.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: Simple, fast, and comprehensive wheel and tire fitment analysis
+test_files: []