danica 0.3.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8d8ae393046bb15fcbcd46af8e9430aa50bbbad6
-  data.tar.gz: 835a4b71b6348e1a3da11a34771d4b4864a37894
+  metadata.gz: d3f27550f7488c80de59bfa28553dd0922778607
+  data.tar.gz: 9dfbb7cb1c84689e5798305c9cc255294ee1938f
 SHA512:
-  metadata.gz: 74eb602d0265187cc3505c25b0870d9564a05bb82e6ae072efdca3cba8be6c9a5b04c243c179a68e8fc94f5f5e73fdfca5c941e547ff1d24e4197f14c78e02ba
-  data.tar.gz: a389e884fa35861559a76b78ee907b6525a42a3274ddb6ee25d41a896361b5df5003328b2186fdc6d4a1382b9944b80318c022256e22861b27bd551ec7850425
+  metadata.gz: cfb395f94ecd24d165a833cd4c88991538378a8789ae892aadc34335e51cfdb52bc4a35f17b4b3a3898797e14bb9d81be6d685c6835448ecef0ac964641a4883
+  data.tar.gz: 57bb42340df18ee9e09233c89917452f65bf069f2ca93ee926bcf40296300db2a8fb11604a265fa09ff6ff9325f2d536350529ee15607e61041861ba5426e177

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    danica (0.3.0)
+    danica (1.0.0)
       activemodel
       activesupport
 
@@ -15,6 +15,8 @@ GEM
       i18n (~> 0.7)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
+    codeclimate-test-reporter (0.5.0)
+      simplecov (>= 0.7.1, < 1.0.0)
     coderay (1.1.1)
     concurrent-ruby (1.0.2)
     diff-lcs (1.2.5)
@@ -53,6 +55,7 @@ PLATFORMS
 
 DEPENDENCIES
   bundler (~> 1.6)
+  codeclimate-test-reporter
   danica!
   pry-nav
   rake

data/README.md

@@ -1,4 +1,7 @@
 # danica
+[![Code Climate](https://codeclimate.com/github/darthjee/danica/badges/gpa.svg)](https://codeclimate.com/github/darthjee/danica)
+[![Test Coverage](https://codeclimate.com/github/darthjee/danica/badges/coverage.svg)](https://codeclimate.com/github/darthjee/danica/coverage)
+
 A tool for math formulation on docs
 
 ## How to use
@@ -60,12 +63,16 @@ class Danica::Function
   end
 end
 
-Danica::Function.new(
+fx = Danica::Function.new(
   time: :t,
   acceleration: 'a',
-  initial_space: { name: :S0, latex: 'S_0' },
-  initial_velocity: { name: :V0, latex: 'V_0' }
-).to_tex
+  initial_space: { name: :S0, latex: 'S_0', gnu: 'S0' },
+  initial_velocity: { name: :V0, latex: 'V_0', gnu: 'V0' }
+)
+```
+
+```ruby
+fx.to_tex
 ```
 
 returns
@@ -73,3 +80,12 @@ returns
 S_0 + V_0 \cdot t + \frac{a \cdot t^2}{2}
 ```
 
+```ruby
+fx.to_gnu
+```
+
+returns
+```string
+S0 + V0 * t + a * t**2/2
+```
+

data/danica.gemspec

@@ -24,5 +24,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec-mocks'
   spec.add_development_dependency 'pry-nav'
   spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'codeclimate-test-reporter'
 
 end

data/lib/danica.rb

@@ -4,6 +4,6 @@ module Danica
   require 'danica/number'
   require 'danica/variable'
   require 'danica/function'
-  require 'danica/not_defined'
+  require 'danica/exception'
 end
 

data/lib/danica/exception.rb

@@ -0,0 +1,4 @@
+class Danica::Exception < ::Exception
+  require 'danica/exception/not_defined'
+end
+

data/lib/danica/exception/not_defined.rb

@@ -0,0 +1,2 @@
+class Danica::Exception::NotDefined < Danica::Exception
+end

data/lib/danica/function.rb

@@ -1,39 +1,57 @@
-class Danica::Function
-  include ActiveModel::Model
-
-  require 'danica/function/chained'
-  require 'danica/function/product'
-  require 'danica/function/sum'
-  require 'danica/function/division'
-  require 'danica/function/power'
-  require 'danica/function/square_root'
-
-  attr_accessor :name, :variables
-
-  def to_f
-    raise 'Not IMplemented yet'
-  end
-
-  def to_tex
-    raise 'Not IMplemented yet'
-  end
-
-  def variables=(variables)
-    @variables = variables.map { |v| wrap_value(v) }
-  end
-
-  def valued?
-    to_f.presend?
-  rescue Danica::NotDefined
-    false
-  end
-
-  private
-
-  def wrap_value(value)
-    return Danica::Number.new(value) if value.is_a?(Numeric)
-    return Danica::Variable.new(value) if value.is_a?(Hash)
-    return Danica::Variable.new(name: value) if [ String, Symbol ].any? { |c| value.is_a?(c) }
-    value
+module Danica
+  class Function
+    include ActiveModel::Model
+  
+    require 'danica/function/chained'
+    require 'danica/function/product'
+    require 'danica/function/sum'
+    require 'danica/function/division'
+    require 'danica/function/power'
+    require 'danica/function/square_root'
+  
+    attr_accessor :name, :variables
+  
+    def to_f
+      raise 'Not IMplemented yet'
+    end
+  
+    def to_tex
+      Number.new(to_f).to_tex
+    rescue Exception::NotDefined
+      tex_string
+    end
+
+    def to_gnu
+      Number.new(to_f).to_gnu
+    rescue Exception::NotDefined
+      gnu_string
+    end
+  
+    def variables=(variables)
+      @variables = variables.map { |v| wrap_value(v) }
+    end
+  
+    def valued?
+      to_f.presend?
+    rescue Exception::NotDefined
+      false
+    end
+  
+    private
+  
+    def tex_string
+      raise 'Not IMplemented yet'
+    end
+
+    def gnu_string
+      raise 'Not IMplemented yet'
+    end
+  
+    def wrap_value(value)
+      return Number.new(value) if value.is_a?(Numeric)
+      return Variable.new(value) if value.is_a?(Hash)
+      return Variable.new(name: value) if [ String, Symbol ].any? { |c| value.is_a?(c) }
+      value
+    end
   end
 end

data/lib/danica/function/chained.rb

@@ -5,11 +5,15 @@ module Danica
         chain(variables.map(&:to_f))
       end
 
-      def to_tex
+      private
+
+      def tex_string
         (numeric_to_tex + non_numeric_variables.map(&:to_tex)).join(" #{tex_symbol} ")
       end
 
-      private
+      def gnu_string
+        (numeric_to_tex + non_numeric_variables.map(&:to_gnu)).join(" #{gnu_symbol} ")
+      end
 
       def numeric_variables
         variables.select { |v| v.valued? }

data/lib/danica/function/division.rb

@@ -7,12 +7,6 @@ module Danica
         numerator.to_f / denominator.to_f
       end
 
-      def to_tex
-        Number.new(to_f).to_tex
-      rescue NotDefined
-        "\\frac{#{numerator.to_tex}}{#{denominator.to_tex}}"
-      end
-
       def numerator=(value)
         @numerator = wrap_value(value)
       end
@@ -20,6 +14,16 @@ module Danica
       def denominator=(value)
         @denominator = wrap_value(value)
       end
+
+      private
+
+      def tex_string
+        "\\frac{#{numerator.to_tex}}{#{denominator.to_tex}}"
+      end
+
+      def gnu_string
+        "#{numerator.to_gnu}/#{denominator.to_gnu}"
+      end
     end
   end
 end

data/lib/danica/function/power.rb

@@ -7,12 +7,6 @@ module Danica
         base.to_f ** exponent.to_f
       end
 
-      def to_tex
-        Number.new(to_f).to_tex
-      rescue NotDefined
-        "#{base.to_tex}^{#{exponent.to_tex}}"
-      end
-
       def base=(value)
         @base = wrap_value(value)
       end
@@ -20,6 +14,16 @@ module Danica
       def exponent=(value)
         @exponent = wrap_value(value)
       end
+
+      private
+
+      def tex_string
+        "#{base.to_tex}^{#{exponent.to_tex}}"
+      end
+
+      def gnu_string
+        "#{base.to_gnu}**#{exponent.to_gnu}"
+      end
     end
   end
 end

data/lib/danica/function/product.rb

@@ -7,6 +7,10 @@ module Danica
         '\cdot'
       end
 
+      def gnu_symbol
+        '*'
+      end
+
       def chain_operation(a, b)
         a * b
       end

data/lib/danica/function/square_root.rb

@@ -7,16 +7,19 @@ module Danica
         Math.sqrt(variable.to_f)
       end
 
-      def to_tex
-        Number.new(to_f).to_tex
-      rescue NotDefined
-        "\\sqrt{#{variable.to_tex}}"
-      end
-
       def variable=(value)
         @variable = wrap_value(value)
       end
 
+      private
+
+      def tex_string
+        "\\sqrt{#{variable.to_tex}}"
+      end
+
+      def gnu_string
+        "sqrt(#{variable.to_gnu})"
+      end
     end
   end
 end

data/lib/danica/function/sum.rb

@@ -7,6 +7,10 @@ module Danica
         '+'
       end
 
+      def gnu_symbol
+        '+'
+      end
+
       def chain_operation(a, b)
         a + b
       end

data/lib/danica/number.rb

@@ -18,6 +18,8 @@ module Danica
     def valued?
       value.present?
     end
+
+    alias_method :to_gnu, :to_tex
   end
 end
 

data/lib/danica/variable.rb

@@ -1,19 +1,29 @@
 module Danica
   class Variable
     include ActiveModel::Model
-    attr_accessor :value, :name, :latex
+    attr_accessor :value, :name, :latex, :gnu
 
     def to_f
-      value.nil? ? raise(NotDefined) : value.to_f
+      value.nil? ? raise(Exception::NotDefined) : value.to_f
     end
 
     def to_tex
-      (value || latex || name).to_s
+      return value.to_tex if value
+      (latex || name).to_s
+    end
+
+    def to_gnu
+      return value.to_gnu if value
+      (gnu || name).to_s
     end
 
     def valued?
       value.present?
     end
+
+    def value=(value)
+      @value = value.is_a?(Numeric) ? Number.new(value) : value
+    end
   end
 end
 

data/lib/danica/version.rb

@@ -1,3 +1,3 @@
 module Danica
-  VERSION = '0.3.0'
+  VERSION = '1.0.0'
 end

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

@@ -1,92 +1,23 @@
 require 'spec_helper'
 
 describe Danica::Function::Division do
-  let(:variables_number) { 4 }
-  let(:values) { [ 2, 4 ] }
-  let(:variables) do
-    [ 1, 2 ].map do |i|
-      { name: "X#{i}", value: values[i-1] }
-    end
-  end
   let(:subject) do
     described_class.new(numerator: variables[0], denominator: variables[1])
   end
 
-  describe 'to_f' do
-    context 'when variables are not numbers but have value' do
-      it 'returns the division of the values' do
-        expect(subject.to_f).to eq(1.0 / 2.0)
-      end
-
-      it do
-        expect(subject.to_f).to be_a(Float)
-      end
-    end
-
-    context 'when all the variables are numbers' do
-      let(:variables) { [ 2, 4 ] }
-
-      it 'returns the division of the values' do
-        expect(subject.to_f).to eq(1.0 / 2.0)
-      end
-
-      it do
-        expect(subject.to_f).to be_a(Float)
-      end
-    end
-
-    context 'when one the variables are numbers' do
-      before do
-        variables[0] = 2
-      end
-
-      it 'returns the division of the values' do
-        expect(subject.to_f).to eq(1.0 / 2.0)
-      end
-
-      it do
-        expect(subject.to_f).to be_a(Float)
-      end
-    end
-  end
-
-  describe 'to_tex' do
-    context 'when variables have no value' do
-      let(:variables) do
-        [ 1,2 ].map { |i| "X#{i}" }
-      end
-
-      it 'returns a latex format fraction' do
-        expect(subject.to_tex).to eq('\frac{X1}{X2}')
-      end
-    end
-
-    context 'when one of the variables has value' do
-      before do
-        subject.denominator.value = nil
-      end
-
-      it 'returns the number instead of the value' do
-        expect(subject.to_tex).to eq('\frac{2}{X2}')
-      end
-    end
-
-    context 'when both variables are numeric' do
-      it 'prints the result of the division' do
-        expect(subject.to_tex).to eq('0.5')
-      end
-    end
-
-    context 'when one of the variables is a number' do
-      before do
-        variables[0] = 1
-        subject.denominator.value = nil
-      end
-
-      it 'prints both numbers' do
-        expect(subject.to_tex).to eq('\frac{1}{X2}')
-      end
-    end
-  end
+  it_behaves_like 'a function that has two terms', :division, {
+    values: [ 2, 4 ],
+    calculated: 1.0 / 2.0,
+    to_tex: {
+      string_expected: '\frac{X1}{X2}',
+      numeric_string_expected: '0.5',
+      partial_string_expected: '\frac{2}{X2}'
+    },
+    to_gnu: {
+      string_expected: 'X1/X2',
+      numeric_string_expected: '0.5',
+      partial_string_expected: '2/X2'
+    }
+  }
 end
 

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

@@ -1,92 +1,23 @@
 require 'spec_helper'
 
 describe Danica::Function::Power do
-  let(:variables_number) { 4 }
-  let(:values) { [ 3, 2 ] }
-  let(:variables) do
-    [ 1, 2 ].map do |i|
-      { name: "X#{i}", value: values[i-1] }
-    end
-  end
   let(:subject) do
     described_class.new(base: variables[0], exponent: variables[1])
   end
 
-  describe 'to_f' do
-    context 'when variables are not numbers but have value' do
-      it 'returns the power of the values' do
-        expect(subject.to_f).to eq(9.0)
-      end
-
-      it do
-        expect(subject.to_f).to be_a(Float)
-      end
-    end
-
-    context 'when all the variables are numbers' do
-      let(:variables) { [ 3, 2 ] }
-
-      it 'returns the power of the values' do
-        expect(subject.to_f).to eq(9.0)
-      end
-
-      it do
-        expect(subject.to_f).to be_a(Float)
-      end
-    end
-
-    context 'when one the variables are numbers' do
-      before do
-        variables[0] = 3
-      end
-
-      it 'returns the power of the values' do
-        expect(subject.to_f).to eq(9.0)
-      end
-
-      it do
-        expect(subject.to_f).to be_a(Float)
-      end
-    end
-  end
-
-  describe 'to_tex' do
-    context 'when variables have no value' do
-      let(:variables) do
-        [ 1,2 ].map { |i| "X#{i}" }
-      end
-
-      it 'returns a latex format fraction' do
-        expect(subject.to_tex).to eq('X1^{X2}')
-      end
-    end
-
-    context 'when one of the variables has value' do
-      before do
-        subject.exponent.value = nil
-      end
-
-      it 'returns both variables' do
-        expect(subject.to_tex).to eq('3^{X2}')
-      end
-    end
-
-    context 'when both variables are numeric' do
-      it 'prints the final calculation' do
-        expect(subject.to_tex).to eq('9')
-      end
-    end
-
-    context 'when one of the variables is a number' do
-      before do
-        variables[0] = 1
-        subject.exponent.value = nil
-      end
-
-      it 'prints both variables' do
-        expect(subject.to_tex).to eq('1^{X2}')
-      end
-    end
-  end
+  it_behaves_like 'a function that has two terms', :power, {
+    values: [ 3, 2 ],
+    calculated: 9.0,
+    to_tex: {
+      string_expected: 'X1^{X2}',
+      numeric_string_expected: '9',
+      partial_string_expected: '3^{X2}'
+    },
+    to_gnu: {
+      string_expected: 'X1**X2',
+      numeric_string_expected: '9',
+      partial_string_expected: '3**X2'
+    }
+  }
 end
 

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

@@ -3,9 +3,16 @@ require 'spec_helper'
 describe Danica::Function::Product do
   it_behaves_like 'a function that joins many variables with same operation', {
     calculated: 24,
-    tex_expected: %w(X1 X2 X3 X4).join(' \cdot '),
-    tex_integer_expected: %w(3 X3 X4).join(' \cdot '),
-    tex_float_expected: '10.5 \cdot X4',
-    numeric_variables: [ 1.5, 2, 3.5 ]
+    numeric_variables: [ 1.5, 2, 3.5 ],
+    to_tex: { 
+      string_expected: %w(X1 X2 X3 X4).join(' \cdot '),
+      integer_expected: %w(3 X3 X4).join(' \cdot '),
+      float_expected: '10.5 \cdot X4'
+    },
+    to_gnu: {
+      string_expected: %w(X1 X2 X3 X4).join(' * '),
+      integer_expected: %w(3 X3 X4).join(' * '),
+      float_expected: '10.5 * X4'
+    }
   }
 end

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

@@ -7,7 +7,7 @@ describe Danica::Function::SquareRoot do
     described_class.new(variable: variable)
   end
 
-  describe 'to_f' do
+  describe '#to_f' do
     context 'when variables are not numbers but have value' do
       it 'returns the division of the values' do
         expect(subject.to_f).to eq(3.0)
@@ -31,7 +31,7 @@ describe Danica::Function::SquareRoot do
     end
   end
 
-  describe 'to_tex' do
+  describe '#to_tex' do
     context 'when variables have no value' do
       let(:variable) { :X }
 
@@ -49,5 +49,23 @@ describe Danica::Function::SquareRoot do
       end
     end
   end
-end
 
+  describe '#to_gnu' do
+    context 'when variables have no value' do
+      let(:variable) { :X }
+
+      it 'returns a latex format fraction' do
+        expect(subject.to_gnu).to eq('sqrt(X)')
+      end
+    end
+
+    context 'when the variable is numeric' do
+      before do
+        subject.variable.value = 9
+      end
+      it 'prints both numbers' do
+        expect(subject.to_gnu).to eq('3')
+      end
+    end
+  end
+end

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

@@ -3,9 +3,16 @@ require 'spec_helper'
 describe Danica::Function::Sum do
   it_behaves_like 'a function that joins many variables with same operation', {
     calculated: 10,
-    tex_expected: 'X1 + X2 + X3 + X4',
-    tex_integer_expected: '4 + X3 + X4',
-    tex_float_expected: '7.5 + X4',
-    numeric_variables: [ 1.5, 2.5, 3.5 ]
+    numeric_variables: [ 1.5, 2.5, 3.5 ],
+    to_tex: {
+      string_expected: 'X1 + X2 + X3 + X4',
+      integer_expected: '4 + X3 + X4',
+      float_expected: '7.5 + X4'
+    },
+    to_gnu: {
+      string_expected: 'X1 + X2 + X3 + X4',
+      integer_expected: '4 + X3 + X4',
+      float_expected: '7.5 + X4'
+    }
   }
 end

data/spec/lib/danica/function_spec.rb

@@ -4,7 +4,7 @@ describe Danica::Function do
   class Danica::Function
     class Spatial < Danica::Function
       attr_accessor :time, :acceleration, :initial_space, :initial_velocity
-      delegate :to_tex, to: :sum
+      delegate :to_tex, :to_gnu, to: :sum
 
       private
 
@@ -34,18 +34,19 @@ describe Danica::Function do
     end
   end
 
+  let(:variables) do
+    {
+      time: :t,
+      acceleration: 'a',
+      initial_space: { name: :S0, latex: 'S_0' },
+      initial_velocity: { name: :V0, latex: 'V_0' }
+    }
+  end
+
+  let(:subject) { described_class::Spatial.new(variables) }
+
   describe '#to_tex' do
     context 'when creating the spatial function for constantly accelerated movement' do
-      let(:variables) do
-        {
-          time: :t,
-          acceleration: 'a',
-          initial_space: { name: :S0, latex: 'S_0' },
-          initial_velocity: { name: :V0, latex: 'V_0' }
-        }
-      end
-
-      let(:subject) { described_class::Spatial.new(variables) }
       let(:expected) { 'S_0 + V_0 \cdot t + \frac{a \cdot t^{2}}{2}'  }
 
       it 'return the latex format CAM' do
@@ -53,4 +54,14 @@ describe Danica::Function do
       end
     end
   end
+
+  describe '#to_gnu' do
+    context 'when creating the spatial function for constantly accelerated movement' do
+      let(:expected) { 'S0 + V0 * t + a * t**2/2'  }
+
+      it 'return the latex format CAM' do
+        expect(subject.to_gnu).to eq(expected)
+      end
+    end
+  end
 end

data/spec/lib/danica/number_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Danica::Number do
+  let(:value) { 10 }
+  let(:subject) { described_class.new(value) }
+
+  describe '#to_f' do
+    it 'returns the float of value' do
+      expect(subject.to_f).to eq(10)
+    end
+
+    it { expect(subject.to_f).to be_a(Float) }
+  end
+
+  describe '#to_tex' do
+    context 'when value should be integer' do
+      let(:value) { 10.0 }
+
+      it 'returns the value integer string' do
+        expect(subject.to_tex).to eq('10')
+      end
+    end
+
+    context 'when value should be integer' do
+      let(:value) { 10.5 }
+
+      it 'returns the value integer string' do
+        expect(subject.to_tex).to eq('10.5')
+      end
+    end
+  end
+
+  describe '#to_gnu' do
+    context 'when value should be integer' do
+      let(:value) { 10.0 }
+
+      it 'returns the value integer string' do
+        expect(subject.to_gnu).to eq('10')
+      end
+    end
+
+    context 'when value should be integer' do
+      let(:value) { 10.5 }
+
+      it 'returns the value integer string' do
+        expect(subject.to_gnu).to eq('10.5')
+      end
+    end
+  end
+end

data/spec/lib/danica/variable_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
 describe Danica::Variable do
-  describe 'to_f' do
+  describe '#to_f' do
     context 'when variable has no value' do
-      it { expect { subject.to_f }.to raise_error(Danica::NotDefined) }
+      it { expect { subject.to_f }.to raise_error(Danica::Exception::NotDefined) }
     end
 
     context 'when variable has value' do
@@ -16,23 +16,11 @@ describe Danica::Variable do
     end
   end
 
-  describe 'to_tex' do
-    let(:name) { :delta }
-
-    context 'when latex is not defined ' do
-      let(:subject) { described_class.new name: name }
-
-      it 'returns name' do
-        expect(subject.to_tex).to eq('delta')
-      end
-    end
-
-    context 'when latex has been defined' do
-      let(:subject) { described_class.new name: name, latex: '\delta' }
+  describe '#to_tex' do
+    it_behaves_like 'a variable method to formated string', :to_tex, :latex
+  end
 
-      it 'returns latex' do
-        expect(subject.to_tex).to eq('\delta')
-      end
-    end
+  describe '#to_gnu' do
+    it_behaves_like 'a variable method to formated string', :to_gnu, :gnu
   end
 end

data/spec/spec_helper.rb

@@ -4,6 +4,11 @@ SimpleCov.profiles.define 'gem' do
   add_filter '/spec/'
 end
 
+if ENV['CODECLIMATE_REPO_TOKEN']
+  require 'codeclimate-test-reporter'
+  CodeClimate::TestReporter.start
+end
+
 SimpleCov.start 'gem'
 require 'pry-nav'
 require 'danica'

data/spec/support/shared_examples/{function.rb → function/chained.rb}

@@ -1,6 +1,7 @@
 shared_examples 'a function that joins many variables with same operation' do |arguments|
   it_behaves_like 'a function that knows how to calculate', arguments
   it_behaves_like 'a function that knows how to write to tex', arguments
+  it_behaves_like 'a function that knows how to write to gnu', arguments
 end
 
 shared_examples 'a function that knows how to calculate' do |arguments|
@@ -41,21 +42,30 @@ shared_examples 'a function that knows how to calculate' do |arguments|
 end
 
 shared_examples 'a function that knows how to write to tex' do |arguments|
-  %w(numeric_variables tex_integer_expected tex_expected tex_float_expected).each do |key|
-    let(key) { arguments[key.to_sym]  }
+  it_behaves_like 'a function that knows how to write to a string', :to_tex, arguments
+end
+
+shared_examples 'a function that knows how to write to gnu' do |arguments|
+  it_behaves_like 'a function that knows how to write to a string', :to_gnu, arguments
+end
+
+shared_examples 'a function that knows how to write to a string' do |command, arguments|
+  let(:numeric_variables) { arguments[:numeric_variables]  }
+  %w(integer_expected string_expected float_expected).each do |key|
+    let(key) { arguments[command][key.to_sym]  }
   end
   let(:subject) do
     described_class.new(variables: variables)
   end
 
-  describe 'to_tex' do
+  describe "#{command}" do
     let(:variables) do
       (1..4).map { |i| "X#{i}" }
     end
 
     context 'when variables have no value' do
-      it 'outputs a latex format' do
-        expect(subject.to_tex).to eq(tex_expected)
+      it 'outputs a text format' do
+        expect(subject.public_send(command)).to eq(string_expected)
       end
     end
 
@@ -68,14 +78,14 @@ shared_examples 'a function that knows how to write to tex' do |arguments|
       end
 
       it 'outputs a latex format with colapsed numbers' do
-        expect(subject.to_tex).to eq(tex_integer_expected)
+        expect(subject.public_send(command)).to eq(integer_expected)
       end
 
-      context 'when numeric variables sum is a float value' do
+      context 'when numeric variables calculated is a float value' do
         let(:numeric_variables_index) { 2 }
 
-        it 'outputs a latex format with colapsed numbers' do
-          expect(subject.to_tex).to eq(tex_float_expected)
+        it 'outputs a text format with colapsed numbers' do
+          expect(subject.public_send(command)).to eq(float_expected)
         end
       end
     end
@@ -88,15 +98,15 @@ shared_examples 'a function that knows how to write to tex' do |arguments|
         end
       end
 
-      it 'outputs a latex format with colapsed numbers' do
-        expect(subject.to_tex).to eq(tex_integer_expected)
+      it 'outputs a text format with colapsed numbers' do
+        expect(subject.public_send(command)).to eq(integer_expected)
       end
 
-      context 'when numeric variables sum is a float value' do
+      context 'when numeric variables calculated is a float value' do
         let(:numeric_variables_index) { 2 }
 
-        it 'outputs a latex format with colapsed numbers' do
-          expect(subject.to_tex).to eq(tex_float_expected)
+        it 'outputs a text format with colapsed numbers' do
+          expect(subject.public_send(command)).to eq(float_expected)
         end
       end
     end

data/spec/support/shared_examples/function/dual_term.rb

@@ -0,0 +1,116 @@
+shared_examples 'a function that has two terms' do |name, arguments|
+  it_behaves_like 'a function that has two terms and knows how to calculate it', name, arguments
+  it_behaves_like 'a function that has two terms and knows how to call to_tex', arguments
+  it_behaves_like 'a function that has two terms and knows how to call to_gnu', arguments
+end
+
+shared_examples 'a function that has two terms and knows how to calculate it' do |name, arguments|
+  %w(values calculated).each do |key|
+    let(key) { arguments[key.to_sym]  }
+  end
+
+  let(:variables) do
+    [ 1, 2 ].map do |i|
+      { name: "X#{i}", value: values[i-1] }
+    end
+  end
+
+  describe '#to_f' do
+    context 'when variables are not numbers but have value' do
+      it "returns the #{name} of the values" do
+        expect(subject.to_f).to eq(calculated)
+      end
+
+      it do
+        expect(subject.to_f).to be_a(Float)
+      end
+    end
+
+    context 'when all the variables are numbers' do
+      let(:variables) { values }
+
+      it "returns the #{name} of the values" do
+        expect(subject.to_f).to eq(calculated)
+      end
+
+      it do
+        expect(subject.to_f).to be_a(Float)
+      end
+    end
+
+    context 'when one the variables are numbers' do
+      before do
+        variables[0] = values[0]
+      end
+
+      it "returns the #{name} of the values" do
+        expect(subject.to_f).to eq(calculated)
+      end
+
+      it do
+        expect(subject.to_f).to be_a(Float)
+      end
+    end
+  end
+end
+
+shared_examples 'a function that has two terms and knows how to call to_tex' do |arguments|
+  it_behaves_like 'a function that has two terms and knows how to return a string out of it', :to_tex, arguments
+end
+
+shared_examples 'a function that has two terms and knows how to call to_gnu' do |arguments|
+  it_behaves_like 'a function that has two terms and knows how to return a string out of it', :to_gnu, arguments
+end
+
+shared_examples 'a function that has two terms and knows how to return a string out of it' do |command, arguments|
+  let(:values) { arguments[:values]  }
+
+  %w(string_expected numeric_string_expected partial_string_expected).each do |key|
+    let(key) { arguments[command][key.to_sym]  }
+  end
+  describe "##{command}" do
+    let(:variables) do
+      [ 1, 2 ].map do |i|
+        { name: "X#{i}", value: values[i-1] }
+      end
+    end
+
+    context 'when variables have no value' do
+      let(:variables) do
+        [ 1,2 ].map { |i| "X#{i}" }
+      end
+
+      it 'returns a text format fraction' do
+        expect(subject.public_send(command)).to eq(string_expected)
+      end
+    end
+
+    context 'when one of the variables has value' do
+      before do
+        variables[1][:value] = nil
+      end
+
+      it 'returns the number instead of the value' do
+        expect(subject.public_send(command)).to eq(partial_string_expected)
+      end
+    end
+
+    context 'when both variables are numeric' do
+      it 'prints the result of the calculation' do
+        expect(subject.public_send(command)).to eq(numeric_string_expected)
+      end
+    end
+
+    context 'when one of the variables is a number' do
+      before do
+        variables[0] = values[0]
+        variables[1][:value] = nil
+      end
+
+      it 'prints both parts' do
+        expect(subject.public_send(command)).to eq(partial_string_expected)
+      end
+    end
+  end
+end
+

data/spec/support/shared_examples/variable.rb

@@ -0,0 +1,28 @@
+shared_examples 'a variable method to formated string' do |method, format|
+  let(:name) { :delta }
+  let(:value) { 10.0 }
+  let(:arguments) { { name: name, latex: '\delta', gnu: 'del' } }
+  let(:subject) { described_class.new(arguments) }
+
+  context "when #{format} is not defined" do
+    before { arguments.delete(format) }
+
+    it 'returns name' do
+      expect(subject.public_send(method)).to eq('delta')
+    end
+
+    context 'when value is defined' do
+      before { arguments[:value] = value }
+
+      it 'returns the value' do
+        expect(subject.public_send(method)).to eq('10')
+      end
+    end
+  end
+
+  context "when #{format} has been defined" do
+    it "returns #{format}" do
+      expect(subject.public_send(method)).to eq(arguments[format])
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: danica
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Darthjee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-28 00:00:00.000000000 Z
+date: 2016-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -122,6 +122,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - darthjee@gmail.com
@@ -137,6 +151,8 @@ files:
 - Rakefile
 - danica.gemspec
 - lib/danica.rb
+- lib/danica/exception.rb
+- lib/danica/exception/not_defined.rb
 - lib/danica/function.rb
 - lib/danica/function/chained.rb
 - lib/danica/function/division.rb
@@ -144,7 +160,6 @@ files:
 - lib/danica/function/product.rb
 - lib/danica/function/square_root.rb
 - lib/danica/function/sum.rb
-- lib/danica/not_defined.rb
 - lib/danica/number.rb
 - lib/danica/variable.rb
 - lib/danica/version.rb
@@ -154,9 +169,12 @@ files:
 - spec/lib/danica/function/square_root_spec.rb
 - spec/lib/danica/function/sum_spec.rb
 - spec/lib/danica/function_spec.rb
+- spec/lib/danica/number_spec.rb
 - spec/lib/danica/variable_spec.rb
 - spec/spec_helper.rb
-- spec/support/shared_examples/function.rb
+- spec/support/shared_examples/function/chained.rb
+- spec/support/shared_examples/function/dual_term.rb
+- spec/support/shared_examples/variable.rb
 homepage: 
 licenses: []
 metadata: {}
@@ -187,6 +205,9 @@ test_files:
 - spec/lib/danica/function/square_root_spec.rb
 - spec/lib/danica/function/sum_spec.rb
 - spec/lib/danica/function_spec.rb
+- spec/lib/danica/number_spec.rb
 - spec/lib/danica/variable_spec.rb
 - spec/spec_helper.rb
-- spec/support/shared_examples/function.rb
+- spec/support/shared_examples/function/chained.rb
+- spec/support/shared_examples/function/dual_term.rb
+- spec/support/shared_examples/variable.rb

data/lib/danica/not_defined.rb

@@ -1,2 +0,0 @@
-class Danica::NotDefined < Exception
-end