danica 2.7.1 → 2.7.6

data/lib/danica.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'darthjee/core_ext'
 
 module Danica
@@ -20,10 +22,10 @@ module Danica
 
   class << self
     delegate :build, to: :builder
+    attr_accessor :debug
 
     def builder
       @builder ||= Builder.new
     end
   end
 end
-

data/lib/danica/base_operations.rb

@@ -1,29 +1,37 @@
+# frozen_string_literal: true
+
 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/builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Danica
   class Builder
     include DSL

data/lib/danica/common.rb

@@ -1,26 +1,29 @@
+# frozen_string_literal: true
+
 module Danica
-  module Common extend ::ActiveSupport::Concern
+  module Common
+    extend ::ActiveSupport::Concern
     included do
       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
@@ -42,16 +45,20 @@ module Danica
       when :f
         to_f
       else
-        raise Exception::FormattedNotFound.new
+        raise Exception::FormattedNotFound
       end
     end
 
     def tex(**options)
-      Formatted.new(self, :tex, options)
+      formatted(format: :tex, **options)
     end
 
     def gnu(**options)
-      Formatted.new(self, :gnu, options)
+      formatted(format: :gnu, **options)
+    end
+
+    def formatted(*args)
+      Formatted.new(self, *args)
     end
 
     def valued?
@@ -68,6 +75,7 @@ module Danica
 
     def wrap_as_group(value)
       return value if is_grouped? || value.priority >= priority
+
       group(value)
     end
   end

data/lib/danica/dsl.rb

@@ -1,18 +1,24 @@
+# frozen_string_literal: true
+
 module Danica
   module DSL
+    autoload :Builder, 'danica/dsl/builder'
+
     class << self
-      def register_operator(method, clazz=nil)
+      def register_operator(method, clazz = nil)
         register(method, clazz, 'Danica::Operator')
       end
 
-      def register_wrapper(method, clazz=nil)
+      def register_wrapper(method, clazz = nil)
         register(method, clazz, 'Danica::Wrapper')
       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
+      def register(method, clazz = nil, base = nil)
+        Builder.new(method, clazz, base).build
+      end
+
+      def register_class(method, clazz)
+        define_method(method) do |*args|
           clazz.new(*args)
         end
       end
@@ -35,14 +41,14 @@ module Danica
     end
   end
 
-  %i(
+  %i[
     addition multiplication division sin cos power
     squared_root exponential
-  ).each do |method|
+  ].each do |method|
     DSL.register_operator(method)
   end
 
-  %i(number group negative plus_minus variable constant).each do |method|
+  %i[number group negative plus_minus variable constant].each do |method|
     DSL.register_wrapper(method)
   end
 

data/lib/danica/dsl/builder.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+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/equation.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module Danica
   class Equation
     include VariablesHolder
-  
+
     autoload :Builder, 'danica/equation/builder'
 
     class << self
@@ -19,5 +21,3 @@ module Danica
     end
   end
 end
-
-

data/lib/danica/equation/builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Danica
   class Equation::Builder
     attr_reader :variables

data/lib/danica/exception.rb

@@ -1,6 +1,18 @@
-class Danica::Exception < ::Exception
+# frozen_string_literal: true
+
+class Danica::Exception < RuntimeError
   class NotDefined < self; end
   class FormattedNotFound < self; end
   class NotImplemented < self; end
-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

@@ -1,27 +1,31 @@
+# frozen_string_literal: true
+
 module Danica
-  module Expressable extend ::ActiveSupport::Concern
+  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)
+        delegate :to, :to_f, to: block_name
 
-          self.send(:define_singleton_method, :build) do |*vars, &block|
-            Class.new(self) do
-              variables(*vars)
+        define_singleton_method(:build) do |*vars, &block|
+          Class.new(self) do
+            variables(*vars)
 
-              private
+            private
 
-              module_eval("define_method :#{block_name} do
-                @#{block_name} ||= instance_eval(&block) if block
-              end")
+            module_eval do
+              define_method block_name do
+                instance_variable_get("@#{block_name}") ||
+                  block && instance_variable_set("@#{block_name}", instance_eval(&block))
+              end
             end
           end
+        end
 
-          self.send(:define_singleton_method, :create) do |*vars, &block|
-            build(*vars, &block).new
-          end
+        define_singleton_method(:create) do |*vars, &block|
+          build(*vars, &block).new
         end
       end
     end
@@ -32,7 +36,7 @@ module Danica
       attributes = { variables: args.flatten }.merge(options)
 
       attributes.each do |key, value|
-        self.public_send("#{key}=", value)
+        public_send("#{key}=", value)
       end
     end
   end

data/lib/danica/expression.rb

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

data/lib/danica/expression/gauss.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module Danica
   class Expression::Gauss < Expression.build(:x, average: { latex: '\mu', gnuplot: :u }, variance_root: { latex: '\sigma', gnuplot: :v }) { num(1) / denominator * exponential(exp) }
-
     private
 
     def denominator
@@ -9,14 +10,13 @@ module Danica
 
     def exp
       - (
-          ((x - average) ** 2) /
+          ((x - average)**2) /
           (num(2) * variance)
-      )
+        )
     end
 
     def variance
-      @variance ||= variance_root ** 2
+      @variance ||= variance_root**2
     end
   end
 end
-

data/lib/danica/formatted.rb

@@ -1,20 +1,45 @@
+# frozen_string_literal: true
+
 class Danica::Formatted
-  attr_reader :content, :format, :decimals
+  attr_reader :content, :options
 
-  def initialize(content, format, decimals: nil)
+  def initialize(content, **options)
     @content = content
-    @format = format
-    @decimals = decimals
+    @options = options
   end
 
   def to_s
-    content.to(format, decimals: decimals)
+    content.to(format, options)
   end
 
   def ==(other)
     return false unless other.class == self.class
-    return other.content == content &&
-           other.format == format
+
+    other.content == content &&
+      other.format == format
+  end
+
+  def format
+    options[:format]
+  end
+
+  def repack(object)
+    self.class.new(
+      object,
+      options
+    )
+  end
+
+  def to_tex(**opts)
+    to(:tex, **opts)
+  end
+
+  def to_gnu(**opts)
+    to(:gnu, **opts)
+  end
+
+  def to(format, **opts)
+    content.to(format, options.merge(opts))
   end
 
   private
@@ -22,9 +47,7 @@ class Danica::Formatted
   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