danica 2.7.2 → 2.7.7

data/spec/lib/danica/formatted_spec.rb

@@ -1,5 +1,6 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
+require 'spec_helper'
 
 shared_examples 'a formatted result' do |output|
   it do
@@ -15,21 +16,40 @@ shared_examples('a formatted object that responds to basic operations') do |oper
   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
@@ -48,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')
@@ -65,13 +85,12 @@ describe Danica::Formatted do
   end
 
   describe 'operators' do
-    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}']
-    }
+    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
@@ -108,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
@@ -123,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
@@ -135,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
@@ -146,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

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,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
-