danica 2.7.1 → 2.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b307b4b7177fbe4174f87da3d4bcad37028c635c
-  data.tar.gz: ab3906ae623e2e99ce5223dffd5868bdac252a6f
+  metadata.gz: 204973e375504667567ab1246d44e05a1375e407
+  data.tar.gz: 0ec10d6273e79affbbb3624795cc00dd06321687
 SHA512:
-  metadata.gz: 6fd900f7a94701ef2717be6177b373e5065b153cfc412431abf3337a1b88636d28146280d298c189cb5d7fc2eca0c337a01331d7e964b4e66a0f1213eb4e47d7
-  data.tar.gz: 1b048a9de7ab0123ba587eae9ec651ff16b0e4e6fd5205aa476894ef8e55eafa8bbd9c87a6ad207985589d744bb1fe7e2da18fed09c882618e02d27f3bbeb3c2
+  metadata.gz: d63fd9fa21b3a5894d55d3a53d6af203f4bfb2f4f78162a9c7d38877f146c9a69f04851fffa6a331f03d2bd533f0945a3de70b88236e577af278e95fdc3cccae
+  data.tar.gz: 21d8fb184a94220c656d8631cf9b230f6f4911cc675333b5188176b379177499cb2522c4e2a306107d4347aa86585ec2c9ee281cedab70e47eaff743668b567f

data/lib/danica/base_operations.rb

@@ -1,29 +1,34 @@
 module Danica
   module BaseOperations
     def +(other)
-      return other + self if other.is_a?(Operator::Addition)
-      addition(self, other)
+      formatted_operation other, addition(self, other)
     end
 
     def *(other)
-      return other * self if other.is_a?(Operator::Multiplication)
-      multiplication(self, other)
+      formatted_operation other, multiplication(self, other)
     end
 
     def /(other)
-      division(self, other)
+      formatted_operation other, division(self, other)
     end
 
     def -(other)
-      self + negative(other)
+      formatted_operation other, (self + negative(other))
     end
 
     def **(other)
-      power(self, other)
+      formatted_operation other, power(self, other)
     end
 
     def -@
       negative(self)
     end
+
+    private
+
+    def formatted_operation(other, value)
+      return other.repack(value) if other.is_a?(Danica::Formatted)
+      value
+    end
   end
 end

data/lib/danica/common.rb

@@ -4,23 +4,23 @@ module Danica
       include Wrapper
       include DSL
 
-      class << self
-        def default_value(name, value)
-          define_method(name) { |*_| value }
-        end
-
-        def default_values(*names, value)
-          names.each do |name|
-            default_value(name, value)
-          end
-        end
-      end
-
       default_values :constant?, :signaled?, :container?, :variable?,
                      :variable_holder?, false
       default_value  :priority, 1
     end
 
+    class_methods do
+      def default_value(name, value)
+        define_method(name) { |*_| value }
+      end
+
+      def default_values(*names, value)
+        names.each do |name|
+          default_value(name, value)
+        end
+      end
+    end
+
     def to_f
       raise Exception::NotImplemented
     end
@@ -47,11 +47,15 @@ module Danica
     end
 
     def tex(**options)
-      Formatted.new(self, :tex, options)
+      formatted(:tex, options)
     end
 
     def gnu(**options)
-      Formatted.new(self, :gnu, options)
+      formatted(:gnu, options)
+    end
+
+    def formatted(*args)
+      Formatted.new(self, *args)
     end
 
     def valued?

data/lib/danica/dsl/builder.rb

@@ -0,0 +1,37 @@
+module Danica
+  module DSL
+    class Builder
+      attr_reader :method, :claz, :base
+
+      def initialize(method, claz=nil, base=nil)
+        @method = method
+        @claz = claz
+        @base = base
+      end
+
+      def build
+        DSL.register_class(method, clazz)
+      end
+
+      private
+
+      def clazz
+        @clazz ||= build_clazz
+      end
+
+      def build_clazz
+        return clazz_from_method unless claz
+        return claz if claz.is_a? Class
+        clazz_from_string
+      end
+
+      def clazz_from_method
+        [base.to_s, method.to_s.camelize].compact.join('::').constantize
+      end
+
+      def clazz_from_string
+        [base, claz.to_s].compact.join('::').constantize
+      end
+    end
+  end
+end

data/lib/danica/dsl.rb

@@ -1,5 +1,7 @@
 module Danica
   module DSL
+    autoload :Builder, 'danica/dsl/builder'
+
     class << self
       def register_operator(method, clazz=nil)
         register(method, clazz, 'Danica::Operator')
@@ -10,9 +12,11 @@ module Danica
       end
 
       def register(method, clazz=nil, base=nil)
-        define_method method do |*args|
-          clazz = [base.to_s, method.to_s.camelize].compact.join('::').constantize unless clazz
-          clazz = [base, clazz.to_s].compact.join('::').constantize unless clazz.is_a? Class
+        Builder.new(method, clazz, base).build
+      end
+
+      def register_class(method, clazz)
+        define_method(method) do |*args|
           clazz.new(*args)
         end
       end

data/lib/danica/exception.rb

@@ -2,5 +2,16 @@ class Danica::Exception < ::Exception
   class NotDefined < self; end
   class FormattedNotFound < self; end
   class NotImplemented < self; end
+  class InvalidInput < self
+    attr_reader :value
+    def initialize(value)
+      @value = value
+      super
+    end
+
+    def message
+      "invalid input class #{value.class}"
+    end
+  end
 end
 

data/lib/danica/expressable.rb

@@ -2,26 +2,24 @@ module Danica
   module Expressable extend ::ActiveSupport::Concern
     include VariablesHolder
 
-    included do
-      class << self
-        def built_with(block_name)
-          self.send(:delegate, :to, :to_f, to: block_name)
+    class_methods do
+      def built_with(block_name)
+        self.delegate :to, :to_f, to: block_name
 
-          self.send(:define_singleton_method, :build) do |*vars, &block|
-            Class.new(self) do
-              variables(*vars)
+        self.define_singleton_method(:build) do |*vars, &block|
+          Class.new(self) do
+            variables(*vars)
 
-              private
+            private
 
-              module_eval("define_method :#{block_name} do
+            module_eval("define_method :#{block_name} do
                 @#{block_name} ||= instance_eval(&block) if block
               end")
-            end
           end
+        end
 
-          self.send(:define_singleton_method, :create) do |*vars, &block|
-            build(*vars, &block).new
-          end
+        self.define_singleton_method(:create) do |*vars, &block|
+          build(*vars, &block).new
         end
       end
     end

data/lib/danica/formatted.rb

@@ -17,14 +17,18 @@ class Danica::Formatted
            other.format == format
   end
 
+  def repack(object)
+    self.class.new(
+      object,
+      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
-    )
+    repack(value)
   end
 end

data/lib/danica/operator/addition.rb

@@ -2,10 +2,6 @@ module Danica
   class Operator::Addition < Operator::Chained
     default_value :priority, 1
 
-    def +(other)
-      repack(other)
-    end
-
     private
 
     default_value :symbol, :+

data/lib/danica/operator/chained.rb

@@ -45,11 +45,6 @@ module Danica
         end
       end
 
-      def repack(other)
-        other_variables = other.is_a?(self.class) ? other.variables : [ other ]
-        self.class.new(variables + other_variables)
-      end
-
       def chain(numbers)
         numbers.inject do |a,b|
           chain_operation(a,b)

data/lib/danica/operator/division.rb

@@ -1,7 +1,7 @@
 module Danica
   class Operator::Division < Operator
     variables :numerator, :denominator
-    default_value :priority, 2
+    default_value :priority, 3
     default_value :is_grouped?, true
 
     def to_f

data/lib/danica/operator/multiplication.rb

@@ -1,10 +1,6 @@
 module Danica
   class Operator::Multiplication < Operator::Chained
-    default_value :priority, 2
-
-    def *(other)
-      repack(other)
-    end
+    default_value :priority, 3
 
     private
 

data/lib/danica/operator.rb

@@ -3,7 +3,7 @@ module Danica
     include VariablesHolder
     include BaseOperations
 
-    default_value :priority, 3
+    default_value :priority, 4
     default_value :is_grouped?, false
 
     def ==(other)

data/lib/danica/variables_holder.rb

@@ -13,32 +13,32 @@ module Danica
 
     included do
       default_value :variable_holder?,  true
+    end
 
-      class << self
-        def variables(*names)
-          VariablesBuilder.new(names, self).build
-        end
+    class_methods do
+      def variables(*names)
+        VariablesBuilder.new(names, self).build
+      end
 
-        def variable_alias(origin, destiny)
-          AliasBuilder.new(origin, destiny, self).build
-        end
+      def variable_alias(origin, destiny)
+        AliasBuilder.new(origin, destiny, self).build
+      end
 
-        def variables_names
-          variables_hash.keys
-        end
+      def variables_names
+        variables_hash.keys
+      end
 
-        def variables_hash
-          @variables_hash ||= superclass_variables_hash.dup
-        end
+      def variables_hash
+        @variables_hash ||= superclass_variables_hash.dup
+      end
 
-        def reset_variables
-          @superclass_variables_hash = {}
-          @variables_hash = nil
-        end
+      def reset_variables
+        @superclass_variables_hash = {}
+        @variables_hash = nil
+      end
 
-        def superclass_variables_hash
-          @superclass_variables_hash ||= (superclass.try(:variables_hash) || {})
-        end
+      def superclass_variables_hash
+        @superclass_variables_hash ||= (superclass.try(:variables_hash) || {})
       end
     end
 

data/lib/danica/version.rb

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

data/lib/danica/wrapper/container.rb

@@ -4,7 +4,7 @@ module Danica
     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

data/lib/danica/wrapper.rb

@@ -6,6 +6,8 @@ module Danica
 
     def self.wrap_value(value)
       case value
+      when Formatted
+        value.content
       when Numeric
         wrap_numeric(value)
       when Hash
@@ -13,6 +15,7 @@ module Danica
       when String, Symbol, NilClass
         Variable.new(name: value)
       else
+        raise Exception::InvalidInput, value unless value.is_a?(Danica::Common)
         value
       end
     end

data/lib/danica.rb

@@ -20,6 +20,7 @@ module Danica
 
   class << self
     delegate :build, to: :builder
+    attr_accessor :debug
 
     def builder
       @builder ||= Builder.new

data/spec/integration/formatted_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe 'integration of formatted objects' do
+  let(:variable) { Danica.build(:v) { v } }
+  subject do
+    variable.tex
+  end
+
+  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(Danica::Formatted)
+      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(Danica::Formatted)
+      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(Danica::Formatted)
+      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(Danica::Formatted)
+      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(Danica::Formatted)
+    end
+
+    it 'knows how to convert it to string' do
+      expect(result.to_s).to eq('x \cdot \left(-v\right)')
+    end
+  end
+end

data/spec/integration/multiplication_spec.rb

@@ -41,4 +41,63 @@ describe 'integration of multiplication' do
       end
     end
   end
+
+  describe 'when calling * operator' do
+    subject do
+      Danica::Operator::Multiplication.new(:x, :y)
+    end
+    let(:variable) { Danica::Wrapper::Variable.new(:v) }
+    let(:result) { subject * variable }
+
+    it do
+      expect(result).to be_a(Danica::Operator::Multiplication)
+    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(Danica::Operator::Multiplication)
+      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(Danica::Operator::Multiplication)
+    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/negative_spec.rb

@@ -19,6 +19,36 @@ describe 'integration of negative' do
         expect(subject.to_tex).to eq('-\left(1 + 2 + 3\right)')
       end
     end
+
+    describe 'when it is the result of an expression' do
+      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 }
+      subject do
+        x - negative_parcel
+      end
+
+      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
 

data/spec/integration/readme/formatting_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe 'formatting' do
+  subject do
+    value = 1 / 3.0
+    Danica.build(:x) do
+      x + value
+    end
+  end
+
+  describe '#to_tex' do
+    it 'formats the output' do
+      expect(subject.to_tex(decimals: 3)).to eq('x + 0.333')
+    end
+  end
+end
+
+describe Danica::Formatted do
+  let(:expression) do
+    value = 1 / 3.0
+    Danica.build(:x) do
+      x + value
+    end
+  end
+  subject do
+    expression.tex(decimals: 3)
+  end
+
+  describe '#to_tex' do
+    it 'formats the output' do
+      expect(subject.to_s).to eq('x + 0.333')
+    end
+  end
+end

data/spec/lib/danica/common_spec.rb

@@ -123,4 +123,14 @@ describe Danica::Common do
       end
     end
   end
+
+  describe '#formatted' do
+    it do
+      expect(subject.formatted(:gnu)).to be_a(Danica::Formatted)
+    end
+
+    it 'knows how to return to build the string string' do
+      expect(subject.formatted(:gnu, decimals: 3).to_s).to eq('gnu {:decimals=>3}')
+    end
+  end
 end

data/spec/lib/danica/formatted_spec.rb

@@ -1,5 +1,29 @@
 require 'spec_helper'
 
+
+shared_examples 'a formatted result' do |output|
+  it do
+    expect(result).to be_a(described_class)
+  end
+
+  it 'keeps being able to parse format' do
+    expect(result.to_s).to eq(output)
+  end
+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) }
+      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
   let(:content) { Danica::Wrapper::Variable.new(latex: :V, gnuplot: :v) }
   let(:format) { :tex }
@@ -41,25 +65,13 @@ describe Danica::Formatted do
   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
+    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

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

@@ -13,19 +13,15 @@ describe Danica::Operator::Addition do
 
   it_behaves_like 'an object with basic operation', ignore: %i(+ -)
   it_behaves_like 'an object with + operation' do
-    let(:subject_included) { 10 }
-
     context 'when other is also a addition' do
       let(:other) { described_class.new(200, 5) }
 
       it 'includes the addition parcels' do
-        expect(result).to include(200)
+        expect(result.to_gnu).to eq('10 + 2 + 200 + 5')
       end
     end
   end
-  it_behaves_like 'an object with - operation' do
-    let(:subject_included) { 10 }
-  end
+  it_behaves_like 'an object with - operation'
 
   it_behaves_like 'a operator that joins many variables with same operation', {
     calculated: 10,

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

@@ -12,13 +12,11 @@ describe Danica::Operator::Multiplication do
   it_behaves_like 'an object that respond to basic_methods'
 
   it_behaves_like 'an object with * operation' do
-    let(:subject_included) { 4 }
-
-    context 'when other is also a addition' do
+    context 'when other is also a multiplication' do
       let(:other) { described_class.new(200, 5) }
 
-      it 'includes the addition parcels' do
-        expect(result).to include(200)
+      it 'includes the addition parcels in the result' do
+        expect(result.to_gnu).to eq('2 * 4 * 200 * 5')
       end
     end
   end

data/spec/lib/danica/wrapper_spec.rb

@@ -32,17 +32,21 @@ describe Danica::Wrapper do
       x: Danica::Wrapper::Variable,
       'x' => Danica::Wrapper::Variable,
       10 => Danica::Wrapper::Number,
+      10.5 => Danica::Wrapper::Number,
       -10 => Danica::Wrapper::Negative,
-      { name: :x } => Danica::Wrapper::Variable
+      { name: :x } => Danica::Wrapper::Variable,
+      { value: 10, latex: :x, gnuplot: :X } => Danica::Wrapper::Constant,
+      Danica::Wrapper::Variable.new(:x).tex => Danica::Wrapper::Variable,
+      Danica.build(:x) { x } => Danica::Expression
     }
 
-    context 'when value is a Hash' do
-      context 'but it is a constant' do
-        let(:value) { { value: 10, latex: :x, gnuplot: :X } }
+    context 'when value is non accepted' do
+      let(:value) { Object.new }
 
-        it do
-          expect(subject.wrapped_value.content).to be_a(Danica::Wrapper::Constant)
-        end
+      it do
+        expect do
+          subject.wrapped_value.content
+        end.to raise_error(Danica::Exception::InvalidInput)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: danica
 version: !ruby/object:Gem::Version
-  version: 2.7.1
+  version: 2.7.2
 platform: ruby
 authors:
 - Darthjee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-18 00:00:00.000000000 Z
+date: 2018-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -143,6 +143,7 @@ files:
 - lib/danica/builder.rb
 - lib/danica/common.rb
 - lib/danica/dsl.rb
+- lib/danica/dsl/builder.rb
 - lib/danica/equation.rb
 - lib/danica/equation/builder.rb
 - lib/danica/exception.rb
@@ -178,6 +179,7 @@ files:
 - lib/danica/wrapper/plus_minus.rb
 - lib/danica/wrapper/variable.rb
 - spec/integration/addition_spec.rb
+- spec/integration/formatted_spec.rb
 - spec/integration/multiplication_spec.rb
 - spec/integration/negative_spec.rb
 - spec/integration/plus_minus_spec.rb
@@ -186,6 +188,7 @@ files:
 - spec/integration/readme/danica_spec.rb
 - spec/integration/readme/equation_spec.rb
 - spec/integration/readme/expression_spec.rb
+- spec/integration/readme/formatting_spec.rb
 - spec/integration/readme/function_spec.rb
 - spec/integration/readme/number_spec.rb
 - spec/integration/readme/operator_spec.rb
@@ -262,6 +265,7 @@ specification_version: 4
 summary: Danica
 test_files:
 - spec/integration/addition_spec.rb
+- spec/integration/formatted_spec.rb
 - spec/integration/multiplication_spec.rb
 - spec/integration/negative_spec.rb
 - spec/integration/plus_minus_spec.rb
@@ -270,6 +274,7 @@ test_files:
 - spec/integration/readme/danica_spec.rb
 - spec/integration/readme/equation_spec.rb
 - spec/integration/readme/expression_spec.rb
+- spec/integration/readme/formatting_spec.rb
 - spec/integration/readme/function_spec.rb
 - spec/integration/readme/number_spec.rb
 - spec/integration/readme/operator_spec.rb