danica 2.7.1 → 2.7.6

data/lib/danica/wrapper/container.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Danica
   class Wrapper::Container
     include Common
     attr_accessor :content
 
     delegate :to_f, :contentd?, :to, :to_tex, :to_gnu, :priority, :grouped?,
-             :signaled?, :constant?, :valued?, :*, :+, :-, :/, :**,
+             :signaled?, :constant?, :valued?, :*, :+, :-, :/, :**, :-@,
              :variables, :variable?, to: :content
 
     default_value :container?, true
@@ -15,10 +17,8 @@ module Danica
 
     def ==(other)
       return content == other unless other.is_a?(self.class)
+
       content == other.content
     end
   end
 end
-
-
-

data/lib/danica/wrapper/group.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Danica
   class Wrapper::Group
     include Common
@@ -24,9 +26,8 @@ module Danica
 
     def ==(other)
       return value == other unless other.is_a?(self.class)
+
       value == other.value
     end
   end
 end
-
-

data/lib/danica/wrapper/negative.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Danica
   class Wrapper::Negative
     include BaseOperations
@@ -25,8 +27,8 @@ module Danica
 
     def ==(other)
       return false unless other.class == self.class
+
       value == other.value
     end
   end
 end
-

data/lib/danica/wrapper/number.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Danica
   class Wrapper::Number
     include BaseOperations
@@ -13,9 +15,10 @@ module Danica
       @value = value
     end
 
-    def to(_, decimals: nil, **__)
+    def to(_format, decimals: nil, **_options)
       return value.to_i.to_s if value.to_i == value
-      return ("%.#{decimals}f" % value).to_f.to_s if decimals
+      return format("%.#{decimals}f", value).to_f.to_s if decimals
+
       value.to_s
     end
 
@@ -29,8 +32,8 @@ module Danica
 
     def ==(other)
       return false unless other.class == self.class
+
       value == other.value
     end
   end
 end
-

data/lib/danica/wrapper/plus_minus.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Danica
   class Wrapper::PlusMinus
     include BaseOperations
@@ -29,8 +31,8 @@ module Danica
 
     def ==(other)
       return false unless other.class == self.class
+
       value == other.value
     end
   end
 end
-

data/lib/danica/wrapper/variable.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 module Danica
   class Wrapper::Variable
     include BaseOperations
     include Common
 
-    attr_accessor :value, :name, :latex, :gnuplot
+    attr_accessor :name, :latex, :gnuplot
+    attr_reader :value
 
     default_value :priority,    10
     default_value :is_grouped?, false
@@ -11,10 +14,10 @@ module Danica
 
     def initialize(*args)
       attrs = args.extract_options!
-      attrs = args.as_hash(%i(name value latex gnuplot)).merge(attrs)
+      attrs = args.as_hash(%i[name value latex gnuplot]).merge(attrs)
 
       attrs.each do |key, value|
-        self.public_send("#{key}=", value)
+        public_send("#{key}=", value)
       end
     end
 
@@ -24,19 +27,22 @@ module Danica
 
     def ==(other)
       return false unless other.class == self.class
-      return other.value == value &&
-             other.name == name &&
-             other.latex == latex &&
-             other.gnuplot == gnuplot
+
+      other.value == value &&
+        other.name == name &&
+        other.latex == latex &&
+        other.gnuplot == gnuplot
     end
 
     def to_tex(**options)
       return value.to_tex(options) if value
+
       (latex || name).to_s
     end
 
     def to_gnu(**options)
       return value.to_gnu(options) if value
+
       (gnuplot || name).to_s
     end
 
@@ -45,4 +51,3 @@ module Danica
     end
   end
 end
-

data/scripts/check_readme.sh

@@ -0,0 +1,6 @@
+#! /bin/bash
+
+PROJECT=danica
+VERSION=$(grep VERSION lib/$PROJECT/version.rb  | sed -e "s/.*'\(.*\)'/\1/g")
+
+grep https://www.rubydoc.info/gems/$PROJECT/$VERSION README.md

data/scripts/rubycritic.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+DIFF_LIST=$(git diff --name-only $CIRCLE_SHA1 $(git merge-base $CIRCLE_SHA1 origin/master) | grep "^lib/")
+
+if [ ! -z "$DIFF_LIST" ]; then
+  mkdir -p tmp/rubycritic/compare
+  bundle exec rubycritic --format console --branch origin/master -t 0 --maximum-decrease 1 $DIFF_LIST
+else
+  echo "No changes detected. Skipping rubycritic..."
+fi

data/spec/integration/global/danica/formatted_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Danica::Formatted do
+  describe 'integration of formatted objects' do
+    subject do
+      variable.tex
+    end
+
+    let(:variable) { Danica.build(:v) { v } }
+
+    context 'when interacting with a multiplication' do
+      let(:other) do
+        Danica.build(:x, :y) { x * y }
+      end
+
+      context 'when multipling another multiplication' do
+        let(:result) { subject * other }
+
+        it do
+          expect(result).to be_a(described_class)
+        end
+
+        it 'knows how to convert it to string' do
+          expect(result.to_s).to eq('v \\cdot x \\cdot y')
+        end
+      end
+
+      context 'when multiplicated by another multiplication' do
+        let(:result) { other * subject }
+
+        it do
+          expect(result).to be_a(described_class)
+        end
+
+        it 'knows how to convert it to string' do
+          expect(result.to_s).to eq('x \\cdot y \\cdot v')
+        end
+      end
+    end
+
+    context 'when interacting with a sum' do
+      let(:other) do
+        Danica.build(:x, :y) { x + y }
+      end
+
+      context 'when summing another sum' do
+        let(:result) { subject + other }
+
+        it do
+          expect(result).to be_a(described_class)
+        end
+
+        it 'knows how to convert it to string' do
+          expect(result.to_s).to eq('v + x + y')
+        end
+      end
+
+      context 'when added by another sum' do
+        let(:result) { other + subject }
+
+        it do
+          expect(result).to be_a(described_class)
+        end
+
+        it 'knows how to convert it to string' do
+          expect(result.to_s).to eq('x + y + v')
+        end
+      end
+    end
+
+    context 'when operating multiplication and subtraction all toguether' do
+      let(:variable) { Danica::Wrapper::Variable.new(:v) }
+      let(:x) { Danica::Wrapper::Variable.new(:x) }
+      let(:result) { x * -subject }
+
+      it do
+        expect(result).to be_a(described_class)
+      end
+
+      it 'knows how to convert it to string' do
+        expect(result.to_s).to eq('x \cdot \left(-v\right)')
+      end
+    end
+  end
+end

data/spec/integration/global/danica/operator/addition_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Danica::Operator::Addition do
+  describe 'integration' do
+    describe 'with negative and positivenegative (+/-) numbers' do
+      subject do
+        described_class.new(
+          Danica::Wrapper::Negative.new(1),
+          2,
+          -3,
+          4,
+          Danica::Wrapper::PlusMinus.new(5),
+          Danica::Wrapper::Number.new(-6)
+        )
+      end
+
+      describe '#to_gnu' do
+        it 'returns the correct string' do
+          expect(subject.to_gnu).to eq('-1 + 2 -3 + 4 + 5 -6')
+        end
+      end
+
+      describe '#to_tex' do
+        it 'returns the correct string' do
+          expect(subject.to_tex).to eq('-1 + 2 -3 + 4 \pm 5 -6')
+        end
+      end
+    end
+  end
+end

data/spec/integration/global/danica/operator/multiplication_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Danica::Operator::Multiplication do
+  describe 'of number and addition' do
+    subject do
+      described_class.new(
+        3, Danica::Operator::Addition.new(2, 4)
+      )
+    end
+
+    describe '#to_gnu' do
+      it 'returns the correct string' do
+        expect(subject.to_gnu).to eq('3 * (2 + 4)')
+      end
+    end
+
+    describe '#to_gnu' do
+      it 'returns the correct string' do
+        expect(subject.to_tex).to eq('3 \cdot \left(2 + 4\right)')
+      end
+    end
+  end
+
+  describe 'of additions' do
+    subject do
+      described_class.new(
+        Danica::Operator::Addition.new(1, 2),
+        Danica::Operator::Addition.new(3, 4)
+      )
+    end
+
+    describe '#to_gnu' do
+      it 'returns the correct string' do
+        expect(subject.to_gnu).to eq('(1 + 2) * (3 + 4)')
+      end
+    end
+
+    describe '#to_tex' do
+      it 'returns the correct string' do
+        expect(subject.to_tex).to eq('\left(1 + 2\right) \cdot \left(3 + 4\right)')
+      end
+    end
+  end
+
+  describe 'when calling * operator' do
+    subject do
+      described_class.new(:x, :y)
+    end
+
+    let(:variable) { Danica::Wrapper::Variable.new(:v) }
+    let(:result) { subject * variable }
+
+    it do
+      expect(result).to be_a(described_class)
+    end
+
+    it 'knows how to order variables' do
+      expect(result.to_gnu).to eq('x * y * v')
+    end
+
+    context 'when called from the other' do
+      let(:result) { variable * subject }
+
+      it do
+        expect(result).to be_a(described_class)
+      end
+
+      it 'knows how to order variables' do
+        expect(result.to_gnu).to eq('v * x * y')
+      end
+    end
+  end
+
+  context 'when multiplicating a negative number' do
+    let(:x) { Danica::Wrapper::Variable.new(:x) }
+    let(:y) { Danica::Wrapper::Variable.new(:y) }
+    let(:negative) { -y }
+    let(:result) { x * negative }
+
+    it do
+      expect(result).to be_a(described_class)
+    end
+
+    it 'knows how to order variables' do
+      expect(result.to_gnu).to eq('x * (-y)')
+    end
+
+    context 'when negative parcel is an expression' do
+      let(:negative) { Danica.build(:y) { -y } }
+
+      it 'knows how to order variables' do
+        expect(result.to_gnu).to eq('x * (-y)')
+      end
+    end
+
+    context 'when negative is the negative of an expression' do
+      let(:negative) { -Danica.build(:y) { y } }
+
+      it 'knows how to order variables' do
+        expect(result.to_gnu).to eq('x * (-y)')
+      end
+    end
+  end
+end

data/spec/integration/{power_spec.rb → global/danica/operator/power_spec.rb}

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe 'integration of power' do
+describe Danica::Operator::Power do
   describe 'of additions' do
     subject do
-      Danica::Operator::Power.new(
+      described_class.new(
         Danica::Operator::Addition.new(3, 4),
         Danica::Operator::Addition.new(5, 6)
       )

data/spec/integration/global/danica/wrapper/negative_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Danica::Wrapper::Negative do
+  describe 'with a addition' do
+    subject do
+      described_class.new(
+        Danica::Operator::Addition.new(1, 2, 3)
+      )
+    end
+
+    describe '#to_gnu' do
+      it 'returns the correct string' do
+        expect(subject.to_gnu).to eq('-(1 + 2 + 3)')
+      end
+    end
+
+    describe '#to_tex' do
+      it 'returns the correct string' do
+        expect(subject.to_tex).to eq('-\left(1 + 2 + 3\right)')
+      end
+    end
+
+    describe 'when it is the result of an expression' do
+      subject do
+        x - negative_parcel
+      end
+
+      let(:x) { Danica::Wrapper::Variable.new(:x) }
+      let(:y) { Danica::Wrapper::Variable.new(:y) }
+      let(:z) { Danica::Wrapper::Variable.new(:z) }
+      let(:negative_parcel) { y + z }
+
+      it 'wraps parcel into a group' do
+        expect(subject.to_gnu).to eq('x -(y + z)')
+      end
+
+      context 'when the negative parcel is an expression' do
+        let(:negative_parcel) { Danica.build(:y, :z) { y + z } }
+
+        it 'wraps parcel into a group' do
+          expect(subject.to_gnu).to eq('x -(y + z)')
+        end
+
+        context 'when negative has just one element' do
+          let(:negative_parcel) { Danica.build(:y) { y } }
+
+          it 'wraps parcel into a group' do
+            expect(subject.to_gnu).to eq('x -y')
+          end
+        end
+      end
+    end
+  end
+end