danica 2.4.4 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7e650cc12cd4ccaaf7eaebd6f8084ae46211f0cf
-  data.tar.gz: 7b9cef3c43db7851160e95f6a2700dfde13f5a28
+  metadata.gz: dbc5e0d585c75c30257524380ed56a556daa08c5
+  data.tar.gz: 429e5c4ed8845329ebd79f9bfa9353b809e1e763
 SHA512:
-  metadata.gz: 0acaff19e60a377126d74cfa90441098329f19603b7467e208f672e1ba7a95242beed67125028cd8c1979f5fb9b4443b877aa27ec24bf8e421f6f44970f983b3
-  data.tar.gz: 3d5be06b0da8ea1569f17354b711ce328f0577b169af1a8a191f6de883d6cbb2b3aab38fe3c2f03511f0f1aa5f72d819146d3bac3107e32364d9e6030d0ace14
+  metadata.gz: 4fb11c37df1b65c3b960d5d9cf1fecd828e445171e950b16c9f532190e490d37b733923be0d3fc809e54eb1d8cd27fcf9f05b02af60eb4772d13280ffbf825f0
+  data.tar.gz: e737d1f7f965f29bc7d95a44744385400f12c6b863544a52ea06f851cb137b0a0a33ce90d669c5d2effe79e575d4eeb92a1cff49dbd2fc2ebacd6796542e35b3

data/lib/danica.rb

@@ -5,8 +5,11 @@ module Danica
   autoload :BaseOperations,   'danica/base_operations'
   autoload :VariablesHolder,  'danica/variables_holder'
   autoload :Common,           'danica/common'
+  autoload :Expression,       'danica/expression'
+  autoload :Equation,         'danica/equation'
   autoload :Function,         'danica/function'
   autoload :Exception,        'danica/exception'
+  autoload :Expressable,      'danica/expressable'
 
   autoload :DSL,              'danica/dsl'
   autoload :Wrapper,          'danica/wrapper'

data/lib/danica/equation.rb

@@ -0,0 +1,17 @@
+module Danica
+  class Equation
+    include Common
+    include VariablesHolder
+
+    variables :left, :right
+
+    def initialize(*args)
+      self.variables = args.flatten
+    end
+
+    def to(format)
+      "#{left.to(format)} = #{right.to(format)}"
+    end
+  end
+end
+

data/lib/danica/expressable.rb

@@ -0,0 +1,39 @@
+module Danica
+  module Expressable extend ::ActiveSupport::Concern
+    included do
+      include VariablesHolder
+
+      class << self
+        def built_with(block_name)
+          self.send(:delegate, :to_f, to: block_name)
+
+          self.send(:define_singleton_method, :build) do |*vars, &block|
+            Class.new(self) do
+              variables(*vars)
+
+              private
+
+              module_eval("define_method :#{block_name} do
+                @#{block_name} ||= instance_eval(&block) if block
+              end")
+            end
+          end
+
+          self.send(:define_singleton_method, :create) do |*vars, &block|
+            build(*vars, &block).new
+          end
+        end
+      end
+    end
+
+    def initialize(*args)
+      options = args.extract_options!
+
+      attributes = { variables: args.flatten }.merge(options)
+
+      attributes.each do |key, value|
+        self.public_send("#{key}=", value)
+      end
+    end
+  end
+end

data/lib/danica/expression.rb

@@ -0,0 +1,14 @@
+module Danica
+  class Expression
+    include Common
+    include DSL
+    include BaseOperations
+    include Expressable
+
+    autoload :Gauss,    'danica/expression/gauss'
+
+    delegate :to, :is_grouped?, :priority, to: :expression_block
+
+    built_with(:expression_block)
+  end
+end

data/lib/danica/{function → expression}/gauss.rb

@@ -1,5 +1,5 @@
 module Danica
-  class Function::Gauss < Function.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', gnu: :u }, variance_root: { latex: '\sigma', gnu: :v }) { num(1) / denominator * exponential(exp) }
 
     private
 

data/lib/danica/function.rb

@@ -1,80 +1,32 @@
 module Danica
-  class Function
+  class Function < Equation
     include Common
-    include VariablesHolder
     include DSL
+    include Expressable
 
-    autoload :Gauss,    'danica/function/gauss'
     autoload :Name,    'danica/function/name'
-
     attr_accessor :name
 
-    default_value :priority, 3
-    default_value :is_grouped?, false
-    delegate :to_f, :to, to: :function_block
-
-    def self.build(*vars, &block)
-      Class.new(self) do
-        variables(*vars)
-
-        private
-
-        define_method :function_block do
-          @function_block ||= instance_eval(&block) if block
-        end
-      end
-    end
-
-    def self.create(*vars, &block)
-      build(*vars, &block).new
-    end
-
-    def initialize(*args)
-      options = args.extract_options!
-
-      attributes = { variables: args.flatten }.merge(options)
-
-      attributes.each do |key, value|
-        self.public_send("#{key}=", value)
-      end
-    end
-
-    def calculate(*args)
-      vars_map = args.extract_options!
-      vars_map = variables_value_hash.merge(vars_map)
-      vars_map.each do |k, v|
-        unless v && (v.is_a?(Integer) || v.valued?)
-          vars_map[k] = args.shift
-        end
-      end
-
-      self.class.new(vars_map).to_f
-    end
-
-    def describe(format)
-      "#{name.to(format)} = #{to(format)}"
-    end
+    reset_variables
 
-    def describe_tex
-      describe(:tex)
-    end
-
-    def describe_gnu
-      describe(:gnu)
-    end
+    built_with(:function_block)
 
     def name
-      @name_object ||= Name.new(name: @name, variables: containers)
+      containers_hash[:left] ||= Danica::Wrapper::Container.new Name.new(name: @name, variables: containers)
     end
 
-    private
+    def expression
+      @expression ||= Expression.build(:x) do
+        x
+      end.new(function_block)
+    end
 
-    def description_variables(format)
-      non_constant_variables.map { |v| v.to(format) }.join(', ')
+    def left
+      name
     end
 
-    def non_constant_variables
-      variables.reject(&:constant?)
+    def right
+      expression
     end
   end
 end

data/lib/danica/operator.rb

@@ -8,7 +8,9 @@ module Danica
     default_value :is_grouped?, false
 
     def initialize(*args)
-      self.variables = args.flatten
+      args = args.flatten
+      args = args.first if (args.length == 1) && args.first.is_a?(Hash) && args.first.keys == self.class.variables_names
+      self.variables = args
     end
 
     def ==(other)

data/lib/danica/variables_holder.rb

@@ -1,6 +1,8 @@
 module Danica
   module VariablesHolder extend ::ActiveSupport::Concern
-    require 'danica/variables_holder/variables_builder'
+    autoload :VariablesBuilder, 'danica/variables_holder/variables_builder'
+    autoload :AliasBuilder,     'danica/variables_holder/alias_builder'
+    autoload :Calculator,       'danica/variables_holder/calculator'
 
     included do
       class << self
@@ -8,12 +10,25 @@ module Danica
           VariablesBuilder.new(names, self).build
         end
 
+        def variable_alias(origin, destiny)
+          AliasBuilder.new(origin, destiny, self).build
+        end
+
         def variables_names
           variables_hash.keys
         end
 
         def variables_hash
-          @variables_hash ||= (superclass.try(:variables_hash) || {}).dup
+          @variables_hash ||= superclass_variables_hash.dup
+        end
+
+        def reset_variables
+          @superclass_variables_hash = {}
+          @variables_hash = nil
+        end
+
+        def superclass_variables_hash
+          @superclass_variables_hash ||= (superclass.try(:variables_hash) || {})
         end
       end
     end
@@ -26,6 +41,20 @@ module Danica
       end
     end
 
+    def extract_variables
+      variables.select do |var|
+        var.is_a?(VariablesHolder)
+      end.inject({}) do |hash, container|
+        hash.merge!(container.content.extract_variables)
+      end.tap do |hash|
+        containers_hash.select do |_, container|
+          container.content.is_a?(Wrapper::Variable)
+        end.each do |key, container|
+          hash[(container.content.name || key).to_sym] = container
+        end
+      end
+    end
+
     def variables
       containers.map(&:content)
     end
@@ -49,5 +78,9 @@ module Danica
         var.try(:value)
       end.as_hash(self.class.variables_names)
     end
+
+    def calculate(*args)
+      Calculator.new(self, *args).calculate
+    end
   end
 end

data/lib/danica/variables_holder/alias_builder.rb

@@ -0,0 +1,20 @@
+module Danica::VariablesHolder
+  class AliasBuilder
+
+    attr_reader :clazz, :origin, :destiny
+
+    def initialize(origin, destiny, clazz)
+      @origin = origin
+      @destiny = destiny
+      @clazz = clazz
+    end
+
+    def build
+      clazz.variables_hash.change_keys! { |k| k == origin ? destiny : k }
+      VariablesBuilder.new([ destiny ], clazz).build
+      clazz.send(:alias_method, "#{origin}=", "#{destiny}=")
+      clazz.send(:alias_method, origin, destiny)
+    end  
+  end
+end
+

data/lib/danica/variables_holder/calculator.rb

@@ -0,0 +1,45 @@
+module Danica
+  module VariablesHolder
+    class Calculator
+      attr_accessor :object, :args
+
+      def initialize(object, *args)
+        @object = object
+        @args = args
+      end
+
+      def calculate
+        raise Exception::NotDefined unless all_valued?
+
+        clazz.new(vars_map).to_f
+      end
+
+      private
+
+      def vars_map
+        @vars_map ||= variables_value_hash.tap do |map|
+          vars = args.dup
+          map.merge! vars.extract_options!
+          vars_map = vars.as_hash(map.keys).select { |_, v| valued?(v) }
+          map.merge! vars_map
+        end
+      end
+
+      def all_valued?
+        vars_map.values.all? { |v| valued?(v) }
+      end
+
+      def valued?(value)
+        value.is_a?(Integer) || value.try(:valued?)
+      end
+
+      def variables_value_hash
+        @variables_value_hash ||= object.variables_value_hash.dup
+      end
+
+      def clazz
+        @clazz ||= object.class
+      end
+    end
+  end
+end

data/lib/danica/variables_holder/variables_builder.rb

@@ -30,13 +30,7 @@ module Danica::VariablesHolder
 
     def add_setter(name)
       instance.send(:define_method, "#{name}=") do |value|
-        if(containers_hash[name.to_sym].try(:container?))
-          containers_hash[name.to_sym].content = wrap_value(value)
-        else
-          value = wrap_value(value)
-          value = Danica::Wrapper::Container.new value unless value.container?
-          containers_hash[name.to_sym] = value
-        end
+        containers_hash[name.to_sym].content = wrap_value(value)
       end
     end
 

data/lib/danica/version.rb

@@ -1,3 +1,3 @@
 module Danica
-  VERSION = '2.4.4'
+  VERSION = '2.5.0'
 end

data/lib/danica/wrapper/container.rb

@@ -4,7 +4,8 @@ module Danica
     attr_accessor :content
 
     delegate :to_f, :contentd?, :to, :to_tex, :to_gnu, :priority, :grouped?,
-             :signaled?, :constant?, :valued?, :*, :+, :-, :/, :**, to: :content
+             :signaled?, :constant?, :valued?, :*, :+, :-, :/, :**,
+             :variables, to: :content
 
     default_value :container?, true
 

data/spec/lib/danica/equation_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Danica::Equation do
+  let(:left) do
+    Danica::Expression.create(:y) { y }
+  end
+  let(:right) do
+    Danica::Expression.create(:x) { x ** 2 }
+  end
+
+  subject { described_class.new(left, right) }
+
+  describe '#to_f' do
+    it do
+      expect { subject.to_f }.to raise_error(Danica::Exception::NotImplemented)
+    end
+  end
+
+  describe '#to_tex' do
+    it 'joins the expressions in a equation' do
+      expect(subject.to_tex).to eq('y = x^{2}')
+    end
+  end
+
+  describe '#to_gnu' do
+    it 'joins the expressions in a equation' do
+      expect(subject.to_gnu).to eq('y = x**(2)')
+    end
+  end
+end

data/spec/lib/danica/expressable_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+class Danica::Expressable::Dummy
+  include Danica::Expressable
+
+  built_with :the_block
+end
+
+describe Danica::Expressable do
+  let(:clazz) { described_class::Dummy }
+
+  describe '.build' do
+    it 'responds to build' do
+      expect(clazz).to respond_to(:build)
+    end
+
+    it 'returns a child class object' do
+      expect(clazz.build(:x) do
+        x
+      end.superclass).to be(clazz)
+    end
+  end
+
+  describe '.create' do
+    it 'responds to create' do
+      expect(clazz).to respond_to(:create)
+    end
+
+    it do
+      expect(clazz.create(:x) do
+        x
+      end).to be_a(clazz)
+    end
+  end
+end