danica 2.6.4 → 2.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4318506811f5ad7390ad5fac3edff89aad449100
-  data.tar.gz: ea17a7c84ebc531cb69a834299c289d0c3bb61e5
+  metadata.gz: b307b4b7177fbe4174f87da3d4bcad37028c635c
+  data.tar.gz: ab3906ae623e2e99ce5223dffd5868bdac252a6f
 SHA512:
-  metadata.gz: d53e9dfdb02e7c754d0095f95715961e4e2f1a806206453933660c96bdfbac2ae715b5177a2e8b88959a822c2e43b52f935fc961960839df828f6b24ecdf5cf7
-  data.tar.gz: 60b93a47b8d32246fd246d4ca05eb4bea775612986996bdb6f4df67da580a7abd8c9a6407965d544072ef0cef595ef02047dc89246508eb6f49c6cbd54e45935
+  metadata.gz: 6fd900f7a94701ef2717be6177b373e5065b153cfc412431abf3337a1b88636d28146280d298c189cb5d7fc2eca0c337a01331d7e964b4e66a0f1213eb4e47d7
+  data.tar.gz: 1b048a9de7ab0123ba587eae9ec651ff16b0e4e6fd5205aa476894ef8e55eafa8bbd9c87a6ad207985589d744bb1fe7e2da18fed09c882618e02d27f3bbeb3c2

data/README.md

@@ -250,8 +250,8 @@ end
 fx = Danica::Function::Spatial.new(
   time: :t,
   acceleration: 'a',
-  initial_space: { name: :S0, latex: 'S_0', gnu: 'S0' },
-  initial_velocity: { name: :V0, latex: 'V_0', gnu: 'V0' }
+  initial_space: { name: :S0, latex: 'S_0', gnuplot: 'S0' },
+  initial_velocity: { name: :V0, latex: 'V_0', gnuplot: 'V0' }
 )
 ```
 
@@ -511,7 +511,7 @@ Variables can also behave differently when converting to tex or gnu
 
 ```ruby
 Danica::DSL.build do
-  variable(name: :frequency, latex: '\lambda', gnu: :f)
+  variable(name: :frequency, latex: '\lambda', gnuplot: :f)
 end
 ```
 would produce different ```#to_tex``` and ```#to_gnu``` results (```\lambda``` and ```f``` respectvly)
@@ -520,7 +520,7 @@ Also, valued variables will always use their value on string representation
 
 ```ruby
 Danica::DSL.build do
-  variable(name: :frequency, latex: '\lambda', gnu: :f, value: 2)
+  variable(name: :frequency, latex: '\lambda', gnuplot: :f, value: 2)
 end
 ```
 
@@ -601,14 +601,57 @@ While variables with value have a numeric string representation, constants will
 be represented by their string attribute
 
 ```ruby
-Danica::Wrapper::Constant.new(gnu: 'pi', latex: '\pi', value: 3.141592)
+Danica::Wrapper::Constant.new(gnuplot: 'pi', latex: '\pi', value: 3.141592)
 ```
 which will have the returns of ```#to(format)``` obeying the following
 
 ```ruby
 {
   tex: '\pi',
-  gnu: 'pi',
+  gnuplot: 'pi',
   f: 3.141592
 }
 ```
+
+###Formatting
+When generating the output, you can choose options or even
+create a formatted object
+
+#### decimals
+define the float decimals
+
+```ruby
+value = 1 / 3.0
+expression = Danica.build(:x) do
+  x + value
+end
+
+expression.to_tex(decimals: 3)
+```
+
+returns
+
+```string
+x + 0.333
+```
+
+#### Formatted
+Any Danica object can be formatted previously returning a pre-formatted object
+
+
+```ruby
+value = 1 / 3.0
+expression = Danica.build(:x) do
+  x + value
+end
+
+formatted = expression.tex(decimals: 3)
+formatted.to_s
+```
+
+returns
+
+```string
+x + 0.333
+```
+

data/lib/danica.rb

@@ -10,6 +10,7 @@ module Danica
   autoload :Function,         'danica/function'
   autoload :Exception,        'danica/exception'
   autoload :Expressable,      'danica/expressable'
+  autoload :Formatted,        'danica/formatted'
 
   autoload :DSL,              'danica/dsl'
   autoload :Wrapper,          'danica/wrapper'

data/lib/danica/common.rb

@@ -18,33 +18,42 @@ module Danica
 
       default_values :constant?, :signaled?, :container?, :variable?,
                      :variable_holder?, false
+      default_value  :priority, 1
     end
 
     def to_f
       raise Exception::NotImplemented
     end
 
-    def to_tex
-      to(:tex)
+    def to_tex(**options)
+      to(:tex, options)
     end
 
-    def to_gnu
-      to(:gnu)
+    def to_gnu(**options)
+      to(:gnu, options)
     end
 
-    def to(format)
+    def to(format, **options)
       case format.to_sym
       when :tex
-        to_tex
+        to_tex(options)
       when :gnu
-        to_gnu
+        to_gnu(options)
       when :f
         to_f
       else
-        raise Exception::FormatNotFound.new
+        raise Exception::FormattedNotFound.new
       end
     end
 
+    def tex(**options)
+      Formatted.new(self, :tex, options)
+    end
+
+    def gnu(**options)
+      Formatted.new(self, :gnu, options)
+    end
+
     def valued?
       to_f.present?
     rescue Exception::NotDefined

data/lib/danica/equation.rb

@@ -14,8 +14,8 @@ module Danica
       end
     end
 
-    def to(format)
-      "#{left.to(format)} = #{right.to(format)}"
+    def to(*args)
+      "#{left.to(*args)} = #{right.to(*args)}"
     end
   end
 end

data/lib/danica/exception.rb

@@ -1,6 +1,6 @@
 class Danica::Exception < ::Exception
   class NotDefined < self; end
-  class FormatNotFound < self; end
+  class FormattedNotFound < self; end
   class NotImplemented < self; end
 end
 

data/lib/danica/expressable.rb

@@ -5,7 +5,7 @@ module Danica
     included do
       class << self
         def built_with(block_name)
-          self.send(:delegate, :to_f, to: block_name)
+          self.send(:delegate, :to, :to_f, to: block_name)
 
           self.send(:define_singleton_method, :build) do |*vars, &block|
             Class.new(self) do

data/lib/danica/expression.rb

@@ -7,7 +7,7 @@ module Danica
 
     autoload :Gauss,    'danica/expression/gauss'
 
-    delegate :to, :is_grouped?, :priority, to: :expression_block
+    delegate :is_grouped?, :priority, to: :expression_block
 
     built_with(:expression_block)
   end

data/lib/danica/expression/gauss.rb

@@ -1,5 +1,5 @@
 module Danica
-  class Expression::Gauss < Expression.build(:x, average: { latex: '\mu', gnu: :u }, variance_root: { latex: '\sigma', gnu: :v }) { num(1) / denominator * exponential(exp) }
+  class Expression::Gauss < Expression.build(:x, average: { latex: '\mu', gnuplot: :u }, variance_root: { latex: '\sigma', gnuplot: :v }) { num(1) / denominator * exponential(exp) }
 
     private
 

data/lib/danica/formatted.rb

@@ -0,0 +1,30 @@
+class Danica::Formatted
+  attr_reader :content, :format, :decimals
+
+  def initialize(content, format, decimals: nil)
+    @content = content
+    @format = format
+    @decimals = decimals
+  end
+
+  def to_s
+    content.to(format, decimals: decimals)
+  end
+
+  def ==(other)
+    return false unless other.class == self.class
+    return other.content == content &&
+           other.format == format
+  end
+
+  private
+
+  def method_missing(method, *args)
+    value = content.public_send(method, *args)
+    return value unless value.is_a?(Danica::Common)
+    self.class.new(
+      value,
+      format
+    )
+  end
+end

data/lib/danica/function/name.rb

@@ -8,8 +8,8 @@ module Danica
       @containers = variables.map { |v| wrap_value(v) }
     end
 
-    def to(format)
-      "#{name}(#{description_variables(format)})"
+    def to(*args)
+      "#{name}(#{description_variables(*args)})"
     end
 
     def variables
@@ -18,8 +18,10 @@ module Danica
 
     private
 
-    def description_variables(format)
-      variables_for(format).map { |v| v.to(format) }.join(', ')
+    def description_variables(format, **options)
+      variables_for(format).map do |value|
+        value.to(format, options)
+      end.join(', ')
     end
 
     def variables_for(format)

data/lib/danica/operator/chained.rb

@@ -14,8 +14,8 @@ module Danica
         variables.include?(value.content)
       end
 
-      def to(format)
-        extractor = string_extractor(format)
+      def to(format, **options)
+        extractor = string_extractor(format, **options)
         variables.procedural_join(extractor, &join_proc(symbol(format)))
       end
 
@@ -38,10 +38,10 @@ module Danica
         proc { " #{symbol} " }
       end
 
-      def string_extractor(method)
+      def string_extractor(*args)
         proc do |parcel|
           parcel = wrap_as_group(parcel)
-          parcel.to(method)
+          parcel.to(*args)
         end
       end
 

data/lib/danica/operator/division.rb

@@ -8,12 +8,12 @@ module Danica
       numerator.to_f / denominator.to_f
     end
 
-    def to_tex
-      "\\frac{#{numerator.to_tex}}{#{denominator.to_tex}}"
+    def to_tex(**options)
+      "\\frac{#{numerator.to_tex(options)}}{#{denominator.to_tex(options)}}"
     end
 
-    def to_gnu
-      "(#{numerator.to_gnu})/(#{denominator.to_gnu})"
+    def to_gnu(**options)
+      "(#{numerator.to_gnu(options)})/(#{denominator.to_gnu(options)})"
     end
   end
 end

data/lib/danica/operator/functional.rb

@@ -14,12 +14,12 @@ module Danica
             Math.#{operator}(value.to_f)
           end
 
-          def to_tex
-            '#{tex.gsub(':value:', "' + value.to_tex + '")}'
+          def to_tex(**options)
+            '#{tex.gsub(':value:', "' + value.to_tex(options) + '")}'
           end
 
-          def to_gnu
-            '#{gnu.gsub(':value:', "' + value.to_gnu + '")}'
+          def to_gnu(**options)
+            '#{gnu.gsub(':value:', "' + value.to_gnu(options) + '")}'
           end
         ))
       end

data/lib/danica/operator/power.rb

@@ -7,12 +7,12 @@ module Danica
       base.to_f ** exponent.to_f
     end
 
-    def to_tex
-      "#{wrap_as_group(base).to_tex}^{#{exponent.to_tex}}"
+    def to_tex(**options)
+      "#{wrap_as_group(base).to_tex(options)}^{#{exponent.to_tex(options)}}"
     end
 
-    def to_gnu
-      "#{ wrap_as_group(base).to_gnu}**(#{exponent.to_gnu})"
+    def to_gnu(**options)
+      "#{ wrap_as_group(base).to_gnu(options)}**(#{exponent.to_gnu(options)})"
     end
   end
 end

data/lib/danica/version.rb

@@ -1,3 +1,3 @@
 module Danica
-  VERSION = '2.6.4'
+  VERSION = '2.7.1'
 end

data/lib/danica/wrapper.rb

@@ -23,7 +23,7 @@ module Danica
     end
 
     def self.wrap_hash(hash)
-      return Constant.new(hash) if hash.keys.map(&:to_sym).sort == %i(gnu latex value)
+      return Constant.new(hash) if hash.keys.map(&:to_sym).sort == %i(gnuplot latex value)
       Variable.new(hash)
     end
 

data/lib/danica/wrapper/constant.rb

@@ -3,7 +3,7 @@ module Danica
     include BaseOperations
     include Common
 
-    attr_reader :value, :latex, :gnu
+    attr_reader :value, :latex, :gnuplot
 
     default_value :priority, 10
     default_value :valued?, true
@@ -12,7 +12,7 @@ module Danica
 
     def initialize(*args)
       attrs = args.extract_options!
-      attrs = args.as_hash(%i(value latex gnu)).merge(attrs)
+      attrs = args.as_hash(%i(value latex gnuplot)).merge(attrs)
 
       attrs.each do |key, value|
         self.send("#{key}=", value)
@@ -25,15 +25,15 @@ module Danica
 
     def ==(other)
       return false unless other.class == self.class
-      gnu == other.gnu && latex == other.latex && value == other.value
+      gnuplot == other.gnuplot && latex == other.latex && value == other.value
     end
 
-    def to_tex
+    def to_tex(**_)
       latex.to_s
     end
 
-    def to_gnu
-      gnu.to_s
+    def to_gnu(**_)
+      gnuplot.to_s
     end
 
     private
@@ -46,8 +46,8 @@ module Danica
       @latex = latex
     end
 
-    def gnu=(gnu)
-      @gnu = gnu
+    def gnuplot=(gnuplot)
+      @gnuplot = gnuplot
     end
   end
 

data/lib/danica/wrapper/group.rb

@@ -14,12 +14,12 @@ module Danica
       @value = wrap_value(value)
     end
 
-    def to_tex
-      "\\left(#{value.to_tex}\\right)"
+    def to_tex(**options)
+      "\\left(#{value.to_tex(options)}\\right)"
     end
 
-    def to_gnu
-      "(#{value.to_gnu})"
+    def to_gnu(**options)
+      "(#{value.to_gnu(options)})"
     end
 
     def ==(other)

data/lib/danica/wrapper/negative.rb

@@ -19,8 +19,8 @@ module Danica
       -value.to_f
     end
 
-    def to(format)
-      "-#{wrap_as_group(value).to(format)}"
+    def to(*args)
+      "-#{wrap_as_group(value).to(*args)}"
     end
 
     def ==(other)

data/lib/danica/wrapper/number.rb

@@ -13,8 +13,9 @@ module Danica
       @value = value
     end
 
-    def to(_)
+    def to(_, decimals: nil, **__)
       return value.to_i.to_s if value.to_i == value
+      return ("%.#{decimals}f" % value).to_f.to_s if decimals
       value.to_s
     end
 

data/lib/danica/wrapper/plus_minus.rb

@@ -19,12 +19,12 @@ module Danica
       value.to_f
     end
 
-    def to_tex
-      "\\pm #{wrap_as_group(value).to_tex}"
+    def to_tex(**options)
+      "\\pm #{wrap_as_group(value).to_tex(options)}"
     end
 
-    def to_gnu
-      "+ #{wrap_as_group(value).to_gnu}"
+    def to_gnu(**options)
+      "+ #{wrap_as_group(value).to_gnu(options)}"
     end
 
     def ==(other)

data/lib/danica/wrapper/variable.rb

@@ -3,7 +3,7 @@ module Danica
     include BaseOperations
     include Common
 
-    attr_accessor :value, :name, :latex, :gnu
+    attr_accessor :value, :name, :latex, :gnuplot
 
     default_value :priority,    10
     default_value :is_grouped?, false
@@ -11,7 +11,7 @@ module Danica
 
     def initialize(*args)
       attrs = args.extract_options!
-      attrs = args.as_hash(%i(name value latex gnu)).merge(attrs)
+      attrs = args.as_hash(%i(name value latex gnuplot)).merge(attrs)
 
       attrs.each do |key, value|
         self.public_send("#{key}=", value)
@@ -27,17 +27,17 @@ module Danica
       return other.value == value &&
              other.name == name &&
              other.latex == latex &&
-             other.gnu == gnu
+             other.gnuplot == gnuplot
     end
 
-    def to_tex
-      return value.to_tex if value
+    def to_tex(**options)
+      return value.to_tex(options) if value
       (latex || name).to_s
     end
 
-    def to_gnu
-      return value.to_gnu if value
-      (gnu || name).to_s
+    def to_gnu(**options)
+      return value.to_gnu(options) if value
+      (gnuplot || name).to_s
     end
 
     def value=(value)

data/spec/integration/readme/constant_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Danica::Wrapper::Constant do
   subject do
-    Danica::Wrapper::Constant.new(gnu: 'pi', latex: '\pi', value: 3.141592)
+    Danica::Wrapper::Constant.new(gnuplot: 'pi', latex: '\pi', value: 3.141592)
   end
   let(:output) do
     {

data/spec/integration/readme/function_spec.rb

@@ -5,8 +5,8 @@ describe Danica::Function::Spatial do
     described_class.new(
       time: :t,
       acceleration: 'a',
-      initial_space: { name: :S0, latex: 'S_0', gnu: 'S0' },
-      initial_velocity: { name: :V0, latex: 'V_0', gnu: 'V0' }
+      initial_space: { name: :S0, latex: 'S_0', gnuplot: 'S0' },
+      initial_velocity: { name: :V0, latex: 'V_0', gnuplot: 'V0' }
     )
   end
 

data/spec/integration/readme/variables_spec.rb

@@ -37,7 +37,7 @@ describe Danica::Wrapper::Variable do
     context 'when variable has value' do
       subject do
         Danica::DSL.build do
-          variable(name: :frequency, latex: '\lambda', gnu: :f, value: 2)
+          variable(name: :frequency, latex: '\lambda', gnuplot: :f, value: 2)
         end
       end
 
@@ -82,7 +82,7 @@ describe Danica::Wrapper::Variable do
   describe 'custom outputs' do
     subject do
       Danica::DSL.build do
-        variable(name: :frequency, latex: '\lambda', gnu: :f)
+        variable(name: :frequency, latex: '\lambda', gnuplot: :f)
       end
     end
 

data/spec/lib/danica/common_spec.rb

@@ -5,19 +5,19 @@ module Danica
     class Dummy
       include Common
 
-      def to_tex
-        'tex'
+      def to_tex(**options)
+        options.empty? ? 'tex' : "tex #{options}"
       end
 
-      def to_gnu
-        'gnu'
+      def to_gnu(**options)
+        options.empty? ? 'gnu' : "gnu #{options}"
       end
     end
 
     class Dummy2
       include Common
 
-      def to(format)
+      def to(format, **_)
         "formatted: #{format}"
       end
     end
@@ -27,6 +27,7 @@ end
 describe Danica::Common do
   let(:clazz) { described_class::Dummy }
   subject { clazz.new }
+  it_behaves_like 'an object that respond to basic_methods'
 
   describe '#to_f' do
     it do
@@ -62,7 +63,12 @@ describe Danica::Common do
         it do
           expect do
             subject.to('format')
-          end.to raise_error(Danica::Exception::FormatNotFound)
+          end.to raise_error(Danica::Exception::FormattedNotFound)
+        end
+      end
+      context 'when passing options' do
+        it 'passes the options ahead' do
+          expect(subject.to(:gnu, { opt: 1 })).to eq('gnu {:opt=>1}')
         end
       end
     end
@@ -85,4 +91,36 @@ describe Danica::Common do
       end
     end
   end
+
+  describe '#tex' do
+    it do
+      expect(subject.tex).to be_a(Danica::Formatted)
+    end
+
+    it 'knows how to return a tex string' do
+      expect(subject.tex.to_s).to eq('tex {:decimals=>nil}')
+    end
+
+    context 'when passing options' do
+      it 'uses the arguments' do
+        expect(subject.tex(decimals: 3).to_s).to eq('tex {:decimals=>3}')
+      end
+    end
+  end
+
+  describe '#gnu' do
+    it do
+      expect(subject.gnu).to be_a(Danica::Formatted)
+    end
+
+    it 'knows how to return a gnu string' do
+      expect(subject.gnu.to_s).to eq('gnu {:decimals=>nil}')
+    end
+
+    context 'when passing options' do
+      it 'uses the arguments' do
+        expect(subject.gnu(decimals: 3).to_s).to eq('gnu {:decimals=>3}')
+      end
+    end
+  end
 end

data/spec/lib/danica/equation_spec.rb

@@ -12,6 +12,8 @@ describe Danica::Equation do
     clazz.new
   end
 
+  it_behaves_like 'an object that respond to basic_methods'
+
   describe '.build' do
     it 'returns a class that is also an equation' do
       expect(subject).to be_a(Danica::Equation)

data/spec/lib/danica/expressable_spec.rb

@@ -3,11 +3,18 @@ require 'spec_helper'
 class Danica::Expressable::Dummy
   include Danica::Expressable
 
+  delegate :to, to: :the_block
+
   built_with :the_block
 end
 
 describe Danica::Expressable do
   let(:clazz) { described_class::Dummy }
+  subject do
+    clazz.create(:x) { x }
+  end
+
+  it_behaves_like 'an object that respond to basic_methods', ignore: %i(valued? container? is_grouped? priority)
 
   describe '.build' do
     it 'responds to build' do

data/spec/lib/danica/expression/gauss_spec.rb

@@ -5,7 +5,7 @@ describe Danica::Expression::Gauss do
     {
       x: :x,
       average: :u,
-      variance_root: { latex: '\theta', gnu: :v }
+      variance_root: { latex: '\theta', gnuplot: :v }
     }
   end
 

data/spec/lib/danica/formatted_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+describe Danica::Formatted do
+  let(:content) { Danica::Wrapper::Variable.new(latex: :V, gnuplot: :v) }
+  let(:format) { :tex }
+  let(:options) { {} }
+  subject do
+    described_class.new(content, format, options)
+  end
+
+  describe '#to_s' do
+    context 'when format is tex' do
+      it 'return the expected tex string' do
+        expect(subject.to_s).to eq('V')
+      end
+    end
+
+    context 'when format is gnu' do
+      let(:format) { :gnu }
+
+      it 'return the expected gnu string' do
+        expect(subject.to_s).to eq('v')
+      end
+    end
+
+    context 'when variable has numeric value' do
+      let(:content) { Danica::Wrapper::Number.new(1/3.0) }
+
+      it 'returns the formatted number' do
+        expect(subject.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')
+        end
+      end
+    end
+  end
+
+  describe 'operators' do
+    describe '+' do
+      it do
+        expect(subject + 2).to be_a(described_class)
+      end
+
+      it 'keeps being able to parse format' do
+        expect((subject + 2).to_s).to eq('V + 2')
+      end
+    end
+
+    describe '*' do
+      it do
+        expect(subject * 2).to be_a(described_class)
+      end
+
+      it 'keeps being able to parse format' do
+        expect((subject * 2).to_s).to eq('V \cdot 2')
+      end
+    end
+
+    describe '-@' do
+      it do
+        expect(-subject).to be_a(described_class)
+      end
+
+      it 'keeps being able to parse format' do
+        expect((-subject).to_s).to eq('-V')
+      end
+    end
+  end
+
+  describe '#to_f' do
+    let(:content) { Danica::Wrapper::Number.new(2) }
+
+    it do
+      expect(subject.to_f).to be_a(Numeric)
+    end
+
+    it 'returns the number' do
+      expect(subject.to_f).to eq(2)
+    end
+  end
+
+  describe '#to' do
+    it do
+      expect(subject.to(:tex)).to be_a(String)
+    end
+
+    it 'returns the string' do
+      expect(subject.to(:tex)).to eq('V')
+    end
+  end
+
+  describe '#tex' do
+    it do
+      expect(subject.tex).to be_a(Danica::Formatted)
+    end
+
+    context 'when original format is tex' do
+      it 'returns the tex string' do
+        expect(subject.tex.to_s).to eq('V')
+      end
+
+      it 'returns similar object' do
+        expect(subject.tex).to eq(subject)
+      end
+    end
+
+    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
+
+      it 'returns a new format object' do
+        expect(subject.tex).not_to eq(subject)
+      end
+    end
+  end
+
+  describe '#gnu' do
+    it do
+      expect(subject.gnu).to be_a(Danica::Formatted)
+    end
+
+    context 'when original format is tex' do
+      it 'returns the gnu string' do
+        expect(subject.gnu.to_s).to eq('v')
+      end
+    end
+
+    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
+    end
+  end
+end

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

@@ -1,9 +1,11 @@
 require 'spec_helper'
 
 describe Danica::Function::Name do
-  let(:x) {  Danica::Wrapper::Variable.new(name: :x, latex: '\mu', gnu: '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'
+
   describe '#to_tex' do
     it 'returns the name of the function with tex variables' do
       expect(subject.to_tex).to eq('f(\mu)')
@@ -18,7 +20,7 @@ describe Danica::Function::Name do
     end
   end
 
-  describe '#to_tex' do
+  describe '#to_gnu' do
     it 'returns the name of the function with tex variables' do
       expect(subject.to_gnu).to eq('f(u)')
     end

data/spec/lib/danica/function_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 shared_examples 'a generically generated function' do
+  it_behaves_like 'an object that respond to basic_methods'
+
   it 'returns a function class' do
     expect(function.class.superclass).to eq(described_class)
   end
@@ -192,7 +194,7 @@ describe Danica::Function do
 
       context 'from a hash' do
         let(:function) do
-          function_class.new(name: :f, x: { latex: '\pi', gnu: 'pi', value: 3.14 })
+          function_class.new(name: :f, x: { latex: '\pi', gnuplot: 'pi', value: 3.14 })
         end
 
         it 'ignores the constant in the definition' do
@@ -244,7 +246,7 @@ describe Danica::Function do
 
       context 'from a hash' do
         let(:function) do
-          function_class.new(name: :f, x: { latex: '\pi', gnu: 'pi', value: 3.14 })
+          function_class.new(name: :f, x: { latex: '\pi', gnuplot: 'pi', value: 3.14 })
         end
 
         it 'ignores the constant in the definition' do

data/spec/lib/danica/operator_spec.rb

@@ -2,6 +2,10 @@ require 'spec_helper'
 
 class Danica::Operator::Dummy < Danica::Operator
   variables :a, :b
+
+  def to(*args)
+    a + b
+  end
 end
 
 describe Danica::Operator do
@@ -9,6 +13,8 @@ describe Danica::Operator do
   let(:clazz) { described_class::Dummy }
   subject { clazz.new(*variables) }
 
+  it_behaves_like 'an object that respond to basic_methods'
+
   describe 'variables assignment' do
     it 'assignes the variables tpo its places' do
       expect(subject.a).to eq(Danica::Wrapper::Number.new(2))

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

@@ -44,7 +44,7 @@ describe Danica::Wrapper::Constant do
       it do
         expect do
           subject.to('format')
-        end.to raise_error(Danica::Exception::FormatNotFound)
+        end.to raise_error(Danica::Exception::FormattedNotFound)
       end
     end
   end
@@ -62,11 +62,11 @@ describe Danica::Wrapper::Constant do
   end
 
   context 'when initializing from hash' do
-    subject { described_class.new(value: 2.5, latex: :M, gnu: :m) }
+    subject { described_class.new(value: 2.5, latex: :M, gnuplot: :m) }
 
     it 'initialize normaly' do
       expect do
-        described_class.new(value: 2.5, latex: :M, gnu: :m)
+        described_class.new(value: 2.5, latex: :M, gnuplot: :m)
       end.not_to raise_error
     end
 

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

@@ -27,38 +27,10 @@ describe Danica::Wrapper::Number do
   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 a float' do
-      let(:value) { 10.5 }
-
-      it 'returns the value float string' do
-        expect(subject.to_tex).to eq('10.5')
-      end
-    end
+    it_behaves_like 'a method that display the numeric value', :to_tex
   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
+    it_behaves_like 'a method that display the numeric value', :to_gnu
   end
 end

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

@@ -39,6 +39,6 @@ describe Danica::Wrapper::Variable do
   end
 
   describe '#to_gnu' do
-    it_behaves_like 'a variable method to formated string', :to_gnu, :gnu
+    it_behaves_like 'a variable method to formated string', :to_gnu, :gnuplot
   end
 end

data/spec/lib/danica/wrapper_spec.rb

@@ -38,7 +38,7 @@ describe Danica::Wrapper do
 
     context 'when value is a Hash' do
       context 'but it is a constant' do
-        let(:value) { { value: 10, latex: :x, gnu: :X } }
+        let(:value) { { value: 10, latex: :x, gnuplot: :X } }
 
         it do
           expect(subject.wrapped_value.content).to be_a(Danica::Wrapper::Constant)

data/spec/support/shared_examples/common.rb

@@ -1,6 +1,23 @@
-shared_examples 'an object that respond to basic_methods' do |ignore: [], methods: %i(to_f to_tex to_gnu priority valued?)|
+shared_examples 'an object that respond to basic_methods' do |ignore: [], methods: %i(to_f to_tex to_gnu priority valued? container? variable? variable_holder?)|
   (methods - ignore).each do |method|
     it { expect(subject).to respond_to(method) }
   end
-end
 
+  it 'accepts option on tex format' do
+    expect do
+      subject.to_tex(decimals: 2)
+    end.not_to raise_error
+  end
+
+  it 'accepts option on gnu format' do
+    expect do
+      subject.to_gnu(decimals: 2)
+    end.not_to raise_error
+  end
+
+  it 'accepts option on to format' do
+    expect do
+      subject.to(:gnu, decimals: 2)
+    end.not_to raise_error
+  end
+end

data/spec/support/shared_examples/variable.rb

@@ -1,7 +1,7 @@
 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(:arguments) { { name: name, latex: '\delta', gnuplot: 'del' } }
   subject { described_class.new(arguments) }
 
   context "when #{format} is not defined" do
@@ -13,10 +13,7 @@ shared_examples 'a variable method to formated string' do |method, format|
 
     context 'when value is defined' do
       before { arguments[:value] = value }
-
-      it 'returns the value' do
-        expect(subject.public_send(method)).to eq('10')
-      end
+      it_behaves_like 'a method that display the numeric value', method
     end
   end
 
@@ -26,3 +23,41 @@ shared_examples 'a variable method to formated string' do |method, format|
     end
   end
 end
+
+shared_examples 'a method that display the numeric value' do |method|
+  context 'when value should be integer' do
+    let(:value) { 10.0 }
+
+    it 'returns the value integer string' do
+      expect(subject.public_send(method)).to eq('10')
+    end
+
+    context 'and passing the decimals argument' do
+      it 'returns the value float string' do
+        expect(subject.public_send(method, decimals: 4)).to eq('10')
+      end
+    end
+  end
+
+  context 'when value should be a float' do
+    let(:value) { 10 / 3.0 }
+
+    it 'returns the value float string' do
+      expect(subject.public_send(method)).to eq('3.3333333333333335')
+    end
+
+    context 'and passing the decimals argument' do
+      it 'returns the value float string' do
+        expect(subject.public_send(method, decimals: 4)).to eq('3.3333')
+      end
+    end
+
+    context 'but the number has less decimals' do
+      let(:value) { 10.5 }
+
+      it 'returns the value integer string' do
+        expect(subject.public_send(method, decimals: 4)).to eq('10.5')
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: danica
 version: !ruby/object:Gem::Version
-  version: 2.6.4
+  version: 2.7.1
 platform: ruby
 authors:
 - Darthjee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-12 00:00:00.000000000 Z
+date: 2018-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -149,6 +149,7 @@ files:
 - lib/danica/expressable.rb
 - lib/danica/expression.rb
 - lib/danica/expression/gauss.rb
+- lib/danica/formatted.rb
 - lib/danica/function.rb
 - lib/danica/function/name.rb
 - lib/danica/operator.rb
@@ -195,6 +196,7 @@ files:
 - spec/lib/danica/expressable_spec.rb
 - spec/lib/danica/expression/gauss_spec.rb
 - spec/lib/danica/expression_spec.rb
+- spec/lib/danica/formatted_spec.rb
 - spec/lib/danica/function/name_spec.rb
 - spec/lib/danica/function_spec.rb
 - spec/lib/danica/operator/addition_spec.rb
@@ -278,6 +280,7 @@ test_files:
 - spec/lib/danica/expressable_spec.rb
 - spec/lib/danica/expression/gauss_spec.rb
 - spec/lib/danica/expression_spec.rb
+- spec/lib/danica/formatted_spec.rb
 - spec/lib/danica/function/name_spec.rb
 - spec/lib/danica/function_spec.rb
 - spec/lib/danica/operator/addition_spec.rb