danica 2.7.4 → 2.7.5

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,7 +13,7 @@ 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
     context 'when other is also a addition' do
       let(:other) { described_class.new(200, 5) }
@@ -23,18 +25,17 @@ describe Danica::Operator::Addition do
   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
@@ -22,18 +24,17 @@ describe Danica::Operator::Multiplication do
   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

data/spec/lib/danica/variables_holder/store_spec.rb

@@ -1,16 +1,19 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe Danica::VariablesHolder::Store do 
+describe Danica::VariablesHolder::Store do
+  subject do
+    described_class.new(default_variables_hash)
+  end
+
   let(:default_variables_hash) do
     {
       x: Danica::Wrapper::Variable.new(name: :x),
-      y: Danica::Wrapper::Variable.new( latex: '\y' ),
+      y: Danica::Wrapper::Variable.new(latex: '\y'),
       z: Danica::Wrapper::Number.new(10)
     }
   end
-  subject do
-    described_class.new(default_variables_hash)
-  end
 
   describe '#variables' do
     context 'when instance has no variables defined' do
@@ -18,7 +21,7 @@ describe Danica::VariablesHolder::Store do
         expect(subject.variables).not_to be_empty
       end
 
-      #it_behaves_like 'an object that returns the default variables'
+      # it_behaves_like 'an object that returns the default variables'
     end
 
     context 'when some variables where defined' do
@@ -26,12 +29,17 @@ describe Danica::VariablesHolder::Store do
         subject.containers_hash[:y] = Danica::Wrapper::Number.new(1)
       end
 
-      it 'returns the default variables and the new set one' do
-        expect(subject.variables).to eq([
+      let(:expected_variables) do
+        [
           Danica::Wrapper::Variable.new(name: :x),
           Danica::Wrapper::Number.new(1),
           Danica::Wrapper::Number.new(10)
-        ])
+        ]
+      end
+
+      it 'returns the default variables and the new set one' do
+        expect(subject.variables)
+          .to eq(expected_variables)
       end
 
       it 'does not change the default variables' do
@@ -44,7 +52,7 @@ describe Danica::VariablesHolder::Store do
 
   describe '#variables_hash' do
     context 'when instance has no variables defined' do
-      #it_behaves_like 'an object that returns the default variables hash'
+      # it_behaves_like 'an object that returns the default variables hash'
     end
 
     context 'when some variables where defined' do
@@ -64,9 +72,7 @@ describe Danica::VariablesHolder::Store do
 
   describe '#containers' do
     it 'is an array of Containers' do
-      subject.containers.each do |container|
-        expect(container).to be_a(Danica::Wrapper::Container)
-      end
+      expect(subject.containers).to all(be_a(Danica::Wrapper::Container))
     end
   end
 end