danica 2.7.1 → 2.7.6

data/spec/lib/danica/function/name_spec.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Danica::Function::Name do
-  let(:x) {  Danica::Wrapper::Variable.new(name: :x, latex: '\mu', gnuplot: 'u')}
+  let(:x) { Danica::Wrapper::Variable.new(name: :x, latex: '\mu', gnuplot: 'u') }
   let(:subject) { described_class.new(name: :f, variables: [x]) }
 
   it_behaves_like 'an object that respond to basic_methods'

data/spec/lib/danica/function_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 shared_examples 'a generically generated function' do
@@ -28,8 +30,9 @@ end
 
 describe Danica::Function do
   subject { function }
+
   let(:function) { function_class.new }
-  let(:variables) { %i(x y) }
+  let(:variables) { %i[x y] }
   let(:function_class) do
     described_class.build(*variables) do
       Danica::Operator::Power.new(x, y)
@@ -37,12 +40,13 @@ describe Danica::Function do
   end
 
   describe '.for' do
-    let(:expression_class) { Danica::Expression::Gauss }
-    let(:expression) { expression_class.new }
     subject do
       described_class.for(expression_class).new
     end
 
+    let(:expression_class) { Danica::Expression::Gauss }
+    let(:expression) { expression_class.new }
+
     it 'returns a function' do
       expect(subject).to be_a(described_class)
     end
@@ -111,7 +115,7 @@ describe Danica::Function do
       let(:function_class) { Danica::Function::SaddleParabole }
 
       it 'has the defined variables on class definition' do
-        expect(function_class.variables_names).to eq([:x, :y])
+        expect(function_class.variables_names).to eq(%i[x y])
       end
 
       it 'has the defined variables' do
@@ -143,6 +147,7 @@ describe Danica::Function do
         f.name = :f
       end
     end
+
     it_behaves_like 'a generically generated function'
   end
 
@@ -157,9 +162,8 @@ describe Danica::Function do
 
     context 'when changing the function variables' do
       it 'changes the name variables' do
-        expect do
-          function.x = 2
-        end.to change { function.name.variables.map(&:content) }
+        expect { function.x = 2 }
+          .to(change { function.name.variables.map(&:content) })
       end
     end
   end
@@ -174,7 +178,7 @@ describe Danica::Function do
         expect(function.to_tex).to eq('f(x, y) = x^{y}')
       end
 
-      context 'and one of the variables is changed' do
+      context 'when one of the variables is changed' do
         it 'uses the new variable value' do
           expect do
             function.y = 2
@@ -192,7 +196,7 @@ describe Danica::Function do
         expect(function.to_tex).to eq('f(y) = \pi^{y}')
       end
 
-      context 'from a hash' do
+      context 'when name is in the hash' do
         let(:function) do
           function_class.new(name: :f, x: { latex: '\pi', gnuplot: 'pi', value: 3.14 })
         end
@@ -244,7 +248,7 @@ describe Danica::Function do
         expect(function.to_gnu).to eq('f(y) = pi**(y)')
       end
 
-      context 'from a hash' do
+      context 'when name is in the hash' do
         let(:function) do
           function_class.new(name: :f, x: { latex: '\pi', gnuplot: 'pi', value: 3.14 })
         end

data/spec/lib/danica/operator/addition_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Danica::Operator::Addition do
@@ -11,34 +13,29 @@ describe Danica::Operator::Addition do
 
   it_behaves_like 'an object that respond to basic_methods'
 
-  it_behaves_like 'an object with basic operation', ignore: %i(+ -)
+  it_behaves_like 'an object with basic operation', ignore: %i[+ -]
   it_behaves_like 'an object with + operation' do
-    let(:subject_included) { 10 }
-
     context 'when other is also a addition' do
       let(:other) { described_class.new(200, 5) }
 
       it 'includes the addition parcels' do
-        expect(result).to include(200)
+        expect(result.to_gnu).to eq('10 + 2 + 200 + 5')
       end
     end
   end
-  it_behaves_like 'an object with - operation' do
-    let(:subject_included) { 10 }
-  end
+  it_behaves_like 'an object with - operation'
 
-  it_behaves_like 'a operator that joins many variables with same operation', {
-    calculated: 10,
-    numeric_variables: [ 1.5, 3.0, 3.5 ],
-    tex: {
-      string_expected: 'X1 + X2 + X3 + X4',
-      integer_expected: '1.5 + 3 + X3 + X4',
-      float_expected: '1.5 + 3 + 3.5 + X4'
-    },
-    gnu: {
-      string_expected: 'X1 + X2 + X3 + X4',
-      integer_expected: '1.5 + 3 + X3 + X4',
-      float_expected: '1.5 + 3 + 3.5 + X4'
-    }
-  }
+  it_behaves_like 'a operator that joins many variables with same operation',
+                  calculated: 10,
+                  numeric_variables: [1.5, 3.0, 3.5],
+                  tex: {
+                    string_expected: 'X1 + X2 + X3 + X4',
+                    integer_expected: '1.5 + 3 + X3 + X4',
+                    float_expected: '1.5 + 3 + 3.5 + X4'
+                  },
+                  gnu: {
+                    string_expected: 'X1 + X2 + X3 + X4',
+                    integer_expected: '1.5 + 3 + X3 + X4',
+                    float_expected: '1.5 + 3 + 3.5 + X4'
+                  }
 end

data/spec/lib/danica/operator/cos_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Danica::Operator::Cos do
@@ -6,12 +8,11 @@ describe Danica::Operator::Cos do
   it_behaves_like 'an object that respond to basic_methods'
   it_behaves_like 'an object with basic operation'
 
-  it_behaves_like 'a operator with a single input value', {
-    variable_value: Math::PI,
-    expected_number: -1.0,
-    expected_number_tex: 'cos(3.141592653589793)',
-    expected_number_gnu: 'cos(3.141592653589793)',
-    expected_tex: 'cos(X)',
-    expected_gnu: 'cos(X)'
-  }
+  it_behaves_like 'a operator with a single input value',
+                  variable_value: Math::PI,
+                  expected_number: -1.0,
+                  expected_number_tex: 'cos(3.141592653589793)',
+                  expected_number_gnu: 'cos(3.141592653589793)',
+                  expected_tex: 'cos(X)',
+                  expected_gnu: 'cos(X)'
 end

data/spec/lib/danica/operator/division_spec.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Danica::Operator::Division do
-  let(:variables) { [2, 4] }
   subject { described_class.new(*variables) }
 
+  let(:variables) { [2, 4] }
+
   describe '#numerator' do
     it 'returns the numerator' do
       expect(subject.numerator).to eq(Danica::Wrapper::Number.new(2))
@@ -19,25 +22,24 @@ describe Danica::Operator::Division do
   it_behaves_like 'an object that respond to basic_methods'
   it_behaves_like 'an object with basic operation'
 
-  it_behaves_like 'a operator that has two terms', :division, {
-    values: [ 2, 4 ],
-    calculated: 1.0 / 2.0,
-    to_tex: {
-      string_expected: '\frac{X1}{X2}',
-      numeric_string_expected: '\frac{2}{4}',
-      partial_string_expected: '\frac{2}{X2}'
-    },
-    to_gnu: {
-      string_expected: '(X1)/(X2)',
-      numeric_string_expected: '(2)/(4)',
-      partial_string_expected: '(2)/(X2)'
-    }
-  }
+  it_behaves_like 'a operator that has two terms', :division,
+                  values: [2, 4],
+                  calculated: 1.0 / 2.0,
+                  to_tex: {
+                    string_expected: '\frac{X1}{X2}',
+                    numeric_string_expected: '\frac{2}{4}',
+                    partial_string_expected: '\frac{2}{X2}'
+                  },
+                  to_gnu: {
+                    string_expected: '(X1)/(X2)',
+                    numeric_string_expected: '(2)/(4)',
+                    partial_string_expected: '(2)/(X2)'
+                  }
 
   describe 'more complex division' do
     describe 'of two additions' do
       subject do
-        Danica::Operator::Division.new(
+        described_class.new(
           Danica::Operator::Addition.new(2, :x),
           Danica::Operator::Addition.new(3, :y)
         )
@@ -55,4 +57,3 @@ describe Danica::Operator::Division do
     end
   end
 end
-

data/spec/lib/danica/operator/exponential_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Danica::Operator::Exponential do
@@ -6,12 +8,11 @@ describe Danica::Operator::Exponential do
   it_behaves_like 'an object that respond to basic_methods'
   it_behaves_like 'an object with basic operation'
 
-  it_behaves_like 'a operator with a single input value', {
-    variable_value: 2,
-    expected_number: Math.exp(2),
-    expected_number_tex: 'e^{2}',
-    expected_number_gnu: 'exp(2)',
-    expected_tex: 'e^{X}',
-    expected_gnu: 'exp(X)'
-  }
+  it_behaves_like 'a operator with a single input value',
+                  variable_value: 2,
+                  expected_number: Math.exp(2),
+                  expected_number_tex: 'e^{2}',
+                  expected_number_gnu: 'exp(2)',
+                  expected_tex: 'e^{X}',
+                  expected_gnu: 'exp(X)'
 end

data/spec/lib/danica/operator/multiplication_spec.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Danica::Operator::Multiplication do
-  subject { described_class.new(2,4) }
+  subject { described_class.new(2, 4) }
 
   it 'initializes from array' do
     expect do
@@ -12,30 +14,27 @@ describe Danica::Operator::Multiplication do
   it_behaves_like 'an object that respond to basic_methods'
 
   it_behaves_like 'an object with * operation' do
-    let(:subject_included) { 4 }
-
-    context 'when other is also a addition' do
+    context 'when other is also a multiplication' do
       let(:other) { described_class.new(200, 5) }
 
-      it 'includes the addition parcels' do
-        expect(result).to include(200)
+      it 'includes the addition parcels in the result' do
+        expect(result.to_gnu).to eq('2 * 4 * 200 * 5')
       end
     end
   end
   it_behaves_like 'an object with basic operation', ignore: :*
 
-  it_behaves_like 'a operator that joins many variables with same operation', {
-    calculated: 24,
-    numeric_variables: [ 1.5, 2, 3.5 ],
-    tex: {
-      string_expected: %w(X1 X2 X3 X4).join(' \cdot '),
-      integer_expected: %w(1.5 2 X3 X4).join(' \cdot '),
-      float_expected: %w(1.5 2 3.5 X4).join(' \cdot ')
-    },
-    gnu: {
-      string_expected: %w(X1 X2 X3 X4).join(' * '),
-      integer_expected: %w(1.5 2 X3 X4).join(' * '),
-      float_expected: %w(1.5 2 3.5 X4).join(' * '),
-    }
-  }
+  it_behaves_like 'a operator that joins many variables with same operation',
+                  calculated: 24,
+                  numeric_variables: [1.5, 2, 3.5],
+                  tex: {
+                    string_expected: %w[X1 X2 X3 X4].join(' \cdot '),
+                    integer_expected: %w[1.5 2 X3 X4].join(' \cdot '),
+                    float_expected: %w[1.5 2 3.5 X4].join(' \cdot ')
+                  },
+                  gnu: {
+                    string_expected: %w[X1 X2 X3 X4].join(' * '),
+                    integer_expected: %w[1.5 2 X3 X4].join(' * '),
+                    float_expected: %w[1.5 2 3.5 X4].join(' * ')
+                  }
 end

data/spec/lib/danica/operator/power_spec.rb

@@ -1,25 +1,26 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Danica::Operator::Power do
-  let(:variables) { [2, 4] }
   subject { described_class.new(*variables) }
 
+  let(:variables) { [2, 4] }
+
   it_behaves_like 'an object that respond to basic_methods'
   it_behaves_like 'an object with basic operation'
 
-  it_behaves_like 'a operator that has two terms', :power, {
-    values: [ 3, 2 ],
-    calculated: 9.0,
-    to_tex: {
-      string_expected: 'X1^{X2}',
-      numeric_string_expected: '3^{2}',
-      partial_string_expected: '3^{X2}'
-    },
-    to_gnu: {
-      string_expected: 'X1**(X2)',
-      numeric_string_expected: '3**(2)',
-      partial_string_expected: '3**(X2)'
-    }
-  }
+  it_behaves_like 'a operator that has two terms', :power,
+                  values: [3, 2],
+                  calculated: 9.0,
+                  to_tex: {
+                    string_expected: 'X1^{X2}',
+                    numeric_string_expected: '3^{2}',
+                    partial_string_expected: '3^{X2}'
+                  },
+                  to_gnu: {
+                    string_expected: 'X1**(X2)',
+                    numeric_string_expected: '3**(2)',
+                    partial_string_expected: '3**(X2)'
+                  }
 end
-

data/spec/lib/danica/operator/sin_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Danica::Operator::Sin do
@@ -6,12 +8,11 @@ describe Danica::Operator::Sin do
   it_behaves_like 'an object that respond to basic_methods'
   it_behaves_like 'an object with basic operation'
 
-  it_behaves_like 'a operator with a single input value', {
-    variable_value: Math::PI / 2.0,
-    expected_number: 1.0,
-    expected_number_tex: 'sin(1.5707963267948966)',
-    expected_number_gnu: 'sin(1.5707963267948966)',
-    expected_tex: 'sin(X)',
-    expected_gnu: 'sin(X)'
-  }
+  it_behaves_like 'a operator with a single input value',
+                  variable_value: Math::PI / 2.0,
+                  expected_number: 1.0,
+                  expected_number_tex: 'sin(1.5707963267948966)',
+                  expected_number_gnu: 'sin(1.5707963267948966)',
+                  expected_tex: 'sin(X)',
+                  expected_gnu: 'sin(X)'
 end

data/spec/lib/danica/operator/squared_root_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Danica::Operator::SquaredRoot do
@@ -6,12 +8,11 @@ describe Danica::Operator::SquaredRoot do
   it_behaves_like 'an object that respond to basic_methods'
   it_behaves_like 'an object with basic operation'
 
-  it_behaves_like 'a operator with a single input value', {
-    variable_value: 9,
-    expected_number: 3.0,
-    expected_number_tex: '\sqrt{9}',
-    expected_number_gnu: 'sqrt(9)',
-    expected_tex: '\sqrt{X}',
-    expected_gnu: 'sqrt(X)'
-  }
+  it_behaves_like 'a operator with a single input value',
+                  variable_value: 9,
+                  expected_number: 3.0,
+                  expected_number_tex: '\sqrt{9}',
+                  expected_number_gnu: 'sqrt(9)',
+                  expected_tex: '\sqrt{X}',
+                  expected_gnu: 'sqrt(X)'
 end

data/spec/lib/danica/operator_spec.rb

@@ -1,31 +1,40 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 class Danica::Operator::Dummy < Danica::Operator
   variables :a, :b
 
-  def to(*args)
+  def to(*_args)
     a + b
   end
 end
 
 describe Danica::Operator do
+  subject { clazz.new(*variables) }
+
   let(:variables) { [2, 4] }
   let(:clazz) { described_class::Dummy }
-  subject { clazz.new(*variables) }
 
   it_behaves_like 'an object that respond to basic_methods'
 
   describe 'variables assignment' do
-    it 'assignes the variables tpo its places' do
+    it 'assignes first variable' do
       expect(subject.a).to eq(Danica::Wrapper::Number.new(2))
+    end
+
+    it 'assignes second variable' do
       expect(subject.b).to eq(Danica::Wrapper::Number.new(4))
     end
 
     context 'when initializing with a hash' do
       let(:variables) { [{ name: :A, value: 2 }, { name: :B, value: 4 }] }
 
-      it 'assignes the variables tpo its places' do
+      it 'assignes first variable' do
         expect(subject.a).to eq(Danica::Wrapper::Variable.new(name: :A, value: 2))
+      end
+
+      it 'assignes second variable' do
         expect(subject.b).to eq(Danica::Wrapper::Variable.new(name: :B, value: 4))
       end
     end