danica 2.7.1 → 2.7.6

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)

data/spec/lib/danica/formatted_spec.rb

@@ -1,11 +1,55 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
+shared_examples 'a formatted result' do |output|
+  it do
+    expect(result).to be_a(described_class)
+  end
+
+  it 'keeps being able to parse format' do
+    expect(result.to_s).to eq(output)
+  end
+end
+
+shared_examples('a formatted object that responds to basic operations') do |operations_map|
+  operations_map.each do |operation, (output, reverse_output)|
+    describe(operation.to_s) do
+      let(:result) { subject.public_send(operation, 2) }
+
+      it_behaves_like 'a formatted result', output
+
+      context 'when doing it backwards' do
+        let(:result) { Danica::Wrapper::Number.new(2).public_send(operation, subject) }
+
+        it_behaves_like 'a formatted result', reverse_output
+      end
+    end
+  end
+end
 describe Danica::Formatted do
+  subject do
+    described_class.new(content, format: format, **options)
+  end
+
   let(:content) { Danica::Wrapper::Variable.new(latex: :V, gnuplot: :v) }
   let(:format) { :tex }
   let(:options) { {} }
-  subject do
-    described_class.new(content, format, options)
+
+  describe '#repack' do
+    let(:expression) { Danica::Wrapper::Number.new(1.0 / 3) }
+
+    it do
+      expect(subject.repack(expression)).to be_a(described_class)
+    end
+
+    context 'when there are options' do
+      let(:options) { { decimals: 3 } }
+
+      it 'wraps expression with options' do
+        expect(subject.repack(expression).to_s).to eq('0.333')
+      end
+    end
   end
 
   describe '#to_s' do
@@ -24,7 +68,7 @@ describe Danica::Formatted do
     end
 
     context 'when variable has numeric value' do
-      let(:content) { Danica::Wrapper::Number.new(1/3.0) }
+      let(:content) { Danica::Wrapper::Number.new(1 / 3.0) }
 
       it 'returns the formatted number' do
         expect(subject.to_s).to eq('0.3333333333333333')
@@ -41,25 +85,12 @@ describe Danica::Formatted do
   end
 
   describe 'operators' do
-    describe '+' do
-      it do
-        expect(subject + 2).to be_a(described_class)
-      end
-
-      it 'keeps being able to parse format' do
-        expect((subject + 2).to_s).to eq('V + 2')
-      end
-    end
-
-    describe '*' do
-      it do
-        expect(subject * 2).to be_a(described_class)
-      end
-
-      it 'keeps being able to parse format' do
-        expect((subject * 2).to_s).to eq('V \cdot 2')
-      end
-    end
+    it_behaves_like 'a formatted object that responds to basic operations',
+                    :+ => ['V + 2', '2 + V'],
+                    :- => ['V -2', '2 -V'],
+                    :* => ['V \cdot 2', '2 \cdot V'],
+                    :/ => ['\frac{V}{2}', '\frac{2}{V}'],
+                    :** => ['V^{2}', '2^{V}']
 
     describe '-@' do
       it do
@@ -96,7 +127,7 @@ describe Danica::Formatted do
 
   describe '#tex' do
     it do
-      expect(subject.tex).to be_a(Danica::Formatted)
+      expect(subject.tex).to be_a(described_class)
     end
 
     context 'when original format is tex' do
@@ -111,6 +142,7 @@ describe Danica::Formatted do
 
     context 'when original format is gnu' do
       let(:format) { :gnu }
+
       it 'returns the tex string' do
         expect(subject.tex.to_s).to eq('V')
       end
@@ -123,7 +155,7 @@ describe Danica::Formatted do
 
   describe '#gnu' do
     it do
-      expect(subject.gnu).to be_a(Danica::Formatted)
+      expect(subject.gnu).to be_a(described_class)
     end
 
     context 'when original format is tex' do
@@ -134,6 +166,7 @@ describe Danica::Formatted do
 
     context 'when original format is gnu' do
       let(:format) { :gnu }
+
       it 'returns the gnu string' do
         expect(subject.gnu.to_s).to eq('v')
       end