dr_light 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03cdec01261b9d5b682f4b85d71009abd4216912aaece529ada333ff4ab910e7
-  data.tar.gz: a2e6c4d8013f389e5872de461e637bc6209365a2561b6cace450fd7d4b1ca367
+  metadata.gz: 6ac81b75a566891c9d1665bfe992e0cae6b17fd58966bdc73ed5262c0324daf7
+  data.tar.gz: 2e35f897b216a715d001ab6e4a18aeb9ccff6e29d9c64670eb707f8697a8c857
 SHA512:
-  metadata.gz: 92a816d6c71135d96fbb5f8435aaf27316f3b44fb946c44592129ffeb8892eeac3a16c715293b978cec43490bc8e9a03587fc6ee476da1a3d0e41771fa13f914
-  data.tar.gz: b4871424ed66e10973c2ef2e24c5197c024c5c2afbbf8d3c88ff1a2c57a3e011e466adb0334ee221f94e7618491d8f261a7918afbebea4876547c5b710167d22
+  metadata.gz: f79b5d554f23111d5b73b9f1e72de7fbee4e947448d8838cd460e053328b7616af3048d5b643bc544a4310f6cab36c71d715af95986d138bf28d1a656e92d5ac
+  data.tar.gz: 931a3d0eff2d2857cadc13e91d4cf948a9aea91f3c0b52015c498708b3fa064a77ea0c9fc5fbd32ecdca0d6ebf6784740a1c2fc40fdaafe8977491f82b8f9a00

data/README.md

@@ -4,12 +4,11 @@ DrLight
 [![Test Coverage](https://codeclimate.com/github/darthjee/dr_light/badges/coverage.svg)](https://codeclimate.com/github/darthjee/dr_light/coverage)
 [![Issue Count](https://codeclimate.com/github/darthjee/dr_light/badges/issue_count.svg)](https://codeclimate.com/github/darthjee/dr_light)
 [![Gem Version](https://badge.fury.io/rb/dr_light.svg)](https://badge.fury.io/rb/dr_light)
-[![Inline docs](http://inch-ci.org/github/darthjee/dr_light.svg?branch=master)](http://inch-ci.org/github/darthjee/dr_light)
 
 
 ![dr_light](https://raw.githubusercontent.com/darthjee/dr_light/master/dr_light.jpg)
 
 Yard Documentation
 -------------------
-https://www.rubydoc.info/gems/dr_light/0.0.2
+https://www.rubydoc.info/gems/dr_light/0.0.3
 

data/config/check_specs.yml

@@ -1,3 +1,4 @@
 ignore:
   - lib/dr_light.rb
   - lib/dr_light/version.rb
+  - lib/dr_light/matchers.rb

data/config/yardstick.yml

@@ -19,6 +19,7 @@ rules:
       - DrLight::ScientificNumber#value
       - DrLight::ScientificNumber#deviance
       - DrLight::ScientificNumber#initialize
+      - DrLight::ScientificNumber::DevianceDistance#initialize
       - DrLight::ScientificNumber::Formatter#initialize
       - DrLight::ScientificNumber::Normalizer#initialize
   ReturnTag:
@@ -27,7 +28,9 @@ rules:
   Summary::Presence:
     enabled: true
     exclude:
+      - DrLight::Matchers::CloseTo#initialize
       - DrLight::ScientificNumber#initialize
+      - DrLight::ScientificNumber::DevianceDistance#initialize
       - DrLight::ScientificNumber::Formatter#initialize
       - DrLight::ScientificNumber::Normalizer#initialize
   Summary::Length:

data/lib/dr_light/matchers.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module DrLight
+  # @api public
+  #
+  # Rspec matchers DSL to be included in rspec
+  #
+  # @example
+  #   RSpec.configure do |config|
+  #     config.include DrLight::Matchers
+  #   end
+  module Matchers
+    autoload :CloseTo, 'dr_light/matchers/close_to'
+
+    # Checks if value is close to expected value
+    #
+    # @overload be_close_to(expected, deviance: nil)
+    #   @param expected [Number] Target to be close to
+    #   @param deviance [Number] Closeness deviance
+    #
+    # @overload be_close_to(expected)
+    #   @param expected [ScientificNumber] target to be close to
+    #
+    # @return [CloseTo]
+    #
+    # @example
+    #   describe DrLight::Matchers do
+    #     describe 'be_close_to' do
+    #       subject(:value) { 10.0 }
+    #
+    #       context 'when they are close' do
+    #         it do
+    #           expect(value).to be_close_to(11, deviance: 1)
+    #         end
+    #       end
+    #
+    #       context 'when they are not close' do
+    #         let(:expected) { DrLight::ScientificNumber.new(9, 0.5) }
+    #
+    #         it do
+    #           expect(value).not_to be_close_to(expected)
+    #         end
+    #       end
+    #     end
+    #   end
+    def be_close_to(expected, deviance: nil)
+      CloseTo.new(expected, deviance)
+    end
+  end
+end

data/lib/dr_light/matchers/close_to.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module DrLight
+  module Matchers
+    # @api private
+    # @author darthjee
+    #
+    # Matcher checking that 2 numbers are
+    # close to each other
+    class CloseTo < RSpec::Matchers::BuiltIn::BaseMatcher
+      # @overload initialize(expected, deviance)
+      #   @param expected [Number] expected value
+      #     to be close to
+      #   @param deviance [Number] Proximity deviance
+      # @overload initialize(expected)
+      #   @param expected [ScientificNumber] expected value
+      #     to be close to
+      def initialize(expected, deviance)
+        @expected = if expected.is_a?(ScientificNumber)
+                      expected
+                    else
+                      ScientificNumber.new(expected, deviance)
+                    end
+      end
+
+      # returns if actual is close to expected
+      #
+      # @return [TrueClass,FalseClass]
+      def matches?(actual)
+        @actual = actual
+
+        distance <= 1.0
+      end
+
+      # returns matcher description on success
+      #
+      # @return [String]
+      def description
+        "be close to #{expected}"
+      end
+
+      # returns message for failure on should
+      #
+      # @return [String]
+      def failure_message_for_should
+        "expected #{actual} to be close to #{expected} but " \
+          "was #{distance} deviances far away"
+      end
+
+      # returns message for failure on should not
+      #
+      # @return [String]
+      def failure_message_for_should_not
+        "expected #{actual} not to be close to #{expected} " \
+          "but was only #{distance} deviances far away"
+      end
+
+      alias failure_message failure_message_for_should
+      alias failure_message_when_negated failure_message_for_should_not
+
+      private
+
+      attr_reader :expected, :actual
+      # @method expected
+      # @api private
+      # @private
+      #
+      # expected value to be close to
+      #
+      # @return [ScientificNumber]
+
+      # @method actual
+      # @api private
+      # @private
+      #
+      # value to be close to expected
+      #
+      # @return [Number,ScientificNumber]
+
+      # distance in deviances between the 2 numbers
+      #
+      # @return [Float]
+      def distance
+        @distance ||= expected.deviance_distance(actual)
+      end
+    end
+  end
+end

data/lib/dr_light/scientific_number.rb

@@ -6,6 +6,9 @@ module DrLight
   #
   # Number to be exibed in scientific number
   class ScientificNumber
+    autoload :DevianceDistance,
+             'dr_light/scientific_number/deviance_distance'
+
     autoload :Formatter,  'dr_light/scientific_number/formatter'
     autoload :Normalizer, 'dr_light/scientific_number/normalizer'
 
@@ -26,9 +29,9 @@ module DrLight
 
     # @param value [Nuber] number to be exibed
     # @param deviance [Number] deviance of number
-    def initialize(value, deviance = 0)
-      @value = value
-      @deviance = deviance
+    def initialize(value, deviance = nil)
+      @value    = value.to_f
+      @deviance = deviance.to_f
     end
 
     # string representation of number
@@ -47,6 +50,29 @@ module DrLight
       )
     end
 
+    # Calculates the distance to another number in deviances
+    #
+    # the deviance will be a composition of both numbers
+    # deviances
+    #
+    # @example With Number
+    #   number = DrLight::ScientificNumber.new(100, 3)
+    #
+    #   number.deviance_distance(115)   # returns 5
+    #
+    # @example With scientifica number
+    #   number = DrLight::ScientificNumber.new(100, 3)
+    #   other  = DrLight::ScientificNumber.new(115, 4)
+    #
+    #   number.deviance_distance(other)   # returns 3
+    #
+    # @see DevianceDistance
+    #
+    # @return [Float] always positive number
+    def deviance_distance(other)
+      DevianceDistance.new(self, other).to_f
+    end
+
     private
 
     # @private

data/lib/dr_light/scientific_number/deviance_distance.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module DrLight
+  class ScientificNumber
+    # @api private
+    #
+    # @author Dathjee
+    #
+    # Class Responsible for calculating distance between 2 numbers
+    # in number of deviances
+    #
+    # The combined deviance of numbers n1(d1), n2(d2)
+    # is d = sqrt(d1 ** 2 + d2 ** 2)
+    #
+    # @example With scientific number
+    #   number = DrLight::ScientificNumber.new(100, 3)
+    #   other  = DrLight::ScientificNumber.new(110, 4)
+    #
+    #   distance = DrLight::ScientificNumber::DevianceDistance.new(
+    #     number, other
+    #   )
+    #
+    #   distance.to_f    # returns 2
+    #
+    # @example With scientific number
+    #   number = DrLight::ScientificNumber.new(100, 3)
+    #   other  = 91
+    #
+    #   distance = DrLight::ScientificNumber::DevianceDistance.new(
+    #     number, other
+    #   )
+    #
+    #   distance.to_f    # returns 3
+    class DevianceDistance
+      # @param number [ScientificNumber] first number
+      # @param other [ScientificNumber,Number] second number
+      def initialize(number, other)
+        @number = number
+
+        @other = if other.is_a?(ScientificNumber)
+                   other
+                 else
+                   ScientificNumber.new(other)
+                 end
+      end
+
+      # Calculates the distance of numbers in deviances
+      #
+      # @return [Float] always positive number
+      def to_f
+        return 0 if difference.zero?
+
+        difference / deviance
+      end
+
+      private
+
+      attr_reader :number, :other
+      # @method number
+      # @api private
+      # @private
+      #
+      # first number
+      #
+      # @return [ScientificNumber]
+
+      # @method other
+      # @api private
+      # @private
+      #
+      # second_number
+      #
+      # @return [ScientificNumber]
+
+      # @private
+      # Raw difference between two numbers
+      #
+      # @return [Float] always positive number
+      def difference
+        @difference ||= (other.value - number.value).abs
+      end
+
+      # @private
+      #
+      # Combined deviances
+      #
+      # Combined deviances of n1(d1) and n2(d2)
+      # is d = sqrt(d1 ** 2 + d2 ** 2)
+      #
+      # @return [Float] always positive number
+      def deviance
+        @deviance ||= Math.sqrt(
+          number.deviance**2 + other.deviance**2
+        )
+      end
+    end
+  end
+end

data/lib/dr_light/scientific_number/formatter.rb

@@ -8,8 +8,8 @@ module DrLight
     # Class responsible for formatting the values of
     # {ScientificNumber}
     class Formatter
-      # @param value [Numeric] number to be exibed
-      # @param deviance [Numeric] deviance of number
+      # @param normalizer [Normalizer] normalizer with number
+      #   and deviance information
       def initialize(normalizer)
         @normalizer = normalizer
       end

data/lib/dr_light/version.rb

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

data/spec/integration/dr_light/matchers_spec.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DrLight::Matchers do
+  describe 'be_close_to' do
+    subject(:value) { 10.0 }
+
+    context 'when passing numbers without deviance' do
+      context 'when they are the same' do
+        it do
+          expect(value).to be_close_to(10)
+        end
+      end
+
+      context 'when they are not the same' do
+        it do
+          expect(value).not_to be_close_to(10.00001)
+        end
+      end
+    end
+
+    context 'when passing numbers with deviance' do
+      context 'when they are the same' do
+        it do
+          expect(value).to be_close_to(10, deviance: 1)
+        end
+      end
+
+      context 'when they are not the same but close' do
+        it do
+          expect(value).to be_close_to(11, deviance: 1)
+        end
+      end
+
+      context 'when they are not the same and not close' do
+        it do
+          expect(value).not_to be_close_to(11.1, deviance: 1)
+        end
+      end
+    end
+
+    context 'when passing scientific number for expected' do
+      context 'when they are the same' do
+        let(:expected) { DrLight::ScientificNumber.new(10, 1) }
+
+        it do
+          expect(value).to be_close_to(expected)
+        end
+      end
+
+      context 'when they are not the same but close' do
+        let(:expected) { DrLight::ScientificNumber.new(9, 1) }
+
+        it do
+          expect(value).to be_close_to(expected)
+        end
+      end
+
+      context 'when they are not the same and not close' do
+        let(:expected) { DrLight::ScientificNumber.new(8.9, 1) }
+
+        it do
+          expect(value).not_to be_close_to(expected)
+        end
+      end
+    end
+
+    context 'when scientific number is close to number' do
+      let(:value) { DrLight::ScientificNumber.new(10, 1) }
+
+      context 'when they are the same' do
+        it do
+          expect(value).to be_close_to(10)
+        end
+      end
+
+      context 'when they are not the same but close' do
+        it do
+          expect(value).to be_close_to(11)
+        end
+      end
+
+      context 'when they are not the same but not close' do
+        it do
+          expect(value).not_to be_close_to(8)
+        end
+      end
+    end
+
+    context 'when both are scientific numbers' do
+      let(:value) { DrLight::ScientificNumber.new(10, 3) }
+
+      context 'when they are the same' do
+        let(:other) { DrLight::ScientificNumber.new(10, 4) }
+
+        it do
+          expect(value).to be_close_to(other)
+        end
+      end
+
+      context 'when they are not the same but close' do
+        let(:other) { DrLight::ScientificNumber.new(5, 4) }
+
+        it do
+          expect(value).to be_close_to(other)
+        end
+      end
+
+      context 'when they are not the same but not close' do
+        let(:other) { DrLight::ScientificNumber.new(16, 4) }
+
+        it do
+          expect(value).not_to be_close_to(other)
+        end
+      end
+    end
+  end
+end

data/spec/integration/yard/dr_light/matchers_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DrLight::Matchers do
+  describe 'be_close_to' do
+    subject(:value) { 10.0 }
+
+    context 'when they are close' do
+      it do
+        expect(value).to be_close_to(11, deviance: 1)
+      end
+    end
+
+    context 'when they are not close' do
+      let(:expected) { DrLight::ScientificNumber.new(9, 0.5) }
+
+      it do
+        expect(value).not_to be_close_to(expected)
+      end
+    end
+  end
+end

data/spec/integration/yard/dr_light/scientific_number/deviance_distance_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DrLight::ScientificNumber::DevianceDistance do
+  describe '#to_f' do
+    describe 'yard' do
+      subject(:distance) { described_class.new(number, other) }
+
+      let(:number) { DrLight::ScientificNumber.new(100, 3) }
+
+      context 'with scientific number' do
+        let(:other) { DrLight::ScientificNumber.new(110, 4) }
+
+        it 'calculates distance' do
+          expect(distance.to_f).to eq(2)
+        end
+      end
+
+      context 'with number' do
+        let(:other) { 91 }
+
+        it 'calculates distance' do
+          expect(distance.to_f).to eq(3)
+        end
+      end
+    end
+  end
+end

data/spec/integration/yard/dr_light/scientific_number_spec.rb

@@ -15,4 +15,22 @@ describe DrLight::ScientificNumber do
       end
     end
   end
+
+  describe 'deviance_distance' do
+    subject(:number) { described_class.new(100, 3) }
+
+    context 'when other is a number' do
+      it 'returns the deviance distance' do
+        expect(number.deviance_distance(115)).to eq(5)
+      end
+    end
+
+    context 'when other is a scientific number' do
+      let(:other) { described_class.new(115, 4) }
+
+      it 'returns the deviance distance' do
+        expect(number.deviance_distance(other)).to eq(3)
+      end
+    end
+  end
 end

data/spec/lib/dr_light/matchers/close_to_spec.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DrLight::Matchers::CloseTo do
+  subject(:matcher) { described_class.new(expected, deviance) }
+
+  let(:expected) { 120 }
+  let(:deviance) { 10 }
+
+  describe '#matches?' do
+    context 'when passing a number' do
+      context 'when passing a number smaller, but within 1 deviance' do
+        let(:number) { 111 }
+
+        it do
+          expect(matcher).to be_matches(number)
+        end
+      end
+
+      context 'when passing a number bigger, but within 2 deviance' do
+        let(:number) { 139 }
+
+        it do
+          expect(matcher).not_to be_matches(number)
+        end
+      end
+
+      context 'when passing a number equal' do
+        let(:number) { 120 }
+
+        it do
+          expect(matcher).to be_matches(number)
+        end
+      end
+    end
+
+    context 'when passing a scientific number without deviance' do
+      context 'when passing a number smaller, but within 1 deviance' do
+        let(:number) { DrLight::ScientificNumber.new(111) }
+
+        it do
+          expect(matcher).to be_matches(number)
+        end
+      end
+
+      context 'when passing a number bigger, but within 2 deviance' do
+        let(:number) { DrLight::ScientificNumber.new(139) }
+
+        it do
+          expect(matcher).not_to be_matches(number)
+        end
+      end
+
+      context 'when passing a number equal' do
+        let(:number) { DrLight::ScientificNumber.new(120) }
+
+        it do
+          expect(matcher).to be_matches(number)
+        end
+      end
+    end
+
+    context 'when passing a scientific number and having no deviance' do
+      let(:deviance) { 0 }
+
+      context 'when passing a number smaller, but within 1 deviance' do
+        let(:number) { DrLight::ScientificNumber.new(111) }
+
+        it do
+          expect(matcher).not_to be_matches(number)
+        end
+      end
+
+      context 'when passing a number bigger, but within 2 deviance' do
+        let(:number) { DrLight::ScientificNumber.new(139) }
+
+        it do
+          expect(matcher).not_to be_matches(number)
+        end
+      end
+
+      context 'when passing a number equal' do
+        let(:number) { DrLight::ScientificNumber.new(120) }
+
+        it do
+          expect(matcher).to be_matches(number)
+        end
+      end
+    end
+
+    context 'when passing a scientific number with deviance' do
+      let(:deviance) { 40 }
+
+      context 'when passing a number smaller, but within 1 deviance' do
+        let(:number) { DrLight::ScientificNumber.new(80, 30) }
+
+        it do
+          expect(matcher).to be_matches(number)
+        end
+      end
+
+      context 'when passing a number bigger, but within 2 deviance' do
+        let(:number) { DrLight::ScientificNumber.new(30, 30) }
+
+        it do
+          expect(matcher).not_to be_matches(number)
+        end
+      end
+
+      context 'when passing a number equal' do
+        let(:number) { DrLight::ScientificNumber.new(120, 30) }
+
+        it do
+          expect(matcher).to be_matches(number)
+        end
+      end
+    end
+
+    context 'when passing a number with deviance and having no deviance' do
+      let(:deviance) { 0 }
+
+      context 'when passing a number smaller, but within 1 deviance' do
+        let(:number) { DrLight::ScientificNumber.new(111, 10) }
+
+        it do
+          expect(matcher).to be_matches(number)
+        end
+      end
+
+      context 'when passing a number bigger, but within 2 deviance' do
+        let(:number) { DrLight::ScientificNumber.new(139, 10) }
+
+        it do
+          expect(matcher).not_to be_matches(number)
+        end
+      end
+
+      context 'when passing a number equal' do
+        let(:number) { DrLight::ScientificNumber.new(120, 10) }
+
+        it do
+          expect(matcher).to be_matches(number)
+        end
+      end
+    end
+  end
+
+  describe '#description' do
+    it 'returns description' do
+      expect(matcher.description)
+        .to eq('be close to 1.20(10)e2')
+    end
+  end
+
+  describe '#failure_message_for_should' do
+    it 'returns failure message' do
+      expect(matcher.failure_message_for_should)
+        .to eq(
+          'expected  to be close to 1.20(10)e2 ' \
+          'but was 12.0 deviances far away'
+        )
+    end
+  end
+
+  describe '#failure_message' do
+    it 'returns failure message' do
+      expect(matcher.failure_message)
+        .to eq(
+          'expected  to be close to 1.20(10)e2 ' \
+          'but was 12.0 deviances far away'
+        )
+    end
+  end
+
+  describe '#failure_message_for_should_not' do
+    it 'returns failure message' do
+      expect(matcher.failure_message_for_should_not)
+        .to eq(
+          'expected  not to be close to 1.20(10)e2 but ' \
+          'was only 12.0 deviances far away'
+        )
+    end
+  end
+
+  describe '#failure_message_when_negated' do
+    it 'returns failure message' do
+      expect(matcher.failure_message_when_negated)
+        .to eq(
+          'expected  not to be close to 1.20(10)e2 but ' \
+          'was only 12.0 deviances far away'
+        )
+    end
+  end
+end

data/spec/lib/dr_light/scientific_number/deviance_distance_spec.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DrLight::ScientificNumber::DevianceDistance do
+  subject(:distance) { described_class.new(number, other) }
+
+  let(:value)    { 120 }
+  let(:deviance) { 10 }
+  let(:number) do
+    DrLight::ScientificNumber.new(value, deviance)
+  end
+
+  describe 'to_f' do
+    context 'when passing a number' do
+      context 'when passing a number smaller, but within 1 deviance' do
+        let(:other) { 111 }
+
+        it do
+          expect(distance.to_f).to be_positive
+        end
+
+        it 'returns deviance distance' do
+          expect(distance.to_f).to eq(0.9)
+        end
+      end
+
+      context 'when passing a number bigger, but within 2 deviance' do
+        let(:other) { 139 }
+
+        it do
+          expect(distance.to_f).to be_positive
+        end
+
+        it 'returns deviance distance' do
+          expect(distance.to_f).to eq(1.9)
+        end
+      end
+
+      context 'when passing a number equal' do
+        let(:other) { 120 }
+
+        it do
+          expect(distance.to_f).to be_zero
+        end
+      end
+    end
+
+    context 'when passing a scientific number without deviance' do
+      context 'when passing a number smaller, but within 1 deviance' do
+        let(:other) { DrLight::ScientificNumber.new(111) }
+
+        it do
+          expect(distance.to_f).to be_positive
+        end
+
+        it 'returns deviance distance' do
+          expect(distance.to_f).to eq(0.9)
+        end
+      end
+
+      context 'when passing a number bigger, but within 2 deviance' do
+        let(:other) { DrLight::ScientificNumber.new(139) }
+
+        it do
+          expect(distance.to_f).to be_positive
+        end
+
+        it 'returns deviance distance' do
+          expect(distance.to_f).to eq(1.9)
+        end
+      end
+
+      context 'when passing a number equal' do
+        let(:other) { DrLight::ScientificNumber.new(120) }
+
+        it do
+          expect(distance.to_f).to be_zero
+        end
+      end
+    end
+
+    context 'when passing a scientific number and having no deviance' do
+      let(:deviance) { 0 }
+
+      context 'when passing a number smaller, but within 1 deviance' do
+        let(:other) { DrLight::ScientificNumber.new(111) }
+
+        it do
+          expect(distance.to_f).to be_positive
+        end
+
+        it do
+          expect(distance.to_f).to eq(Float::INFINITY)
+        end
+      end
+
+      context 'when passing a number bigger, but within 2 deviance' do
+        let(:other) { DrLight::ScientificNumber.new(139) }
+
+        it do
+          expect(distance.to_f).to be_positive
+        end
+
+        it do
+          expect(distance.to_f).to eq(Float::INFINITY)
+        end
+      end
+
+      context 'when passing a number equal' do
+        let(:other) { DrLight::ScientificNumber.new(120) }
+
+        it do
+          expect(distance.to_f).to be_zero
+        end
+      end
+    end
+
+    context 'when passing a scientific number with deviance' do
+      let(:deviance) { 40 }
+
+      context 'when passing a number smaller, but within 1 deviance' do
+        let(:other) { DrLight::ScientificNumber.new(80, 30) }
+
+        it do
+          expect(distance.to_f).to be_positive
+        end
+
+        it 'returns deviance distance with combined deviance' do
+          expect(distance.to_f).to eq(0.8)
+        end
+      end
+
+      context 'when passing a number bigger, but within 2 deviance' do
+        let(:other) { DrLight::ScientificNumber.new(30, 30) }
+
+        it do
+          expect(distance.to_f).to be_positive
+        end
+
+        it 'returns deviance distance with combined deviance' do
+          expect(distance.to_f).to eq(1.8)
+        end
+      end
+
+      context 'when passing a number equal' do
+        let(:other) { DrLight::ScientificNumber.new(120, 30) }
+
+        it do
+          expect(distance.to_f).to be_zero
+        end
+      end
+    end
+
+    context 'when passing a number with deviance and having no deviance' do
+      let(:deviance) { 0 }
+
+      context 'when passing a number smaller, but within 1 deviance' do
+        let(:other) { DrLight::ScientificNumber.new(111, 10) }
+
+        it do
+          expect(distance.to_f).to be_positive
+        end
+
+        it 'returns deviance distance with combined deviance' do
+          expect(distance.to_f).to eq(0.9)
+        end
+      end
+
+      context 'when passing a number bigger, but within 2 deviance' do
+        let(:other) { DrLight::ScientificNumber.new(139, 10) }
+
+        it do
+          expect(distance.to_f).to be_positive
+        end
+
+        it 'returns deviance distance with combined deviance' do
+          expect(distance.to_f).to eq(1.9)
+        end
+      end
+
+      context 'when passing a number equal' do
+        let(:other) { DrLight::ScientificNumber.new(120, 10) }
+
+        it do
+          expect(distance.to_f).to be_zero
+        end
+      end
+    end
+  end
+end

data/spec/lib/dr_light/scientific_number/normalizer_spec.rb

@@ -5,12 +5,13 @@ require 'spec_helper'
 shared_examples 'value normalized' do |order:, expctd_order: 1, devnc_fctr: 0|
   let(:multiplier)          { 0.1 * 10**order }
   let(:expected_multiplier) { 10**expctd_order }
+  let(:random)              { Random.rand * 0.9 + 0.1 }
   let(:deviance) do
     Random.rand * multiplier * devnc_fctr
   end
 
   context 'when value is positive' do
-    let(:value) { Random.rand * multiplier }
+    let(:value) { random * multiplier }
     let(:range) do
       [0.1 * expected_multiplier, expected_multiplier]
     end
@@ -21,7 +22,7 @@ shared_examples 'value normalized' do |order:, expctd_order: 1, devnc_fctr: 0|
   end
 
   context 'when value is positive' do
-    let(:value) { -1 * Random.rand * multiplier }
+    let(:value) { -1 * random * multiplier }
     let(:range) do
       [-expected_multiplier, -0.1 * expected_multiplier]
     end

data/spec/lib/dr_light/scientific_number_spec.rb

@@ -5,6 +5,9 @@ require 'spec_helper'
 describe DrLight::ScientificNumber do
   subject(:number) { described_class.new(value, deviance) }
 
+  let(:value)    { 120 }
+  let(:deviance) { 10 }
+
   describe '#to_s' do
     context 'when there is no deviance' do
       subject(:number) { described_class.new(value) }
@@ -436,4 +439,182 @@ describe DrLight::ScientificNumber do
       end
     end
   end
+
+  describe 'deviance_distance?' do
+    context 'when passing a number' do
+      context 'when passing a number smaller, but within 1 deviance' do
+        let(:other) { 111 }
+
+        it do
+          expect(number.deviance_distance(other)).to be_positive
+        end
+
+        it 'returns deviance distance' do
+          expect(number.deviance_distance(other)).to eq(0.9)
+        end
+      end
+
+      context 'when passing a number bigger, but within 2 deviance' do
+        let(:other) { 139 }
+
+        it do
+          expect(number.deviance_distance(other)).to be_positive
+        end
+
+        it 'returns deviance distance' do
+          expect(number.deviance_distance(other)).to eq(1.9)
+        end
+      end
+
+      context 'when passing a number equal' do
+        let(:other) { 120 }
+
+        it do
+          expect(number.deviance_distance(other)).to be_zero
+        end
+      end
+    end
+
+    context 'when passing a scientific number without deviance' do
+      context 'when passing a number smaller, but within 1 deviance' do
+        let(:other) { described_class.new(111) }
+
+        it do
+          expect(number.deviance_distance(other)).to be_positive
+        end
+
+        it 'returns deviance distance' do
+          expect(number.deviance_distance(other)).to eq(0.9)
+        end
+      end
+
+      context 'when passing a number bigger, but within 2 deviance' do
+        let(:other) { described_class.new(139) }
+
+        it do
+          expect(number.deviance_distance(other)).to be_positive
+        end
+
+        it 'returns deviance distance' do
+          expect(number.deviance_distance(other)).to eq(1.9)
+        end
+      end
+
+      context 'when passing a number equal' do
+        let(:other) { described_class.new(120) }
+
+        it do
+          expect(number.deviance_distance(other)).to be_zero
+        end
+      end
+    end
+
+    context 'when passing a scientific number and having no deviance' do
+      let(:deviance) { 0 }
+
+      context 'when passing a number smaller, but within 1 deviance' do
+        let(:other) { described_class.new(111) }
+
+        it do
+          expect(number.deviance_distance(other)).to be_positive
+        end
+
+        it do
+          expect(number.deviance_distance(other)).to eq(Float::INFINITY)
+        end
+      end
+
+      context 'when passing a number bigger, but within 2 deviance' do
+        let(:other) { described_class.new(139) }
+
+        it do
+          expect(number.deviance_distance(other)).to be_positive
+        end
+
+        it do
+          expect(number.deviance_distance(other)).to eq(Float::INFINITY)
+        end
+      end
+
+      context 'when passing a number equal' do
+        let(:other) { described_class.new(120) }
+
+        it do
+          expect(number.deviance_distance(other)).to be_zero
+        end
+      end
+    end
+
+    context 'when passing a scientific number with deviance' do
+      let(:deviance) { 40 }
+
+      context 'when passing a number smaller, but within 1 deviance' do
+        let(:other) { described_class.new(80, 30) }
+
+        it do
+          expect(number.deviance_distance(other)).to be_positive
+        end
+
+        it 'returns deviance distance with combined deviance' do
+          expect(number.deviance_distance(other)).to eq(0.8)
+        end
+      end
+
+      context 'when passing a number bigger, but within 2 deviance' do
+        let(:other) { described_class.new(30, 30) }
+
+        it do
+          expect(number.deviance_distance(other)).to be_positive
+        end
+
+        it 'returns deviance distance with combined deviance' do
+          expect(number.deviance_distance(other)).to eq(1.8)
+        end
+      end
+
+      context 'when passing a number equal' do
+        let(:other) { described_class.new(120, 30) }
+
+        it do
+          expect(number.deviance_distance(other)).to be_zero
+        end
+      end
+    end
+
+    context 'when passing a number with deviance and having no deviance' do
+      let(:deviance) { 0 }
+
+      context 'when passing a number smaller, but within 1 deviance' do
+        let(:other) { described_class.new(111, 10) }
+
+        it do
+          expect(number.deviance_distance(other)).to be_positive
+        end
+
+        it 'returns deviance distance with combined deviance' do
+          expect(number.deviance_distance(other)).to eq(0.9)
+        end
+      end
+
+      context 'when passing a number bigger, but within 2 deviance' do
+        let(:other) { described_class.new(139, 10) }
+
+        it do
+          expect(number.deviance_distance(other)).to be_positive
+        end
+
+        it 'returns deviance distance with combined deviance' do
+          expect(number.deviance_distance(other)).to eq(1.9)
+        end
+      end
+
+      context 'when passing a number equal' do
+        let(:other) { described_class.new(120, 10) }
+
+        it do
+          expect(number.deviance_distance(other)).to be_zero
+        end
+      end
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -9,6 +9,7 @@ end
 SimpleCov.start 'gem'
 
 require 'dr_light'
+require 'dr_light/matchers'
 require 'pry-nav'
 
 support_files = File.expand_path('spec/support/**/*.rb')
@@ -20,4 +21,5 @@ RSpec.configure do |config|
   config.filter_run_excluding :integration unless ENV['ALL']
 
   config.order = 'random'
+  config.include DrLight::Matchers
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dr_light
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - DarthJee
@@ -257,13 +257,21 @@ files:
 - docker-compose.yml
 - dr_light.gemspec
 - lib/dr_light.rb
+- lib/dr_light/matchers.rb
+- lib/dr_light/matchers/close_to.rb
 - lib/dr_light/scientific_number.rb
+- lib/dr_light/scientific_number/deviance_distance.rb
 - lib/dr_light/scientific_number/formatter.rb
 - lib/dr_light/scientific_number/normalizer.rb
 - lib/dr_light/utils.rb
 - lib/dr_light/version.rb
+- spec/integration/dr_light/matchers_spec.rb
+- spec/integration/yard/dr_light/matchers_spec.rb
+- spec/integration/yard/dr_light/scientific_number/deviance_distance_spec.rb
 - spec/integration/yard/dr_light/scientific_number_spec.rb
 - spec/integration/yard/dr_light/utils_spec.rb
+- spec/lib/dr_light/matchers/close_to_spec.rb
+- spec/lib/dr_light/scientific_number/deviance_distance_spec.rb
 - spec/lib/dr_light/scientific_number/formatter_spec.rb
 - spec/lib/dr_light/scientific_number/normalizer_spec.rb
 - spec/lib/dr_light/scientific_number_spec.rb