dr_light 0.0.1 → 0.0.2

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+describe DrLight::Utils do
+  describe '.order' do
+    describe 'yard' do
+      it 'returns order 1 for -100' do
+        expect(described_class.order(-100)).to eq(2)
+      end
+
+      it 'returns order -2 for 0.01' do
+        expect(described_class.order(0.01)).to eq(-2)
+      end
+
+      it 'returns order 0 for 0' do
+        expect(described_class.order(0)).to eq(0)
+      end
+    end
+  end
+
+  describe '.order_difference' do
+    describe 'yard' do
+      subject(:difference) do
+        described_class.order_difference(-10, 0.1)
+      end
+
+      it 'returns order difference between numbers' do
+        expect(difference).to eq(2)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,479 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DrLight::ScientificNumber::Formatter do
+  subject(:formatter) { described_class.new(normalizer) }
+
+  let(:normalizer) do
+    DrLight::ScientificNumber::Normalizer.new(value: value, deviance: deviance)
+  end
+
+  describe '#format_string' do
+    context 'when there is no deviance' do
+      let(:deviance) { 0 }
+
+      context 'when negative number only has 2 digits and order 10' do
+        let(:value) { -12 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string).to eq('%<value>.1fe%<exponential>d')
+        end
+      end
+
+      context 'when negative number has 3 digits and order 10^2' do
+        let(:value) { -123 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string).to eq('%<value>.1fe%<exponential>d')
+        end
+      end
+
+      context 'when negative number only has 2 digits and order 1' do
+        let(:value) { -1.2 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string).to eq('%<value>.1f')
+        end
+      end
+
+      context 'when negative number has 3 digits and order 1' do
+        let(:value) { -1.23 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string).to eq('%<value>.1f')
+        end
+      end
+
+      context 'when negative number only has 2 digits and order 10^-1' do
+        let(:value) { -0.12 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string).to eq('%<value>.1fe%<exponential>d')
+        end
+      end
+
+      context 'when negative number has 3 digits and order 10^-1' do
+        let(:value) { -0.123 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string).to eq('%<value>.1fe%<exponential>d')
+        end
+      end
+
+      context 'when positive number only has 2 digits and order 10' do
+        let(:value) { 12 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string).to eq('%<value>.1fe%<exponential>d')
+        end
+      end
+
+      context 'when positive number has 3 digits and order 10^2' do
+        let(:value) { 123 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string).to eq('%<value>.1fe%<exponential>d')
+        end
+      end
+
+      context 'when positive number only has 2 digits and order 1' do
+        let(:value) { 1.2 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string).to eq('%<value>.1f')
+        end
+      end
+
+      context 'when positive number has 3 digits and order 1' do
+        let(:value) { 1.23 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string).to eq('%<value>.1f')
+        end
+      end
+
+      context 'when positive number only has 2 digits and order 10^-1' do
+        let(:value) { 0.12 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string).to eq('%<value>.1fe%<exponential>d')
+        end
+      end
+
+      context 'when positive number has 3 digits and order 10^-1' do
+        let(:value) { 0.123 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string).to eq('%<value>.1fe%<exponential>d')
+        end
+      end
+    end
+
+    context 'when deviance has the same order as the value' do
+      context 'when negative number only has 2 digits and order 10' do
+        let(:value)    { -12 }
+        let(:deviance) { 13 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when negative number has 3 digits and order 10^2' do
+        let(:value)    { -123 }
+        let(:deviance) { 134 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when negative number only has 2 digits and order 1' do
+        let(:value)    { -1.2 }
+        let(:deviance) { 1.3 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)')
+        end
+      end
+
+      context 'when negative number has 3 digits and order 1' do
+        let(:value)    { -1.23 }
+        let(:deviance) { 1.34 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)')
+        end
+      end
+
+      context 'when negative number only has 2 digits and order 10^-1' do
+        let(:value)    { -0.12 }
+        let(:deviance) { 0.13 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when negative number has 3 digits and order 10^-1' do
+        let(:value)    { -0.123 }
+        let(:deviance) { 0.134 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when positive number only has 2 digits and order 10' do
+        let(:value)    { 12 }
+        let(:deviance) { 13 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when positive number has 3 digits and order 10^2' do
+        let(:value)    { 123 }
+        let(:deviance) { 134 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when positive number only has 2 digits and order 1' do
+        let(:value)    { 1.2 }
+        let(:deviance) { 1.3 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)')
+        end
+      end
+
+      context 'when positive number has 3 digits and order 1' do
+        let(:value)    { 1.23 }
+        let(:deviance) { 1.34 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)')
+        end
+      end
+
+      context 'when positive number only has 2 digits and order 10^-1' do
+        let(:value)    { 0.12 }
+        let(:deviance) { 0.13 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when positive number has 3 digits and order 10^-1' do
+        let(:value) { 0.123 }
+        let(:deviance) { 0.134 }
+
+        it 'shows 2 digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)e%<exponential>d')
+        end
+      end
+    end
+
+    context 'when deviance has smaller order than the value' do
+      context 'when negative number only has 2 digits and order 10' do
+        let(:value)    { -12 }
+        let(:deviance) { 0.13 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.3f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when negative number has 3 digits and order 10^2' do
+        let(:value)    { -123 }
+        let(:deviance) { 1.34 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.3f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when negative number only has 2 digits and order 1' do
+        let(:value)    { -1.2 }
+        let(:deviance) { 0.013 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.3f(%<deviance>d)')
+        end
+      end
+
+      context 'when negative number has 3 digits and order 1' do
+        let(:value)    { -1.23 }
+        let(:deviance) { 0.0134 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.3f(%<deviance>d)')
+        end
+      end
+
+      context 'when negative number only has 2 digits and order 10^-1' do
+        let(:value)    { -0.12 }
+        let(:deviance) { 0.0013 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.3f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when negative number has 3 digits and order 10^-1' do
+        let(:value)    { -0.123 }
+        let(:deviance) { 0.00134 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.3f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when positive number only has 2 digits and order 10' do
+        let(:value)    { 12 }
+        let(:deviance) { 0.13 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.3f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when positive number has 3 digits and order 10^2' do
+        let(:value)    { 123 }
+        let(:deviance) { 1.34 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.3f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when positive number only has 2 digits and order 1' do
+        let(:value)    { 1.2 }
+        let(:deviance) { 0.013 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.3f(%<deviance>d)')
+        end
+      end
+
+      context 'when positive number has 3 digits and order 1' do
+        let(:value)    { 1.23 }
+        let(:deviance) { 0.0134 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.3f(%<deviance>d)')
+        end
+      end
+
+      context 'when positive number only has 2 digits and order 10^-1' do
+        let(:value)    { 0.12 }
+        let(:deviance) { 0.0013 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.3f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when positive number has 3 digits and order 10^-1' do
+        let(:value)    { 0.123 }
+        let(:deviance) { 0.00134 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.3f(%<deviance>d)e%<exponential>d')
+        end
+      end
+    end
+
+    context 'when deviance has bigger order than the value' do
+      context 'when negative number only has 2 digits and order 10' do
+        let(:value)    { -12 }
+        let(:deviance) { 130 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when negative number has 3 digits and order 10^2' do
+        let(:value)    { -123 }
+        let(:deviance) { 1340 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when negative number only has 2 digits and order 1' do
+        let(:value)    { -1.2 }
+        let(:deviance) { 13 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when negative number has 3 digits and order 1' do
+        let(:value)    { -1.23 }
+        let(:deviance) { 13.4 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when negative number only has 2 digits and order 10^-1' do
+        let(:value)    { -0.12 }
+        let(:deviance) { 1.3 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)')
+        end
+      end
+
+      context 'when negative number has 3 digits and order 10^-1' do
+        let(:value)    { -0.123 }
+        let(:deviance) { 1.34 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)')
+        end
+      end
+
+      context 'when positive number only has 2 digits and order 10' do
+        let(:value)    { 12 }
+        let(:deviance) { 0.13 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.3f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when positive number has 3 digits and order 10^2' do
+        let(:value)    { 123 }
+        let(:deviance) { 1340 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when positive number only has 2 digits and order 1' do
+        let(:value)    { 1.2 }
+        let(:deviance) { 13 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when positive number has 3 digits and order 1' do
+        let(:value)    { 1.23 }
+        let(:deviance) { 13.4 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)e%<exponential>d')
+        end
+      end
+
+      context 'when positive number only has 2 digits and order 10^-1' do
+        let(:value)    { 0.12 }
+        let(:deviance) { 1.3 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)')
+        end
+      end
+
+      context 'when positive number has 3 digits and order 10^-1' do
+        let(:value)    { 0.123 }
+        let(:deviance) { 1.34 }
+
+        it 'shows 2 deviance digits' do
+          expect(formatter.format_string)
+            .to eq('%<value>.1f(%<deviance>d)')
+        end
+      end
+    end
+  end
+end