danica 2.7.2 → 2.7.7

data/spec/integration/readme/number_spec.rb

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Danica::Wrapper::Number do
-  let(:number) do
-    Danica::Wrapper::Number.new(3)
-  end
-
   subject do
     Danica::DSL.build do
       number(3)
     end
   end
 
+  let(:number) do
+    described_class.new(3)
+  end
+
   it do
     expect(subject).to eq(number)
   end
@@ -25,10 +27,10 @@ describe Danica::Wrapper::Number do
     let(:expected) do
       Danica::Operator::Addition.new(
         Danica::Operator::Power.new(
-          Danica::Wrapper::Variable.new(:x), 
-          Danica::Wrapper::Number.new(2)
+          Danica::Wrapper::Variable.new(:x),
+          described_class.new(2)
         ),
-        Danica::Wrapper::Number.new(3)
+        described_class.new(3)
       )
     end
 
@@ -37,4 +39,3 @@ describe Danica::Wrapper::Number do
     end
   end
 end
-

data/spec/integration/readme/operator_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe MyOperator do
@@ -17,7 +19,7 @@ describe MyOperator do
     subject { described_class.new(x: 2) }
 
     it 'returns the result of the operation' do
-      expect(subject.to_f).to eq(2 ** Math::PI)
+      expect(subject.to_f).to eq(2**Math::PI)
     end
   end
 end

data/spec/integration/readme/variables_spec.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Danica::Wrapper::Variable do
   describe '#to_tex' do
     context 'when initializing with the name' do
       subject do
-        Danica::Wrapper::Variable.new(:x)
+        described_class.new(:x)
       end
 
       it do
@@ -14,7 +16,7 @@ describe Danica::Wrapper::Variable do
 
     context 'when initializing with a hash' do
       subject do
-        Danica::Wrapper::Variable.new(name: :x)
+        described_class.new(name: :x)
       end
 
       it do
@@ -102,17 +104,17 @@ describe Danica::Wrapper::Variable do
   describe 'automatic wrapp' do
     let(:sum) do
       Danica::DSL.build do
-        power(:x, { name: :y }) + :z
+        power(:x, name: :y) + :z
       end
     end
 
     let(:expected) do
       Danica::Operator::Addition.new(
         Danica::Operator::Power.new(
-          Danica::Wrapper::Variable.new(:x),
-          Danica::Wrapper::Variable.new(:y)
+          described_class.new(:x),
+          described_class.new(:y)
         ),
-        Danica::Wrapper::Variable.new(:z)
+        described_class.new(:z)
       )
     end
 

data/spec/lib/danica/common_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module Danica
@@ -17,7 +19,7 @@ module Danica
     class Dummy2
       include Common
 
-      def to(format, **_)
+      def to(format, **_options)
         "formatted: #{format}"
       end
     end
@@ -25,8 +27,10 @@ module Danica
 end
 
 describe Danica::Common do
-  let(:clazz) { described_class::Dummy }
   subject { clazz.new }
+
+  let(:clazz) { described_class::Dummy }
+
   it_behaves_like 'an object that respond to basic_methods'
 
   describe '#to_f' do
@@ -44,31 +48,36 @@ describe Danica::Common do
           expect(subject.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')
         end
       end
+
       context 'when requesting :gnu' do
         it 'has a string for gnu' do
           expect(subject.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')
         end
       end
-      context "when requesting wrong format" do
+
+      context 'when requesting wrong format' do
         it do
           expect do
             subject.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(subject.to(:gnu, opt: 1)).to eq('gnu {:opt=>1}')
         end
       end
     end
@@ -77,19 +86,71 @@ describe Danica::Common do
   describe '#to_tex' do
     context 'when defined the #to method' do
       let(:clazz) { described_class::Dummy2 }
+
       it 'returns the call of #to(:tex)' do
         expect(subject.to_tex).to eq('formatted: tex')
       end
     end
+
+    context 'when formatted was generated with gnu and with options' do
+      subject { 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')
+      end
+
+      context 'when overwritting options' do
+        it 'formats with the current options' do
+          expect(subject.to_tex(decimals: 4)).to eq('0.3333')
+        end
+      end
+    end
   end
 
   describe '#to_gnu' do
     context 'when defined the #to method' do
       let(:clazz) { described_class::Dummy2 }
+
       it 'returns the call of #to(:gnu)' do
         expect(subject.to_gnu).to eq('formatted: gnu')
       end
     end
+
+    context 'when formatted was generated with tex and with options' do
+      subject { 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')
+      end
+
+      context 'when overwritting options' do
+        it 'formats with the current options' do
+          expect(subject.to_gnu(decimals: 4)).to eq('0.3333')
+        end
+      end
+    end
+  end
+
+  describe 'to' do
+    context 'when already formatted with options' do
+      subject { 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')
+      end
+
+      context 'when calling with options' do
+        it 'uses options' do
+          expect(subject.to(:gnu, decimals: 4)).to eq('0.3333')
+        end
+      end
+    end
   end
 
   describe '#tex' do
@@ -98,12 +159,12 @@ describe Danica::Common do
     end
 
     it 'knows how to return a tex string' do
-      expect(subject.tex.to_s).to eq('tex {:decimals=>nil}')
+      expect(subject.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 {:decimals=>3}')
+        expect(subject.tex(decimals: 3).to_s).to eq('tex {:format=>:tex, :decimals=>3}')
       end
     end
   end
@@ -114,23 +175,23 @@ describe Danica::Common do
     end
 
     it 'knows how to return a gnu string' do
-      expect(subject.gnu.to_s).to eq('gnu {:decimals=>nil}')
+      expect(subject.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 {:decimals=>3}')
+        expect(subject.gnu(decimals: 3).to_s).to eq('gnu {:format=>:gnu, :decimals=>3}')
       end
     end
   end
 
   describe '#formatted' do
     it do
-      expect(subject.formatted(:gnu)).to be_a(Danica::Formatted)
+      expect(subject.formatted(format: :gnu)).to be_a(Danica::Formatted)
     end
 
     it 'knows how to return to build the string string' do
-      expect(subject.formatted(:gnu, decimals: 3).to_s).to eq('gnu {:decimals=>3}')
+      expect(subject.formatted(format: :gnu, decimals: 3).to_s).to eq('gnu {:format=>:gnu, :decimals=>3}')
     end
   end
 end

data/spec/lib/danica/dsl_spec.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-shared_context 'a class with alias to a clazz' do |aliaz, clazz, *variables|
+shared_examples 'a class with alias to a clazz' do |aliaz, clazz, *variables|
   it do
     expect(subject).to respond_to(aliaz)
   end
@@ -10,29 +12,29 @@ shared_context 'a class with alias to a clazz' do |aliaz, clazz, *variables|
   end
 end
 
-shared_context 'a class with mapped dsl' do
+shared_examples 'a class with mapped dsl' do
   {
-    addition:       Danica::Operator::Addition,
-    sum:            Danica::Operator::Addition,
+    addition: Danica::Operator::Addition,
+    sum: Danica::Operator::Addition,
     multiplication: Danica::Operator::Multiplication,
-    product:        Danica::Operator::Multiplication,
-    division:       Danica::Operator::Division,
-    power:          Danica::Operator::Power
+    product: Danica::Operator::Multiplication,
+    division: Danica::Operator::Division,
+    power: Danica::Operator::Power
   }.each do |aliaz, clazz|
     it_behaves_like 'a class with alias to a clazz', aliaz, clazz, 2, 3
   end
   {
-    squared_root:  Danica::Operator::SquaredRoot,
-    sqrt:          Danica::Operator::SquaredRoot,
-    exponential:   Danica::Operator::Exponential,
-    sin:           Danica::Operator::Sin,
-    cos:           Danica::Operator::Cos,
-    group:         Danica::Wrapper::Group,
-    negative:      Danica::Wrapper::Negative,
-    number:        Danica::Wrapper::Number,
-    num:           Danica::Wrapper::Number,
-    plus_minus:    Danica::Wrapper::PlusMinus,
-    constant:      Danica::Wrapper::Constant
+    squared_root: Danica::Operator::SquaredRoot,
+    sqrt: Danica::Operator::SquaredRoot,
+    exponential: Danica::Operator::Exponential,
+    sin: Danica::Operator::Sin,
+    cos: Danica::Operator::Cos,
+    group: Danica::Wrapper::Group,
+    negative: Danica::Wrapper::Negative,
+    number: Danica::Wrapper::Number,
+    num: Danica::Wrapper::Number,
+    plus_minus: Danica::Wrapper::PlusMinus,
+    constant: Danica::Wrapper::Constant
   }.each do |aliaz, clazz|
     it_behaves_like 'a class with alias to a clazz', aliaz, clazz, 9
   end
@@ -44,6 +46,7 @@ describe Danica::DSL do
   end
 
   let(:subject) { described_class::Dummy.new }
+
   it_behaves_like 'a class with mapped dsl'
 
   describe '.build' do

data/spec/lib/danica/equation_spec.rb

@@ -1,22 +1,24 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Danica::Equation do
+  subject do
+    clazz.new
+  end
+
   let(:clazz) do
     described_class.build(:x, :y) do
       left { y }
-      right { x ** 2 }
+      right { x**2 }
     end
   end
 
-  subject do
-    clazz.new
-  end
-
   it_behaves_like 'an object that respond to basic_methods'
 
   describe '.build' do
     it 'returns a class that is also an equation' do
-      expect(subject).to be_a(Danica::Equation)
+      expect(subject).to be_a(described_class)
     end
   end
 
@@ -24,12 +26,12 @@ describe Danica::Equation do
     subject do
       described_class.create(:x, :y) do
         left { y }
-        right { x ** 2 }
+        right { x**2 }
       end
     end
 
     it 'returns a class that is also an equation' do
-      expect(subject).to be_a(Danica::Equation)
+      expect(subject).to be_a(described_class)
     end
   end
 

data/spec/lib/danica/expressable_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 class Danica::Expressable::Dummy
@@ -9,12 +11,13 @@ class Danica::Expressable::Dummy
 end
 
 describe Danica::Expressable do
-  let(:clazz) { described_class::Dummy }
   subject do
     clazz.create(:x) { x }
   end
 
-  it_behaves_like 'an object that respond to basic_methods', ignore: %i(valued? container? is_grouped? priority)
+  let(:clazz) { described_class::Dummy }
+
+  it_behaves_like 'an object that respond to basic_methods', ignore: %i[valued? container? is_grouped? priority]
 
   describe '.build' do
     it 'responds to build' do

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

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Danica::Expression::Gauss do
+  subject { described_class::Gauss.new(variables) }
+
   let(:variables) do
     {
       x: :x,
@@ -9,12 +13,11 @@ describe Danica::Expression::Gauss do
     }
   end
 
-  subject { described_class::Gauss.new(variables) }
   it_behaves_like 'an object that respond to basic_methods'
 
   describe '#to_tex' do
     context 'when creating the spatial operator for constantly accelerated movement' do
-      let(:expected) { '\frac{1}{\theta \cdot \sqrt{2 \cdot \pi}} \cdot e^{-\frac{\left(x -u\right)^{2}}{2 \cdot \theta^{2}}}'  }
+      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)
@@ -36,7 +39,7 @@ describe Danica::Expression::Gauss do
     subject { 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}}}'  }
+      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)

data/spec/lib/danica/expression_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 shared_examples 'a generically generated expression' do
@@ -25,18 +27,20 @@ shared_examples 'a generically generated expression' do
 end
 
 describe Danica::Expression do
-  let(:variables) { %i(x y) }
+  subject { expression }
+
+  let(:variables) { %i[x y] }
   let(:expression_class) do
     described_class.build(*variables) do
       Danica::Operator::Power.new(x, y)
     end
   end
-  subject { expression }
 
   describe '.build' do
     let(:expression) do
       expression_class.new
     end
+
     it_behaves_like 'an object with basic operation'
     it_behaves_like 'an object that respond to basic_methods'
     it_behaves_like 'a generically generated expression'
@@ -84,7 +88,7 @@ describe Danica::Expression do
       it_behaves_like 'an object that respond to basic_methods'
 
       it 'has the defined variables on class definition' do
-        expect(expression_class.variables_names).to eq([:x, :y])
+        expect(expression_class.variables_names).to eq(%i[x y])
       end
 
       it 'has the defined variables' do
@@ -114,12 +118,15 @@ describe Danica::Expression do
         Danica::Operator::Power.new(x, y)
       end
     end
+
     it_behaves_like 'an object with basic operation'
     it_behaves_like 'an object that respond to basic_methods'
     it_behaves_like 'a generically generated expression'
   end
 
   describe 'spatial' do
+    subject { described_class::Spatial.new(variables) }
+
     let(:variables) do
       {
         time: :t,
@@ -129,13 +136,12 @@ describe Danica::Expression do
       }
     end
 
-    subject { described_class::Spatial.new(variables) }
     it_behaves_like 'an object with basic operation'
     it_behaves_like 'an object that respond to basic_methods'
 
     describe '#to_tex' do
       context 'when creating the spatial operator for constantly accelerated movement' do
-        let(:expected) { 'S_0 + V_0 \cdot t + \frac{a \cdot t^{2}}{2}'  }
+        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)
@@ -145,7 +151,7 @@ describe Danica::Expression do
 
     describe '#to_gnu' do
       context 'when creating the spatial operator for constantly accelerated movement' do
-        let(:expected) { 'S0 + V0 * t + (a * t**(2))/(2)'  }
+        let(:expected) { 'S0 + V0 * t + (a * t**(2))/(2)' }
 
         it 'return the latex format CAM' do
           expect(subject.to_gnu).to eq(expected)
@@ -158,13 +164,14 @@ describe Danica::Expression do
         {
           time: Danica::Wrapper::Variable.new(name: :t),
           acceleration: Danica::Wrapper::Variable.new(name: 'a'),
-          initial_space: Danica::Wrapper::Variable.new( name: :S0, latex: 'S_0' ),
-          initial_velocity: Danica::Wrapper::Variable.new( name: :V0, latex: 'V_0' )
+          initial_space: Danica::Wrapper::Variable.new(name: :S0, latex: 'S_0'),
+          initial_velocity: Danica::Wrapper::Variable.new(name: :V0, latex: 'V_0')
         }
       end
 
       context 'when variables are already wrapped with Danica::Wrapper::Variable' do
         let(:variables) { expected }
+
         it 'returns a hash with the variabels' do
           expect(subject.variables_hash).to eq(expected)
         end
@@ -198,10 +205,11 @@ describe Danica::Expression do
       end
 
       context 'when initializing with array' do
-        context 'as hash' do
-          let(:variables) { [ :t, 'a', {name: :S0, latex: 'S_0'}, { name: :V0, latex: 'V_0' } ] }
+        context 'when variables contain hashes' do
           subject { 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)
           end
@@ -209,21 +217,23 @@ describe Danica::Expression do
       end
 
       context 'when initializing with sequence' do
-        context 'as hash' do
-          let(:variables) { [ :t, 'a', {name: :S0, latex: 'S_0'}, { name: :V0, latex: 'V_0' } ] }
+        context 'when variables contain hashes' do
           subject { 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)
           end
         end
       end
 
-      context 'when initializing with variables array' do
-        context 'as hash' do
-          let(:variables) { [ :t, 'a', {name: :S0, latex: 'S_0'}, { name: :V0, latex: 'V_0' } ] }
+      context 'when initializing with variables hash' do
+        context 'when variables contain hashes' do
           subject { 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)
           end
@@ -234,7 +244,9 @@ describe Danica::Expression do
     describe '#variables' do
       context 'when initialized with an array of variables' do
         subject { 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)
         end
@@ -242,6 +254,7 @@ describe Danica::Expression do
 
       context 'when not initializing all variables' do
         subject { described_class::Spatial.new }
+
         let(:time) { Danica::Wrapper::Variable.new(name: :t) }
 
         context 'when initialized with an empty variable set' do
@@ -255,25 +268,32 @@ describe Danica::Expression do
             subject.time = time
           end
 
-          it 'returns the list of variables merged default and new variables' do
-            expect(subject.variables.compact).to eq([
+          let(:expected_variables) do
+            [
               time,
               Danica::Wrapper::Variable.new(name: :acceleration),
               Danica::Wrapper::Variable.new(name: :initial_space),
               Danica::Wrapper::Variable.new(name: :initial_velocity)
-            ])
+            ]
+          end
+
+          it 'returns the list of variables merged default and new variables' do
+            expect(subject.variables.compact).to eq(expected_variables)
           end
         end
 
         context 'when initializing with a variable set' do
-          let(:names) { [ :t, :a, :s0, :v0 ] }
-          subject { described_class::Spatial.new *names }
+          subject { 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)
           end
 
           context 'when initializing variables with a hash out of order' do
+            subject { described_class::Spatial.new variables }
+
             let(:variables) do
               {
                 initial_velocity: :v0,
@@ -282,7 +302,6 @@ describe Danica::Expression do
                 time: :t
               }
             end
-            subject { described_class::Spatial.new variables }
 
             it 'returns the variables given on initialization' do
               expect(subject.variables.map(&:name)).to eq(names)
@@ -294,13 +313,15 @@ 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) }
+
         let(:time_value) { 2 }
         let(:time) { time_value }
         let(:acceleration) { 3 }
         let(:initial_space) { 1 }
         let(:initial_velocity) { 1 }
-        subject { described_class::Spatial.new(time, acceleration, initial_space, initial_velocity) }
-        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)
@@ -313,7 +334,7 @@ describe Danica::Expression do
             expect { subject.calculate }.to raise_error(Danica::Exception::NotDefined)
           end
 
-          context 'but calling calculate with a value for the variables' do
+          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)
             end
@@ -344,10 +365,11 @@ describe Danica::Expression do
   describe 'baskara' do
     context 'when using the default value for variables' do
       subject { described_class::Baskara.new }
+
       it_behaves_like 'an object that respond to basic_methods'
 
       describe '#to_tex' do
-        let(:expected) { '\frac{-b \pm \sqrt{b^{2} -4 \cdot a \cdot c}}{2 \cdot a}'  }
+        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)
@@ -355,7 +377,7 @@ describe Danica::Expression do
       end
 
       describe '#to_gnu' do
-        let(:expected) { '(-b + sqrt(b**(2) -4 * a * c))/(2 * a)'  }
+        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)