danica 2.7.4 → 2.7.5

data/spec/lib/danica/variables_holder_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 shared_examples 'an object that returns the default variables hash' do
@@ -11,12 +13,16 @@ shared_examples 'an object that returns the default variables hash' do
 end
 
 shared_examples 'an object that returns the default variables' do
-  it 'returns the default variables hash' do
-    expect(subject.variables).to eq([
+  let(:expected_variables) do
+    [
       Danica::Wrapper::Variable.new(name: :x),
       Danica::Wrapper::Variable.new(latex: '\y'),
       Danica::Wrapper::Number.new(10)
-    ])
+    ]
+  end
+
+  it 'returns the default variables hash' do
+    expect(subject.variables).to eq(expected_variables)
   end
 end
 
@@ -24,20 +30,20 @@ shared_examples 'an variable set that does not change the class variables' do
   it 'does not change the the class variables' do
     expect do
       subject.variables = variables
-    end.not_to change { clazz.variables_hash }
+    end.not_to change(clazz, :variables_hash)
   end
 end
 
 shared_examples 'a class with mapped variables' do
   context 'when initializing with an array' do
-    subject { clazz.new(1,2,3) }
+    subject { clazz.new(1, 2, 3) }
 
     it 'initialize variables in order of declaration' do
-      expect(subject.variables_hash).to eq({
+      expect(subject.variables_hash).to eq(
         x: Danica::Wrapper::Number.new(1),
         y: Danica::Wrapper::Number.new(2),
         z: Danica::Wrapper::Number.new(3)
-      })
+      )
     end
   end
 
@@ -45,55 +51,56 @@ shared_examples 'a class with mapped variables' do
     subject { clazz.new(z: 1, y: 2) }
 
     it 'initialize variables with the map given' do
-      expect(subject.variables_hash).to eq({
+      expect(subject.variables_hash).to eq(
         x: Danica::Wrapper::Variable.new(name: :x),
         y: Danica::Wrapper::Number.new(2),
         z: Danica::Wrapper::Number.new(1)
-      })
+      )
     end
   end
 
   context 'when initializing with hashes' do
     subject do
       clazz.new(
-        {name: :xis, value: 1},
-        {name: :yps, value: 2},
-        {name: :zes, value: 3}
+        { name: :xis, value: 1 },
+        { name: :yps, value: 2 },
+        name: :zes, value: 3
       )
     end
 
     it 'initialize variables with the maps given' do
-      expect(subject.variables_hash).to eq({
+      expect(subject.variables_hash).to eq(
         x: Danica::Wrapper::Variable.new(name: :xis, value: 1),
         y: Danica::Wrapper::Variable.new(name: :yps, value: 2),
         z: Danica::Wrapper::Variable.new(name: :zes, value: 3)
-      })
+      )
     end
   end
 
   context 'when initializing with array of hashes' do
     subject do
       clazz.new([
-        {name: :xis, value: 1},
-        {name: :yps, value: 2},
-        {name: :zes, value: 3}
-      ])
+                  { name: :xis, value: 1 },
+                  { name: :yps, value: 2 },
+                  { name: :zes, value: 3 }
+                ])
     end
 
     it 'initialize variables with the maps given' do
-      expect(subject.variables_hash).to eq({
+      expect(subject.variables_hash).to eq(
         x: Danica::Wrapper::Variable.new(name: :xis, value: 1),
         y: Danica::Wrapper::Variable.new(name: :yps, value: 2),
         z: Danica::Wrapper::Variable.new(name: :zes, value: 3)
-      })
+      )
     end
   end
 end
 
 describe Danica::VariablesHolder do
-  let(:clazz) { described_class::Dummy }
   subject { clazz.new }
 
+  let(:clazz) { described_class::Dummy }
+
   describe '#initialize' do
     context 'when using a symbolized key definition' do
       it_behaves_like 'a class with mapped variables'
@@ -101,18 +108,24 @@ describe Danica::VariablesHolder do
 
     context 'when using a string key definition' do
       let(:clazz) { described_class::DummyString }
+
       it_behaves_like 'a class with mapped variables'
     end
   end
 
   describe 'variables assignement' do
-    it 'creates setters and getters for the variables' do
-      %i(x y z).each do |var|
-        expect(subject).to respond_to(var)
+    it 'creates setters for the variables' do
+      %i[x y z].each do |var|
         expect(subject).to respond_to("#{var}=")
       end
     end
 
+    it 'creates getters for the variables' do
+      %i[x y z].each do |var|
+        expect(subject).to respond_to(var)
+      end
+    end
+
     it 'accepts variable assignment' do
       expect do
         subject.x = 1
@@ -134,14 +147,14 @@ describe Danica::VariablesHolder do
 
   describe '.variables_names' do
     it 'returns the list of variables pre configured' do
-      expect(clazz.variables_names).to eq(%i(x y z))
+      expect(clazz.variables_names).to eq(%i[x y z])
     end
 
     context 'when variables are defined in super class' do
       let(:clazz) { described_class::DummyChild }
 
       it 'returns the list of variables of both classes merged' do
-        expect(clazz.variables_names).to eq(%i(x y z k))
+        expect(clazz.variables_names).to eq(%i[x y z k])
       end
     end
 
@@ -149,7 +162,7 @@ describe Danica::VariablesHolder do
       let(:clazz) { described_class::DummyOverwrite }
 
       it 'returns the list of variables of both classes merged' do
-        expect(clazz.variables_names).to eq(%i(k z))
+        expect(clazz.variables_names).to eq(%i[k z])
       end
     end
   end
@@ -159,7 +172,7 @@ describe Danica::VariablesHolder do
       let(:clazz) { described_class::DummyAlias }
 
       it 'returns the list of variables of both classes merged' do
-        expect(clazz.variables_names).to eq(%i(a y z))
+        expect(clazz.variables_names).to eq(%i[a y z])
       end
 
       context 'when original variable is set' do
@@ -175,9 +188,7 @@ describe Danica::VariablesHolder do
 
         context 'when changing the new alias value' do
           it do
-            expect do
-              subject.a = 20
-            end.to change { subject.x.content }
+            expect { subject.a = 20 }.to(change { subject.x.content })
           end
         end
       end
@@ -195,9 +206,8 @@ describe Danica::VariablesHolder do
 
         context 'when changing the original variable value' do
           it do
-            expect do
-              subject.x = 20
-            end.to change { subject.a.content }
+            expect { subject.x = 20 }
+              .to(change { subject.a.content })
           end
         end
       end
@@ -208,21 +218,25 @@ describe Danica::VariablesHolder do
     context 'when changing the variables of the object' do
       context 'when all the variables are set with value' do
         let(:variables) { [1, 2, 3] }
+
         it_behaves_like 'an variable set that does not change the class variables'
       end
 
-      context 'setting the variables through a hash' do
+      context 'when setting the variables through a hash' do
         let(:variables) { { x: 1, y: 2, z: 3 } }
+
         it_behaves_like 'an variable set that does not change the class variables'
       end
 
       context 'when none of the variables are set with values' do
         let(:variables) { [] }
+
         it_behaves_like 'an variable set that does not change the class variables'
       end
 
       context 'when the variables are set through an empty hash' do
         let(:variables) { {} }
+
         it_behaves_like 'an variable set that does not change the class variables'
       end
     end
@@ -231,14 +245,16 @@ describe Danica::VariablesHolder do
       before do
         subject.variables = variables
       end
+
       let(:variables) { [1, 2, 3] }
 
       it 'changes the values of the variables' do
         expect(subject.x).to eq(Danica::Wrapper::Number.new(1))
       end
 
-      context 'but the array is empty' do
+      context 'when the array is empty' do
         let(:variables) { [] }
+
         it_behaves_like 'an object that returns the default variables hash'
       end
     end
@@ -254,8 +270,9 @@ describe Danica::VariablesHolder do
         expect(subject.x).to eq(Danica::Wrapper::Number.new(1))
       end
 
-      context 'but the hash is empty' do
+      context 'when the hash is empty' do
         let(:variables) { {} }
+
         it_behaves_like 'an object that returns the default variables hash'
       end
     end
@@ -277,10 +294,10 @@ describe Danica::VariablesHolder do
 
       it 'returns the default variables and the new set one' do
         expect(subject.variables).to eq([
-          Danica::Wrapper::Variable.new(name: :x),
-          Danica::Wrapper::Number.new(1),
-          Danica::Wrapper::Number.new(10)
-        ])
+                                          Danica::Wrapper::Variable.new(name: :x),
+                                          Danica::Wrapper::Number.new(1),
+                                          Danica::Wrapper::Number.new(10)
+                                        ])
       end
 
       it 'does not change the class variables' do
@@ -314,7 +331,7 @@ describe Danica::VariablesHolder do
   describe '#variables_value_hash' do
     context 'when instance has no variables defined' do
       it 'returns the default value' do
-        expect(subject.variables_value_hash).to eq({x: nil, y: nil, z: 10})
+        expect(subject.variables_value_hash).to eq(x: nil, y: nil, z: 10)
       end
     end
 
@@ -324,7 +341,7 @@ describe Danica::VariablesHolder do
       end
 
       it 'returns the values' do
-        expect(subject.variables_value_hash).to eq({x: nil, y: 1, z: 10})
+        expect(subject.variables_value_hash).to eq(x: nil, y: 1, z: 10)
       end
     end
   end
@@ -338,24 +355,24 @@ describe Danica::VariablesHolder do
       let(:containers) { subject.containers }
 
       it 'changes the variables in the containers' do
-        expect do
-          subject.x = 2
-        end.to change { containers.map(&:content) }
+        expect {  subject.x = 2 }
+          .to(change { containers.map(&:content) })
       end
     end
   end
 
   describe '#extract_variables' do
     let(:clazz) { described_class::DummyChild }
+
     context 'when holder has straight variables' do
       it 'returns the variables hash' do
-        expect(subject.extract_variables).to eq(subject.containers.as_hash([:x, :y, :zeta, :k]))
+        expect(subject.extract_variables).to eq(subject.containers.as_hash(%i[x y zeta k]))
       end
 
-      context 'but one of them is a number' do
+      context 'when one of them is a number' do
         let(:clazz) { described_class::Dummy }
         let(:expected) do
-          subject.containers_hash.reject { |k,v| k == :z }
+          subject.containers_hash.reject { |k, _v| k == :z }
         end
 
         it 'returns only the variables' do
@@ -368,7 +385,7 @@ describe Danica::VariablesHolder do
       let(:subject) { clazz.new(x: :xis, y: :lambda, z: :zeta, k: :key) }
 
       it 'returns the names as keys' do
-        expect(subject.extract_variables.keys).to eq(%i(xis lambda zeta key))
+        expect(subject.extract_variables.keys).to eq(%i[xis lambda zeta key])
       end
     end
 
@@ -378,8 +395,8 @@ describe Danica::VariablesHolder do
         clazz.new(z: inner)
       end
       let(:expected) do
-        subject.containers_hash.reject { |k,v| k == :z }
-                               .merge(inner.containers_hash)
+        subject.containers_hash.reject { |k, _v| k == :z }
+               .merge(inner.containers_hash)
       end
 
       it 'returns the ineer variables of the inner holder as well' do
@@ -389,7 +406,7 @@ describe Danica::VariablesHolder do
       context 'when inner holder has the same variables' do
         let(:inner) { clazz.new }
         let(:expected) do
-          inner.containers.as_hash([:x, :y, :zeta, :k])
+          inner.containers.as_hash(%i[x y zeta k])
         end
 
         it 'merges them together in favor of the inner variables' do
@@ -406,7 +423,7 @@ describe Danica::VariablesHolder do
           expect { subject.calculate }.to raise_error(Danica::Exception::NotDefined)
         end
 
-        context 'which does not complete the values' do
+        context 'when it does not complete the values' do
           it do
             expect { subject.calculate(2) }.to raise_error(Danica::Exception::NotDefined)
           end
@@ -414,7 +431,7 @@ describe Danica::VariablesHolder do
       end
 
       context 'when passing the values' do
-        context 'as a list of values' do
+        context 'when values are a list' do
           it do
             expect { subject.calculate(2, 4) }.not_to raise_error
           end
@@ -423,7 +440,7 @@ describe Danica::VariablesHolder do
             expect(subject.calculate(2, 4)).to eq(26)
           end
 
-          context 'and replacing all the values' do
+          context 'when replacing all the values' do
             it do
               expect { subject.calculate(2, 4, 5) }.not_to raise_error
             end
@@ -434,8 +451,8 @@ describe Danica::VariablesHolder do
           end
         end
 
-        context 'as a hash' do
-          context 'which completes the values' do
+        context 'when the values are hash' do
+          context 'when it completes the values' do
             it do
               expect { subject.calculate(x: 2, y: 4) }.not_to raise_error
             end
@@ -445,7 +462,7 @@ describe Danica::VariablesHolder do
             end
           end
 
-          context 'which does not complete the values' do
+          context 'when it does not complete the values' do
             it do
               expect { subject.calculate(x: 2, z: 4) }.to raise_error(Danica::Exception::NotDefined)
             end

data/spec/lib/danica/wrapper/constant_spec.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Danica::Wrapper::Constant do
   subject { described_class.new(2.5, :M, :m) }
+
   let(:other) { described_class.new(3, :N, :n) }
 
   it_behaves_like 'an object that respond to basic_methods'
@@ -25,22 +28,26 @@ describe Danica::Wrapper::Constant do
         expect(subject.to(:tex)).to eq('M')
       end
     end
+
     context "when requesting 'tex'" do
       it 'has a string for latex' do
         expect(subject.to('tex')).to eq('M')
       end
     end
+
     context 'when requesting :gnu' do
       it 'has a string for gnu' do
         expect(subject.to(:gnu)).to eq('m')
       end
     end
+
     context "when requesting 'gnu'" do
       it 'has a string for gnu' do
         expect(subject.to('gnu')).to eq('m')
       end
     end
-    context "when requesting wrong format" do
+
+    context 'when requesting wrong format' do
       it do
         expect do
           subject.to('format')
@@ -95,9 +102,9 @@ describe Danica::Wrapper::Constant do
 
       context 'with same values' do
         let(:other) { described_class.new(2.5, :M, :m) }
+
         it { expect(subject).to eq(other) }
       end
     end
   end
 end
-

data/spec/lib/danica/wrapper/group_spec.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Danica::Wrapper::Group do
-  let(:value) { 10 }
   subject { described_class.new(value) }
 
+  let(:value) { 10 }
+
   it_behaves_like 'an object that respond to basic_methods'
   it_behaves_like 'an object with basic operation'