hesabu 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 569ad0bbcbed74d83d57ab12ea67b39377400394a7ee7821e37bb3d157f69232
-  data.tar.gz: 3984eec0e0e7e1c193a5a2cd7cab98b84a1da9f02c93cd41ebb5e1dfc3a03ab8
+  metadata.gz: 431f06d479e890cf49a1cf8fb1f9a166b66a88aee4b6200be1c540996fecf4fd
+  data.tar.gz: e6d8a83f61a8e986658b6c574c0b51c5365787819f0fb2bff9331b7cdf3ba07b
 SHA512:
-  metadata.gz: 58be8b83b70bbeaaf2d4c49b2d9aaaa315614a895bdd1b812d27bf029b6f5dfb48e98d3af4f6c2aae62f9a8890bfb1256807a636db38e3f699c549c2ef25e118
-  data.tar.gz: ff042a9247f785f8d2ef40e800a85bd1330ded53e4ee0fc2a1bf7428ece4e2e532a364869596787af6016078c9b634c028d660a518e324f154e6e05b54dea306
+  metadata.gz: c22ea9e78df743ee0ea74d8fb3fc22291fe12fdd1cd7235d94e608c72627c665d9982c2e803eede67320cf42e453741682313d8a4aa87f59a449638d37187e8d
+  data.tar.gz: 96761de748fed74701bc6aa799ec99ff309c77da03521111cd0a4960874552d7018bd5998c883cb2a41a6d826d2ec8fa3415b0ad70ff419c41c93f373370ddcd

data/Gemfile.lock

@@ -1,8 +1,7 @@
 PATH
   remote: .
   specs:
-    hesabu (0.1.4)
-      parslet
+    hesabu (0.1.5)
 
 GEM
   remote: https://rubygems.org/
@@ -34,7 +33,6 @@ GEM
     parallel (1.12.1)
     parser (2.5.1.0)
       ast (~> 2.4.0)
-    parslet (1.8.2)
     path_expander (1.0.2)
     powerpack (0.1.1)
     pronto (0.9.5)

data/README.md

@@ -25,13 +25,7 @@ The expressions can be more complex (excel like), see the supported functions [h
 
 Currently the solver is case sensitive (except function names)
 
-Nb: Hesabu is swahili word for arithemtic.
-
-## Technical background
-
-* https://tomassetti.me/guide-parsing-algorithms-terminology/
-* https://github.com/PhilippeSigaud/Pegged/wiki/PEG-Basics
-* https://github.com/kschiess/parslet
+Nb: Hesabu is swahili word for arithmetic.
 
 ## Alternatives
 
@@ -62,10 +56,7 @@ chmod 0600 ~/.gem/credentials
 
 
 ```
-gem bump
-gem build hesabu.gemspec
-gem push hesabu-x.x.x.gem
-
+gem bump --tag --release
 ```
 
 

data/hesabu.gemspec

@@ -23,8 +23,6 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "parslet"
-
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"

data/lib/hesabu/equation_cleaner.rb

@@ -0,0 +1,11 @@
+
+module Hesabu
+  class EquationCleaner
+    def self.clean(eq)
+      clean_eq = eq.gsub(" AND ", " && ")
+      clean_eq.split(/(<=|>=|!=|==|=|\*|\s)/m)
+              .map { |a| a == "=" ? "==" : a }
+              .join("")
+    end
+  end
+end

data/lib/hesabu/errors.rb

@@ -1,17 +1,15 @@
 
 module Hesabu
   class Error < StandardError
+    attr_accessor :errors
+    def iniatialize(message)
+      super(message)
+      @errors = errors
+    end
   end
   class ArgumentError < Error
-  end
-  class ParseError < Error
-  end
-  class CalculationError < Error
-  end
-  class DivideByZeroError < Error
-  end
-  class CyclicError < Error
-  end
-  class UnboundVariableError < Error
+    def iniatialize(message)
+      super(message)
+    end
   end
 end

data/lib/hesabu/solver.rb

@@ -1,127 +1,49 @@
-module Hesabu
-  class Solver
-    include TSort
 
-    Equation = Struct.new(:name, :evaluable, :dependencies, :raw_expression)
-    EMPTY_DEPENDENCIES = [].freeze
-    FakeEvaluable = Struct.new(:eval)
 
+module Hesabu
+  class Solver
     def initialize
-      @parser = ::Hesabu::Parser.new
-      @interpreter = ::Hesabu::Interpreter.new
       @equations = {}
-      @bindings = {}
     end
 
     def add(name, raw_expression)
       if raw_expression.nil? || name.nil?
         raise Hesabu::ArgumentError, "name or expression can't be nil : '#{name}', '#{raw_expression}'"
       end
-
-      if ::Hesabu::Types.as_numeric(raw_expression)
-        add_numeric(name, raw_expression)
-      else
-        add_equation(name, raw_expression)
-      end
+      @equations[name] = EquationCleaner.clean(raw_expression.to_s)
     end
 
     def solve!
-      solving_order.each do |name|
-        evaluate_equation(@equations[name])
+      result = nil
+      IO.popen(HESABUCLI, mode = "r+") do |io|
+        io.write @equations.to_json
+        io.close_write # let the process know you've given it all the data
+        result = io.read
       end
-      solution = @bindings.dup
-      @bindings.clear
-      to_numerics(solution)
-    rescue StandardError => e
-      log_and_raise(e)
-    end
+      solution = JSON.parse(result)
+      exit_status = $CHILD_STATUS.exitstatus
 
-    def solving_order
-      tsort
-    rescue TSort::Cyclic => e
-      raise Hesabu::CyclicError, "There's a cycle between the variables : " + e.message[25..-1]
-    end
-
-    def tsort_each_node(&block)
-      @equations.each_key(&block)
-    end
-
-    def tsort_each_child(node, &block)
-      equation = @equations[node]
-      raise UnboundVariableError, unbound_message(node) unless equation
-      equation.dependencies.each(&block)
-    end
-
-    private
-
-    def to_numerics(solution)
-      solution.each_with_object({}) do |kv, hash|
-        hash[kv.first] = Hesabu::Types.as_numeric(kv.last) || kv.last
-      end
+      log_everything(exit_status, result) if ENV["HESABU_DEBUG"] || exit_status != 0
+      handle_error(solution) if exit_status != 0
+      solution
     end
 
-    def log_and_raise(e)
-      log_error(e)
-      raise e
-    end
-
-    def log_error(e)
-      log "Error during processing: #{$ERROR_INFO}"
-      log "Error : #{e.class} #{e.message}"
-      log "Backtrace:\n\t#{e.backtrace.join("\n\t")}"
-    end
-
-    def evaluate_equation(equation)
-      raise "not evaluable #{equation.evaluable} #{equation}" unless equation.evaluable.respond_to?(:eval, false)
-      begin
-        @bindings[equation.name] = equation.evaluable.eval
-      rescue StandardError => e
-        raise CalculationError, "Failed to evaluate #{equation.name} due to #{e.message} in formula #{equation.raw_expression}"
-      end
-    end
-
-    def log(message)
-      puts message
-    end
-
-    def add_numeric(name, raw_expression)
-      @equations[name] = Equation.new(
-        name,
-        FakeEvaluable.new(::Hesabu::Types.as_bigdecimal(raw_expression)),
-        EMPTY_DEPENDENCIES,
-        raw_expression
-      )
-    end
-
-    def add_equation(name, raw_expression)
-      expression = raw_expression.gsub(/\r\n?/, "")
-      ast_tree = begin
-        @parser.parse(expression)
-      rescue Parslet::ParseFailed => e
-        log(raw_expression)
-        log_error(e)
-        raise ParseError, "failed to parse #{name} := #{expression} : #{e.message}"
-      end
-      var_identifiers = Set.new
-      interpretation = @interpreter.apply(
-        ast_tree,
-        doc:             @bindings,
-        var_identifiers: var_identifiers
-      )
-      if ENV["HESABU_DEBUG"]
-        log expression
-        log JSON.pretty_generate(ast_tree)
-      end
-      @equations[name] = Equation.new(name, interpretation, var_identifiers, raw_expression)
-    end
+    def handle_error(solution)
+      puts
+      error = solution["errors"].first
+      message = "In equation #{error['source']} " + error["message"] + " #{error['source']} := #{error['expression']}"
 
-    def unbound_message(node)
-      ref = first_reference(node)
-      "Unbound variable : #{node} used by #{ref.name} (#{ref.raw_expression})"
+      err = Hesabu::Error.new(message)
+      err.errors = solution["errors"]
+      raise err
     end
 
-    def first_reference(variable_name)
-      @equations.values.select { |v| v.dependencies.include?(variable_name) }.take(1).first
+    def log_everything(exit_status, result)
+      puts ["**************",
+            "exit_status:#{exit_status}",
+            @equations.to_json,
+            "=> ",
+            result].join("\n")
     end
   end
 end

data/lib/hesabu/version.rb

@@ -1,3 +1,3 @@
 module Hesabu
-  VERSION = "0.1.5".freeze
+  VERSION = "0.1.6".freeze
 end

data/lib/hesabu.rb

@@ -1,17 +1,12 @@
 require "hesabu/version"
-require "parslet"
+
 require_relative "./hesabu/errors"
-require_relative "./hesabu/parser"
 require_relative "./hesabu/types/numeric"
-require_relative "./hesabu/types/float_lit"
-require_relative "./hesabu/types/fun_call"
-require_relative "./hesabu/types/indentifier_lit"
-require_relative "./hesabu/types/int_lit"
-require_relative "./hesabu/types/string_lit"
-require_relative "./hesabu/types/operation"
 
-require_relative "./hesabu/interpreter"
+require_relative "./hesabu/equation_cleaner"
 require_relative "./hesabu/solver"
 
 module Hesabu
+  HESABUCLI = File.expand_path("../bin/hesabucli", File.dirname(__FILE__))
+  puts "************** HESABU cli location : " + HESABUCLI
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: hesabu
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Stéphan Mestach
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-06 00:00:00.000000000 Z
+date: 2018-07-09 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: parslet
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -171,20 +157,14 @@ files:
 - Rakefile
 - bin/console
 - bin/fast
+- bin/hesabucli
 - bin/setup
 - hesabu.gemspec
 - lib/hesabu.rb
+- lib/hesabu/equation_cleaner.rb
 - lib/hesabu/errors.rb
-- lib/hesabu/interpreter.rb
-- lib/hesabu/parser.rb
 - lib/hesabu/solver.rb
-- lib/hesabu/types/float_lit.rb
-- lib/hesabu/types/fun_call.rb
-- lib/hesabu/types/indentifier_lit.rb
-- lib/hesabu/types/int_lit.rb
 - lib/hesabu/types/numeric.rb
-- lib/hesabu/types/operation.rb
-- lib/hesabu/types/string_lit.rb
 - lib/hesabu/version.rb
 homepage: https://github.com/BLSQ/hesabu
 licenses:

data/lib/hesabu/interpreter.rb

@@ -1,25 +0,0 @@
-module Hesabu
-  class Interpreter < Parslet::Transform
-    rule(plist: sequence(:arr)) { arr }
-    rule(plist: "()") { [] }
-    rule(l: simple(:left),
-         r: simple(:right),
-         o: simple(:op)) do
-      Hesabu::Types::Operation.new(left, op, right)
-    end
-    rule(identifier: simple(:id)) { id.to_s }
-    rule(variable: simple(:variable)) do |d|
-      d[:var_identifiers]&.add(d[:variable])
-      Hesabu::Types::IdentifierLit.new(d[:variable], d[:doc])
-    end
-    rule(fcall: { name: simple(:name), varlist: sequence(:vars) }) do
-      Hesabu::Types::FunCall.new(name, vars)
-    end
-    rule(str: subtree(:str)) do
-      Hesabu::Types::StringLit.new(str.map { |char| char.values.first.str }.join)
-    end
-
-    rule(integer: simple(:integer)) { Hesabu::Types::IntLit.new(integer) }
-    rule(float: simple(:float)) { Hesabu::Types::FloatLit.new(float) }
-  end
-end

data/lib/hesabu/parser.rb

@@ -1,75 +0,0 @@
-module Hesabu
-  class Parser < Parslet::Parser
-    def cts(atom_arg)
-      atom_arg >> space?
-    end
-
-    # simple things
-    rule(:lparen)             { str("(") >> space? }
-    rule(:rparen)             { str(")") >> space? }
-    rule(:comma)              { str(",") >> space? }
-    rule(:space)              { match["\s"] | match["\t"] | match["\n"] }
-    rule(:spaces)             { space.repeat }
-    rule(:space?)             { spaces.maybe }
-
-    rule(:nonquote)   { str("'").absnt? >> any }
-    rule(:quote)      { str("'") }
-    rule(:string)     { quote >> nonquote.as(:char).repeat(1).as(:str) >> quote >> space? }
-
-    rule(:identifier) do
-      cts((match["a-zA-Z"] >> match["a-zA-Z0-9_"].repeat).as(:identifier))
-    end
-
-    rule(:separator) { str(";") }
-
-    rule(:digit) { match["0-9"] }
-
-    rule(:integer) do
-      cts((str("-").maybe >> match["1-9"] >> digit.repeat).as(:integer) | str("0").as(:integer))
-    end
-
-    rule(:float) do
-      cts((str("-").maybe >> digit.repeat(1) >> str(".") >> digit.repeat(1)).as(:float)) |
-      cts((str(".") >> digit.repeat(1)).as(:float))
-    end
-
-    # arithmetic
-
-    rule(:expression)         { iexpression | variable | pexpression }
-    rule(:pexpression)        { lparen >> expression >> rparen }
-
-    rule(:variable)           { identifier.as(:variable) }
-    rule(:sum_op)             { match("[+-]") >> space? }
-    rule(:mul_op)             { match("[*/]") >> space? }
-    rule(:comparison_op)      do
-      (
-       str("<=") | str(">=") | str("==") |
-       str("!=") | str("<") | str("=") |
-       str(">") | str("AND")
-      ) >> space?
-    end
-
-    rule(:atom) { string | pexpression | float | integer | fcall.as(:fcall) | variable }
-
-    rule(:iexpression) do
-      infix_expression(atom,
-                       [mul_op, 3, :left],
-                       [sum_op, 2, :left],
-                       [comparison_op, 1, :left])
-    end
-
-    # lists
-    rule(:varlist)    { expression >> (comma >> expression).repeat }
-    rule(:pvarlist)   { (lparen >> varlist.repeat >> rparen).as(:plist) }
-
-    # functions
-    rule(:fcall)        { identifier.as(:name) >> pvarlist.as(:varlist) }
-
-    # root
-    rule(:command) do
-      iexpression | expression | atom
-    end
-    rule(:commands) { commands.repeat }
-    root :command
-  end
-end

data/lib/hesabu/types/float_lit.rb

@@ -1,9 +0,0 @@
-module Hesabu
-  module Types
-    FloatLit = Struct.new(:float) do
-      def eval
-        Hesabu::Types.as_bigdecimal(float)
-      end
-    end
-  end
-end

data/lib/hesabu/types/fun_call.rb

@@ -1,123 +0,0 @@
-module Hesabu
-  module Types
-    class Function
-      def divide(num, denum)
-        num / denum
-      end
-    end
-    class IfFunction < Function
-      def call(args)
-        raise "expected args #{name} : #{args}" unless args.size != 2
-        condition_expression = args[0]
-        condition = condition_expression.eval
-        condition ? args[1].eval : args[2].eval
-      end
-    end
-
-    class SumFunction < Function
-      def call(args)
-        values = args.map(&:eval)
-        values.reduce(0, :+)
-      end
-    end
-
-    class ScoreTableFunction < Function
-      def call(args)
-        values = args.map(&:eval)
-        target = values.shift
-        matching_rules = values.each_slice(3).find do |lower, greater, result|
-          greater.nil? || result.nil? ? true : lower <= target && target < greater
-        end
-        matching_rules.last
-      end
-    end
-
-    class AvgFunction < Function
-      def call(args)
-        values = args.map(&:eval)
-        values.inject(0.0) { |acc, elem| acc + elem } / values.size
-      end
-    end
-
-    class SafeDivFunction < Function
-      def call(args)
-        eval_denom = args[1].eval
-        if eval_denom == 0
-          0
-        else
-          eval_num = args[0].eval
-          eval_denom.zero? ? 0 : (eval_num / eval_denom)
-        end
-      end
-    end
-
-    class MinFunction
-      def call(args)
-        values = args.map(&:eval)
-        values.min
-      end
-    end
-
-    class MaxFunction
-      def call(args)
-        values = args.map(&:eval)
-        values.max
-      end
-    end
-
-    class RandbetweenFunction
-      def call(args)
-        values = args.map(&:eval)
-        rand(values.first..values.last)
-      end
-    end
-
-    class AbsFunction
-      def call(args)
-        raise "expected args #{self.class.name} : #{args}" if args.size != 1
-        args.first.eval.abs
-      end
-    end
-
-    class AccessFunction
-      def call(args)
-        values = args.map(&:eval)
-        array = values[0..-2]
-        index = values[-1]
-        array[index]
-      end
-    end
-
-    class RoundFunction
-      def call(args)
-        raise "expected args #{self.class.name} : #{args}" if args.size > 2 || args.empty?
-        values = args.map(&:eval)
-        decimals = args.size == 2 ? values[1] : 0
-        values.first.round(decimals)
-      end
-    end
-
-    FUNCTIONS = {
-      "if"          => IfFunction.new,
-      "sum"         => SumFunction.new,
-      "avg"         => AvgFunction.new,
-      "min"         => MinFunction.new,
-      "max"         => MaxFunction.new,
-      "safe_div"    => SafeDivFunction.new,
-      "randbetween" => RandbetweenFunction.new,
-      "score_table" => ScoreTableFunction.new,
-      "abs"         => AbsFunction.new,
-      "access"      => AccessFunction.new,
-      "round"       => RoundFunction.new
-    }.freeze
-
-    FunCall = Struct.new(:name, :args) do
-      def eval
-        function_name = name.strip.downcase
-        function = FUNCTIONS[function_name]
-        raise "unsupported function call  : #{function_name} only knows #{FUNCTIONS.keys.join(', ')}" unless function
-        function.call(args)
-      end
-    end
-  end
-end

data/lib/hesabu/types/indentifier_lit.rb

@@ -1,9 +0,0 @@
-module Hesabu
-  module Types
-    IdentifierLit = Struct.new(:var_identifier, :bindings) do
-      def eval
-        bindings[var_identifier] ||= 0
-      end
-    end
-  end
-end

data/lib/hesabu/types/int_lit.rb

@@ -1,9 +0,0 @@
-module Hesabu
-  module Types
-    IntLit = Struct.new(:int) do
-      def eval
-        ::Hesabu::Types.as_bigdecimal(int)
-      end
-    end
-  end
-end

data/lib/hesabu/types/operation.rb

@@ -1,42 +0,0 @@
-module Hesabu
-  module Types
-    Operation = Struct.new(:left, :operator, :right) do
-      def eval
-        op = operator.str.strip
-        result(op, left.eval, right.eval)
-      end
-
-      private
-
-      def result(op, leftval, rightval)
-        case op
-        when "+"
-          leftval + rightval
-        when  "-"
-          leftval - rightval
-        when  "*"
-          leftval * rightval
-        when  "/"
-          raise DivideByZeroError, "division by 0 : #{leftval}/0" if rightval.zero?
-          leftval / rightval
-        when  ">"
-          leftval > rightval
-        when  "<"
-          leftval < rightval
-        when  ">="
-          leftval >= rightval
-        when  "<="
-          leftval <= rightval
-        when  "=", "=="
-          leftval == rightval
-        when  "!="
-          leftval != rightval
-        when  "AND"
-          leftval && rightval
-        else
-          raise "unsupported operand : #{op} : #{left} #{operator} #{right}"
-        end
-      end
-    end
-  end
-end

data/lib/hesabu/types/string_lit.rb

@@ -1,9 +0,0 @@
-module Hesabu
-  module Types
-    StringLit = Struct.new(:string) do
-      def eval
-        string
-      end
-    end
-  end
-end