danica 2.7.6 → 3.0.0

data/spec/lib/danica/common_spec.rb

@@ -27,7 +27,7 @@ module Danica
 end
 
 describe Danica::Common do
-  subject { clazz.new }
+  subject(:dummy) { clazz.new }
 
   let(:clazz) { described_class::Dummy }
 
@@ -36,7 +36,7 @@ describe Danica::Common do
   describe '#to_f' do
     it do
       expect do
-        subject.to_f
+        dummy.to_f
       end.to raise_error(Danica::Exception::NotImplemented)
     end
   end
@@ -45,39 +45,39 @@ describe Danica::Common do
     context 'when defining to_tex and to_gnu' do
       context 'when requesting :tex' do
         it 'has a string for latex' do
-          expect(subject.to(:tex)).to eq('tex')
+          expect(dummy.to(:tex)).to eq('tex')
         end
       end
 
       context "when requesting 'tex'" do
         it 'has a string for latex' do
-          expect(subject.to('tex')).to eq('tex')
+          expect(dummy.to('tex')).to eq('tex')
         end
       end
 
       context 'when requesting :gnu' do
         it 'has a string for gnu' do
-          expect(subject.to(:gnu)).to eq('gnu')
+          expect(dummy.to(:gnu)).to eq('gnu')
         end
       end
 
       context "when requesting 'gnu'" do
         it 'has a string for gnu' do
-          expect(subject.to('gnu')).to eq('gnu')
+          expect(dummy.to('gnu')).to eq('gnu')
         end
       end
 
       context 'when requesting wrong format' do
         it do
           expect do
-            subject.to('format')
+            dummy.to('format')
           end.to raise_error(Danica::Exception::FormattedNotFound)
         end
       end
 
       context 'when passing options' do
         it 'passes the options ahead' do
-          expect(subject.to(:gnu, opt: 1)).to eq('gnu {:opt=>1}')
+          expect(dummy.to(:gnu, opt: 1)).to eq('gnu {:opt=>1}')
         end
       end
     end
@@ -88,22 +88,22 @@ describe Danica::Common do
       let(:clazz) { described_class::Dummy2 }
 
       it 'returns the call of #to(:tex)' do
-        expect(subject.to_tex).to eq('formatted: tex')
+        expect(dummy.to_tex).to eq('formatted: tex')
       end
     end
 
     context 'when formatted was generated with gnu and with options' do
-      subject { number.gnu(decimals: 3) }
+      subject(:dummy) { number.gnu(decimals: 3) }
 
       let(:number) { Danica::Wrapper::Number.new(1.0 / 3) }
 
       it 'formats with the current options' do
-        expect(subject.to_tex).to eq('0.333')
+        expect(dummy.to_tex).to eq('0.333')
       end
 
       context 'when overwritting options' do
         it 'formats with the current options' do
-          expect(subject.to_tex(decimals: 4)).to eq('0.3333')
+          expect(dummy.to_tex(decimals: 4)).to eq('0.3333')
         end
       end
     end
@@ -114,22 +114,22 @@ describe Danica::Common do
       let(:clazz) { described_class::Dummy2 }
 
       it 'returns the call of #to(:gnu)' do
-        expect(subject.to_gnu).to eq('formatted: gnu')
+        expect(dummy.to_gnu).to eq('formatted: gnu')
       end
     end
 
     context 'when formatted was generated with tex and with options' do
-      subject { number.tex(decimals: 3) }
+      subject(:dummy) { number.tex(decimals: 3) }
 
       let(:number) { Danica::Wrapper::Number.new(1.0 / 3) }
 
       it 'formats with the current options' do
-        expect(subject.to_gnu).to eq('0.333')
+        expect(dummy.to_gnu).to eq('0.333')
       end
 
       context 'when overwritting options' do
         it 'formats with the current options' do
-          expect(subject.to_gnu(decimals: 4)).to eq('0.3333')
+          expect(dummy.to_gnu(decimals: 4)).to eq('0.3333')
         end
       end
     end
@@ -137,17 +137,17 @@ describe Danica::Common do
 
   describe 'to' do
     context 'when already formatted with options' do
-      subject { number.tex(decimals: 3) }
+      subject(:dummy) { number.tex(decimals: 3) }
 
       let(:number) { Danica::Wrapper::Number.new(1.0 / 3) }
 
       it 'uses to with options' do
-        expect(subject.to(:gnu)).to eq('0.333')
+        expect(dummy.to(:gnu)).to eq('0.333')
       end
 
       context 'when calling with options' do
         it 'uses options' do
-          expect(subject.to(:gnu, decimals: 4)).to eq('0.3333')
+          expect(dummy.to(:gnu, decimals: 4)).to eq('0.3333')
         end
       end
     end
@@ -155,43 +155,43 @@ describe Danica::Common do
 
   describe '#tex' do
     it do
-      expect(subject.tex).to be_a(Danica::Formatted)
+      expect(dummy.tex).to be_a(Danica::Formatted)
     end
 
     it 'knows how to return a tex string' do
-      expect(subject.tex.to_s).to eq('tex {:format=>:tex}')
+      expect(dummy.tex.to_s).to eq('tex {:format=>:tex}')
     end
 
     context 'when passing options' do
       it 'uses the arguments' do
-        expect(subject.tex(decimals: 3).to_s).to eq('tex {:format=>:tex, :decimals=>3}')
+        expect(dummy.tex(decimals: 3).to_s).to eq('tex {:format=>:tex, :decimals=>3}')
       end
     end
   end
 
   describe '#gnu' do
     it do
-      expect(subject.gnu).to be_a(Danica::Formatted)
+      expect(dummy.gnu).to be_a(Danica::Formatted)
     end
 
     it 'knows how to return a gnu string' do
-      expect(subject.gnu.to_s).to eq('gnu {:format=>:gnu}')
+      expect(dummy.gnu.to_s).to eq('gnu {:format=>:gnu}')
     end
 
     context 'when passing options' do
       it 'uses the arguments' do
-        expect(subject.gnu(decimals: 3).to_s).to eq('gnu {:format=>:gnu, :decimals=>3}')
+        expect(dummy.gnu(decimals: 3).to_s).to eq('gnu {:format=>:gnu, :decimals=>3}')
       end
     end
   end
 
   describe '#formatted' do
     it do
-      expect(subject.formatted(format: :gnu)).to be_a(Danica::Formatted)
+      expect(dummy.formatted(format: :gnu)).to be_a(Danica::Formatted)
     end
 
     it 'knows how to return to build the string string' do
-      expect(subject.formatted(format: :gnu, decimals: 3).to_s).to eq('gnu {:format=>:gnu, :decimals=>3}')
+      expect(dummy.formatted(format: :gnu, decimals: 3).to_s).to eq('gnu {:format=>:gnu, :decimals=>3}')
     end
   end
 end

data/spec/lib/danica/dsl_spec.rb

@@ -41,11 +41,7 @@ shared_examples 'a class with mapped dsl' do
 end
 
 describe Danica::DSL do
-  class Danica::DSL::Dummy
-    include Danica::DSL
-  end
-
-  let(:subject) { described_class::Dummy.new }
+  subject { described_class::Dummy.new }
 
   it_behaves_like 'a class with mapped dsl'
 

data/spec/lib/danica/equation_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 describe Danica::Equation do
-  subject do
+  subject(:equation) do
     clazz.new
   end
 
@@ -18,12 +18,12 @@ describe Danica::Equation do
 
   describe '.build' do
     it 'returns a class that is also an equation' do
-      expect(subject).to be_a(described_class)
+      expect(equation).to be_a(described_class)
     end
   end
 
   describe '.create' do
-    subject do
+    subject(:equation) do
       described_class.create(:x, :y) do
         left { y }
         right { x**2 }
@@ -31,25 +31,25 @@ describe Danica::Equation do
     end
 
     it 'returns a class that is also an equation' do
-      expect(subject).to be_a(described_class)
+      expect(equation).to be_a(described_class)
     end
   end
 
   describe '#to_f' do
     it do
-      expect { subject.to_f }.to raise_error(Danica::Exception::NotImplemented)
+      expect { equation.to_f }.to raise_error(Danica::Exception::NotImplemented)
     end
   end
 
   describe '#to_tex' do
     it 'joins the expressions in a equation' do
-      expect(subject.to_tex).to eq('y = x^{2}')
+      expect(equation.to_tex).to eq('y = x^{2}')
     end
   end
 
   describe '#to_gnu' do
     it 'joins the expressions in a equation' do
-      expect(subject.to_gnu).to eq('y = x**(2)')
+      expect(equation.to_gnu).to eq('y = x**(2)')
     end
   end
 end

data/spec/lib/danica/expression/gauss_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 describe Danica::Expression::Gauss do
-  subject { described_class::Gauss.new(variables) }
+  subject(:expression) { described_class::Gauss.new(variables) }
 
   let(:variables) do
     {
@@ -20,7 +20,7 @@ describe Danica::Expression::Gauss do
       let(:expected) { '\frac{1}{\theta \cdot \sqrt{2 \cdot \pi}} \cdot e^{-\frac{\left(x -u\right)^{2}}{2 \cdot \theta^{2}}}' }
 
       it 'return the latex format CAM' do
-        expect(subject.to_tex).to eq(expected)
+        expect(expression.to_tex).to eq(expected)
       end
     end
   end
@@ -30,19 +30,19 @@ describe Danica::Expression::Gauss do
       let(:expected) { '(1)/(v * sqrt(2 * pi)) * exp(-((x -u)**(2))/(2 * v**(2)))' }
 
       it 'return the gnu format CAM' do
-        expect(subject.to_gnu).to eq(expected)
+        expect(expression.to_gnu).to eq(expected)
       end
     end
   end
 
   context 'when not passing variables' do
-    subject { described_class::Gauss.new }
+    subject(:expression) { described_class::Gauss.new }
 
     describe '#to_tex' do
       let(:expected) { '\frac{1}{\sigma \cdot \sqrt{2 \cdot \pi}} \cdot e^{-\frac{\left(x -\mu\right)^{2}}{2 \cdot \sigma^{2}}}' }
 
       it 'rely on default variables definition' do
-        expect(subject.to_tex).to eq(expected)
+        expect(expression.to_tex).to eq(expected)
       end
     end
 
@@ -50,7 +50,7 @@ describe Danica::Expression::Gauss do
       let(:expected) { '(1)/(v * sqrt(2 * pi)) * exp(-((x -u)**(2))/(2 * v**(2)))' }
 
       it 'rely on default variables definition' do
-        expect(subject.to_gnu).to eq(expected)
+        expect(expression.to_gnu).to eq(expected)
       end
     end
   end

data/spec/lib/danica/expression_spec.rb

@@ -27,8 +27,6 @@ shared_examples 'a generically generated expression' do
 end
 
 describe Danica::Expression do
-  subject { expression }
-
   let(:variables) { %i[x y] }
   let(:expression_class) do
     described_class.build(*variables) do
@@ -37,7 +35,7 @@ describe Danica::Expression do
   end
 
   describe '.build' do
-    let(:expression) do
+    subject(:expression) do
       expression_class.new
     end
 
@@ -113,7 +111,7 @@ describe Danica::Expression do
   end
 
   describe '.create' do
-    let(:expression) do
+    subject(:expression) do
       described_class.create(*variables) do
         Danica::Operator::Power.new(x, y)
       end
@@ -125,7 +123,7 @@ describe Danica::Expression do
   end
 
   describe 'spatial' do
-    subject { described_class::Spatial.new(variables) }
+    subject(:expression) { described_class::Spatial.new(variables) }
 
     let(:variables) do
       {
@@ -144,7 +142,7 @@ describe Danica::Expression do
         let(:expected) { 'S_0 + V_0 \cdot t + \frac{a \cdot t^{2}}{2}' }
 
         it 'return the latex format CAM' do
-          expect(subject.to_tex).to eq(expected)
+          expect(expression.to_tex).to eq(expected)
         end
       end
     end
@@ -154,7 +152,7 @@ describe Danica::Expression do
         let(:expected) { 'S0 + V0 * t + (a * t**(2))/(2)' }
 
         it 'return the latex format CAM' do
-          expect(subject.to_gnu).to eq(expected)
+          expect(expression.to_gnu).to eq(expected)
         end
       end
     end
@@ -173,7 +171,7 @@ describe Danica::Expression do
         let(:variables) { expected }
 
         it 'returns a hash with the variabels' do
-          expect(subject.variables_hash).to eq(expected)
+          expect(expression.variables_hash).to eq(expected)
         end
       end
 
@@ -183,59 +181,59 @@ describe Danica::Expression do
         end
 
         it 'returns a hash with the variabels' do
-          expect(subject.variables_hash).to eq(expected)
+          expect(expression.variables_hash).to eq(expected)
         end
       end
 
       context 'when variables are not wrapped yet' do
         it 'returns a hash with the variabels' do
-          expect(subject.variables_hash).to eq(expected)
+          expect(expression.variables_hash).to eq(expected)
         end
       end
 
       context 'when changing a variable' do
         before do
-          subject.time = :x
+          expression.time = :x
           expected[:time] = Danica::Wrapper::Variable.new(name: :x)
         end
 
         it do
-          expect(subject.variables_hash).to eq(expected)
+          expect(expression.variables_hash).to eq(expected)
         end
       end
 
       context 'when initializing with array' do
         context 'when variables contain hashes' do
-          subject { described_class::Spatial.new(variables) }
+          subject(:expression) { described_class::Spatial.new(variables) }
 
           let(:variables) { [:t, 'a', { name: :S0, latex: 'S_0' }, { name: :V0, latex: 'V_0' }] }
 
           it 'returns a hash with the variabels' do
-            expect(subject.variables_hash).to eq(expected)
+            expect(expression.variables_hash).to eq(expected)
           end
         end
       end
 
       context 'when initializing with sequence' do
         context 'when variables contain hashes' do
-          subject { described_class::Spatial.new(*variables, {}) }
+          subject(:expression) { described_class::Spatial.new(*variables, {}) }
 
           let(:variables) { [:t, 'a', { name: :S0, latex: 'S_0' }, { name: :V0, latex: 'V_0' }] }
 
           it 'returns a hash with the variabels' do
-            expect(subject.variables_hash).to eq(expected)
+            expect(expression.variables_hash).to eq(expected)
           end
         end
       end
 
       context 'when initializing with variables hash' do
         context 'when variables contain hashes' do
-          subject { described_class::Spatial.new(variables: variables) }
+          subject(:expression) { described_class::Spatial.new(variables: variables) }
 
           let(:variables) { [:t, 'a', { name: :S0, latex: 'S_0' }, { name: :V0, latex: 'V_0' }] }
 
           it 'returns a hash with the variabels' do
-            expect(subject.variables_hash).to eq(expected)
+            expect(expression.variables_hash).to eq(expected)
           end
         end
       end
@@ -243,29 +241,29 @@ describe Danica::Expression do
 
     describe '#variables' do
       context 'when initialized with an array of variables' do
-        subject { described_class::Spatial.new(variables: variables.values) }
+        subject(:expression) { described_class::Spatial.new(variables: variables.values) }
 
         let(:expected) { variables.values.map { |v| Danica::Wrapper::Variable.new(v.is_a?(Hash) ? v : { name: v }) } }
 
         it do
-          expect(subject.variables.compact).to eq(expected)
+          expect(expression.variables.compact).to eq(expected)
         end
       end
 
       context 'when not initializing all variables' do
-        subject { described_class::Spatial.new }
+        subject(:expression) { described_class::Spatial.new }
 
         let(:time) { Danica::Wrapper::Variable.new(name: :t) }
 
         context 'when initialized with an empty variable set' do
           it do
-            expect(subject.variables.compact).not_to be_empty
+            expect(expression.variables.compact).not_to be_empty
           end
         end
 
         context 'when changing a variable' do
           before do
-            subject.time = time
+            expression.time = time
           end
 
           let(:expected_variables) do
@@ -278,21 +276,21 @@ describe Danica::Expression do
           end
 
           it 'returns the list of variables merged default and new variables' do
-            expect(subject.variables.compact).to eq(expected_variables)
+            expect(expression.variables.compact).to eq(expected_variables)
           end
         end
 
         context 'when initializing with a variable set' do
-          subject { described_class::Spatial.new(*names) }
+          subject(:expression) { described_class::Spatial.new(*names) }
 
           let(:names) { %i[t a s0 v0] }
 
           it 'returns the variables given oin initialization' do
-            expect(subject.variables.map(&:name)).to eq(names)
+            expect(expression.variables.map(&:name)).to eq(names)
           end
 
           context 'when initializing variables with a hash out of order' do
-            subject { described_class::Spatial.new variables }
+            subject(:expression) { described_class::Spatial.new variables }
 
             let(:variables) do
               {
@@ -304,7 +302,7 @@ describe Danica::Expression do
             end
 
             it 'returns the variables given on initialization' do
-              expect(subject.variables.map(&:name)).to eq(names)
+              expect(expression.variables.map(&:name)).to eq(names)
             end
           end
         end
@@ -313,7 +311,7 @@ describe Danica::Expression do
 
     describe '#calculate' do
       context 'when all variables have value' do
-        subject { described_class::Spatial.new(time, acceleration, initial_space, initial_velocity) }
+        subject(:expression) { described_class::Spatial.new(time, acceleration, initial_space, initial_velocity) }
 
         let(:time_value) { 2 }
         let(:time) { time_value }
@@ -321,40 +319,40 @@ describe Danica::Expression do
         let(:initial_space) { 1 }
         let(:initial_velocity) { 1 }
 
-        let(:expected) { initial_space + initial_velocity * time_value + acceleration * (time_value**2) / 2.0 }
+        let(:expected) { initial_space + (initial_velocity * time_value) + (acceleration * (time_value**2) / 2.0) }
 
         it 'retuirns the calculated value' do
-          expect(subject.calculate).to eq(expected)
+          expect(expression.calculate).to eq(expected)
         end
 
         context 'when not all variables have value' do
           let(:time) { :t }
 
           it do
-            expect { subject.calculate }.to raise_error(Danica::Exception::NotDefined)
+            expect { expression.calculate }.to raise_error(Danica::Exception::NotDefined)
           end
 
           context 'when calling calculate with a value for the variables' do
             it 'calculate using the given value' do
-              expect(subject.calculate(time_value)).to eq(expected)
+              expect(expression.calculate(time_value)).to eq(expected)
             end
 
             it 'does not change the values of then valued variables' do
               expect do
-                subject.calculate(time_value)
-              end.not_to change(subject.time, :valued?)
+                expression.calculate(time_value)
+              end.not_to change(expression.time, :valued?)
             end
           end
 
           context 'when calling with a hash for the values' do
             it 'calculate using the given value' do
-              expect(subject.calculate(time: time_value)).to eq(expected)
+              expect(expression.calculate(time: time_value)).to eq(expected)
             end
 
             it 'does not change the values of then valued variables' do
               expect do
-                subject.calculate(time: time_value)
-              end.not_to change(subject.time, :valued?)
+                expression.calculate(time: time_value)
+              end.not_to change(expression.time, :valued?)
             end
           end
         end
@@ -364,7 +362,7 @@ describe Danica::Expression do
 
   describe 'baskara' do
     context 'when using the default value for variables' do
-      subject { described_class::Baskara.new }
+      subject(:expression) { described_class::Baskara.new }
 
       it_behaves_like 'an object that respond to basic_methods'
 
@@ -372,7 +370,7 @@ describe Danica::Expression do
         let(:expected) { '\frac{-b \pm \sqrt{b^{2} -4 \cdot a \cdot c}}{2 \cdot a}' }
 
         it 'return the latex format CAM' do
-          expect(subject.to_tex).to eq(expected)
+          expect(expression.to_tex).to eq(expected)
         end
       end
 
@@ -380,7 +378,7 @@ describe Danica::Expression do
         let(:expected) { '(-b + sqrt(b**(2) -4 * a * c))/(2 * a)' }
 
         it 'return the gnu format CAM' do
-          expect(subject.to_gnu).to eq(expected)
+          expect(expression.to_gnu).to eq(expected)
         end
       end
     end