danica 2.7.6 → 3.0.0

data/spec/lib/danica/formatted_spec.rb

@@ -15,20 +15,21 @@ 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) }
+      let(:result) { formatted.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) }
+        let(:result) { Danica::Wrapper::Number.new(2).public_send(operation, formatted) }
 
         it_behaves_like 'a formatted result', reverse_output
       end
     end
   end
 end
+
 describe Danica::Formatted do
-  subject do
+  subject(:formatted) do
     described_class.new(content, format: format, **options)
   end
 
@@ -40,14 +41,14 @@ describe Danica::Formatted do
     let(:expression) { Danica::Wrapper::Number.new(1.0 / 3) }
 
     it do
-      expect(subject.repack(expression)).to be_a(described_class)
+      expect(formatted.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')
+        expect(formatted.repack(expression).to_s).to eq('0.333')
       end
     end
   end
@@ -55,7 +56,7 @@ describe Danica::Formatted do
   describe '#to_s' do
     context 'when format is tex' do
       it 'return the expected tex string' do
-        expect(subject.to_s).to eq('V')
+        expect(formatted.to_s).to eq('V')
       end
     end
 
@@ -63,7 +64,7 @@ describe Danica::Formatted do
       let(:format) { :gnu }
 
       it 'return the expected gnu string' do
-        expect(subject.to_s).to eq('v')
+        expect(formatted.to_s).to eq('v')
       end
     end
 
@@ -71,14 +72,14 @@ describe Danica::Formatted do
       let(:content) { Danica::Wrapper::Number.new(1 / 3.0) }
 
       it 'returns the formatted number' do
-        expect(subject.to_s).to eq('0.3333333333333333')
+        expect(formatted.to_s).to eq('0.3333333333333333')
       end
 
       context 'when passing decimals settings' do
         let(:options) { { decimals: 4 } }
 
         it 'returns the formatted number' do
-          expect(subject.to_s).to eq('0.3333')
+          expect(formatted.to_s).to eq('0.3333')
         end
       end
     end
@@ -94,11 +95,11 @@ describe Danica::Formatted do
 
     describe '-@' do
       it do
-        expect(-subject).to be_a(described_class)
+        expect(-formatted).to be_a(described_class)
       end
 
       it 'keeps being able to parse format' do
-        expect((-subject).to_s).to eq('-V')
+        expect((-formatted).to_s).to eq('-V')
       end
     end
   end
@@ -107,36 +108,36 @@ describe Danica::Formatted do
     let(:content) { Danica::Wrapper::Number.new(2) }
 
     it do
-      expect(subject.to_f).to be_a(Numeric)
+      expect(formatted.to_f).to be_a(Numeric)
     end
 
     it 'returns the number' do
-      expect(subject.to_f).to eq(2)
+      expect(formatted.to_f).to eq(2)
     end
   end
 
   describe '#to' do
     it do
-      expect(subject.to(:tex)).to be_a(String)
+      expect(formatted.to(:tex)).to be_a(String)
     end
 
     it 'returns the string' do
-      expect(subject.to(:tex)).to eq('V')
+      expect(formatted.to(:tex)).to eq('V')
     end
   end
 
   describe '#tex' do
     it do
-      expect(subject.tex).to be_a(described_class)
+      expect(formatted.tex).to be_a(described_class)
     end
 
     context 'when original format is tex' do
       it 'returns the tex string' do
-        expect(subject.tex.to_s).to eq('V')
+        expect(formatted.tex.to_s).to eq('V')
       end
 
       it 'returns similar object' do
-        expect(subject.tex).to eq(subject)
+        expect(formatted.tex).to eq(formatted)
       end
     end
 
@@ -144,23 +145,23 @@ describe Danica::Formatted do
       let(:format) { :gnu }
 
       it 'returns the tex string' do
-        expect(subject.tex.to_s).to eq('V')
+        expect(formatted.tex.to_s).to eq('V')
       end
 
       it 'returns a new format object' do
-        expect(subject.tex).not_to eq(subject)
+        expect(formatted.tex).not_to eq(formatted)
       end
     end
   end
 
   describe '#gnu' do
     it do
-      expect(subject.gnu).to be_a(described_class)
+      expect(formatted.gnu).to be_a(described_class)
     end
 
     context 'when original format is tex' do
       it 'returns the gnu string' do
-        expect(subject.gnu.to_s).to eq('v')
+        expect(formatted.gnu.to_s).to eq('v')
       end
     end
 
@@ -168,7 +169,7 @@ describe Danica::Formatted do
       let(:format) { :gnu }
 
       it 'returns the gnu string' do
-        expect(subject.gnu.to_s).to eq('v')
+        expect(formatted.gnu.to_s).to eq('v')
       end
     end
   end

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

@@ -3,35 +3,36 @@
 require 'spec_helper'
 
 describe Danica::Function::Name do
+  subject(:name) { described_class.new(name: :f, variables: [x]) }
+
   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'
 
   describe '#to_tex' do
     it 'returns the name of the function with tex variables' do
-      expect(subject.to_tex).to eq('f(\mu)')
+      expect(name.to_tex).to eq('f(\mu)')
     end
 
     context 'when initializing variables from scratch' do
       let(:x) { :x }
 
       it 'returns the name of the function with tex variables' do
-        expect(subject.to_tex).to eq('f(x)')
+        expect(name.to_tex).to eq('f(x)')
       end
     end
   end
 
   describe '#to_gnu' do
     it 'returns the name of the function with tex variables' do
-      expect(subject.to_gnu).to eq('f(u)')
+      expect(name.to_gnu).to eq('f(u)')
     end
 
     context 'when initializing variables from scratch' do
       let(:x) { :x }
 
       it 'returns the name of the function with tex variables' do
-        expect(subject.to_gnu).to eq('f(x)')
+        expect(name.to_gnu).to eq('f(x)')
       end
     end
   end

data/spec/lib/danica/function_spec.rb

@@ -29,9 +29,8 @@ shared_examples 'a generically generated function' do
 end
 
 describe Danica::Function do
-  subject { function }
+  subject(:function) { function_class.new }
 
-  let(:function) { function_class.new }
   let(:variables) { %i[x y] }
   let(:function_class) do
     described_class.build(*variables) do
@@ -40,7 +39,7 @@ describe Danica::Function do
   end
 
   describe '.for' do
-    subject do
+    subject(:function) do
       described_class.for(expression_class).new
     end
 
@@ -48,24 +47,24 @@ describe Danica::Function do
     let(:expression) { expression_class.new }
 
     it 'returns a function' do
-      expect(subject).to be_a(described_class)
+      expect(function).to be_a(described_class)
     end
 
     it 'behaves like a function' do
       expect do
-        subject.to_tex
+        function.to_tex
       end.not_to raise_error
     end
 
     it 'creates a funcion out of an expression' do
-      expect(subject.to_tex).to eq("f(x, \\mu, \\sigma) = #{expression.to_tex}")
+      expect(function.to_tex).to eq("f(x, \\mu, \\sigma) = #{expression.to_tex}")
     end
 
     context 'when passing an operator' do
       let(:expression_class) { Danica::Operator::Cos }
 
       it do
-        expect(subject.to_tex).to eq("f(value) = #{expression.to_tex}")
+        expect(function.to_tex).to eq("f(value) = #{expression.to_tex}")
       end
     end
   end
@@ -212,17 +211,7 @@ describe Danica::Function do
         function_class.new(name: :f, x: 2)
       end
 
-      it 'sohws the variable as number' do
-        expect(function.to_tex).to eq('f(2, y) = 2^{y}')
-      end
-    end
-
-    context 'when a variable has value' do
-      let(:function) do
-        function_class.new(name: :f, x: 2)
-      end
-
-      it 'sohws the variable as number' do
+      it 'shwws the variable as number' do
         expect(function.to_tex).to eq('f(2, y) = 2^{y}')
       end
     end

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

@@ -3,19 +3,19 @@
 require 'spec_helper'
 
 describe Danica::Operator::Division do
-  subject { described_class.new(*variables) }
+  subject(:operator) { 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))
+      expect(operator.numerator).to eq(Danica::Wrapper::Number.new(2))
     end
   end
 
   describe '#denominator' do
     it 'returns the denominator' do
-      expect(subject.denominator).to eq(Danica::Wrapper::Number.new(4))
+      expect(operator.denominator).to eq(Danica::Wrapper::Number.new(4))
     end
   end
 
@@ -38,7 +38,7 @@ describe Danica::Operator::Division do
 
   describe 'more complex division' do
     describe 'of two additions' do
-      subject do
+      subject(:operator) do
         described_class.new(
           Danica::Operator::Addition.new(2, :x),
           Danica::Operator::Addition.new(3, :y)
@@ -51,7 +51,7 @@ describe Danica::Operator::Division do
         end
 
         it 'groups addition' do
-          expect(subject.to_gnu).to eq(expected)
+          expect(operator.to_gnu).to eq(expected)
         end
       end
     end

data/spec/lib/danica/operator_spec.rb

@@ -11,7 +11,7 @@ class Danica::Operator::Dummy < Danica::Operator
 end
 
 describe Danica::Operator do
-  subject { clazz.new(*variables) }
+  subject(:operator) { clazz.new(*variables) }
 
   let(:variables) { [2, 4] }
   let(:clazz) { described_class::Dummy }
@@ -20,22 +20,22 @@ describe Danica::Operator do
 
   describe 'variables assignment' do
     it 'assignes first variable' do
-      expect(subject.a).to eq(Danica::Wrapper::Number.new(2))
+      expect(operator.a).to eq(Danica::Wrapper::Number.new(2))
     end
 
     it 'assignes second variable' do
-      expect(subject.b).to eq(Danica::Wrapper::Number.new(4))
+      expect(operator.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 first variable' do
-        expect(subject.a).to eq(Danica::Wrapper::Variable.new(name: :A, value: 2))
+        expect(operator.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))
+        expect(operator.b).to eq(Danica::Wrapper::Variable.new(name: :B, value: 4))
       end
     end
   end

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

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 describe Danica::VariablesHolder::Store do
-  subject do
+  subject(:holder) do
     described_class.new(default_variables_hash)
   end
 
@@ -18,7 +18,7 @@ describe Danica::VariablesHolder::Store do
   describe '#variables' do
     context 'when instance has no variables defined' do
       it do
-        expect(subject.variables).not_to be_empty
+        expect(holder.variables).not_to be_empty
       end
 
       # it_behaves_like 'an object that returns the default variables'
@@ -26,7 +26,7 @@ describe Danica::VariablesHolder::Store do
 
     context 'when some variables where defined' do
       before do
-        subject.containers_hash[:y] = Danica::Wrapper::Number.new(1)
+        holder.containers_hash[:y] = Danica::Wrapper::Number.new(1)
       end
 
       let(:expected_variables) do
@@ -38,30 +38,26 @@ describe Danica::VariablesHolder::Store do
       end
 
       it 'returns the default variables and the new set one' do
-        expect(subject.variables)
+        expect(holder.variables)
           .to eq(expected_variables)
       end
 
       it 'does not change the default variables' do
         expect do
-          subject.containers_hash[:x] = Danica::Wrapper::Number.new(2)
-        end.not_to change(subject, :default_variables_hash)
+          holder.containers_hash[:x] = Danica::Wrapper::Number.new(2)
+        end.not_to change(holder, :default_variables_hash)
       end
     end
   end
 
   describe '#variables_hash' do
-    context 'when instance has no variables defined' do
-      # it_behaves_like 'an object that returns the default variables hash'
-    end
-
     context 'when some variables where defined' do
       before do
-        subject.containers_hash[:y] = Danica::Wrapper::Number.new(1)
+        holder.containers_hash[:y] = Danica::Wrapper::Number.new(1)
       end
 
       it 'returns the default hash with the set value' do
-        expect(subject.variables_hash).to eq(
+        expect(holder.variables_hash).to eq(
           x: Danica::Wrapper::Variable.new(name: :x),
           y: Danica::Wrapper::Number.new(1),
           z: Danica::Wrapper::Number.new(10)
@@ -72,7 +68,7 @@ describe Danica::VariablesHolder::Store do
 
   describe '#containers' do
     it 'is an array of Containers' do
-      expect(subject.containers).to all(be_a(Danica::Wrapper::Container))
+      expect(holder.containers).to all(be_a(Danica::Wrapper::Container))
     end
   end
 end