hesabu 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abe943d484f4a7c14677bbd0edaa584a9705718b76dbf6584e827c61d804b290
-  data.tar.gz: feb5c1e48b9bd534e9e780b282e4dc0c246b77c6c9897b7d355acb23efa19967
+  metadata.gz: a7919ff5f5986fbf22b42ccbc75d9b782619a6a037219d4e379528777e86168c
+  data.tar.gz: 7b33587c21aaf91e74c2d64d835d54b923a729e20dcd1419597b53411ca2972a
 SHA512:
-  metadata.gz: d85f9343ef7f93028552e8ccf73be54c5eac7d4210a9172666f06b72bf941660e9bf21f528c5bc3a53236566963bb3b832b17456349f3959f5047e4d9831e5c1
-  data.tar.gz: 696f4a816991e4fcf72cf1291c3c392215d2d7f13f1ebc167db32ae80cfdfa8d27ad38a802eae91d58e416f063a7bd744e6f4dfa56fc5a83333b92cd1956fd0e
+  metadata.gz: 93953561238b518ae4287e12a72725c55668402ebf0e7cac31f9559b12eabd45bde96af2b5a256d3d0ea2157a82a77eb8d217907d53a17afdffc94e87903b3a0
+  data.tar.gz: 1950edd4e3a4c757d8e97d8fde8b6d9013b470474545ce590925bf50314d2339cfea816732b1dc86da444c541763d7b9498f203a71d6e457b15543ea669dffe4

data/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,11 @@
+## Self proof reading checklist
+
+- [ ] Did I run Pronto and fixed all warnings
+- [ ] Make sure all naming and code will remain understandable in 6 month by someone new to the project or by you.
+- [ ] Did I test the right thing?
+- [ ] Did I test corner cases, non happy path (defensive testing)?
+- [ ] Check that I used the ad-hoc patterns and created files accordingly
+- [ ] Check code efficiency with record intensive project
+- [ ] Update documentation,readme accordingly
+
+Thanks!

data/.gitignore

@@ -10,4 +10,5 @@
 # rspec failure tracking
 .rspec_status
 
-*.gem
+*.gem
+.byebug_history

data/.rubocop.yml

@@ -1,9 +1,7 @@
 AllCops:
-  TargetRubyVersion: 2.3
+  TargetRubyVersion: 2.5
   Exclude:
     - db/schema.rb
-Rails:
-  Enabled: true
 Layout/AlignHash:
   # Alignment of entries using hash rocket as separator. Valid values are:
   #
@@ -52,9 +50,8 @@ Style/FormatStringToken:
   EnforcedStyle: template
 Metrics/LineLength:
   Exclude:
-    - 'spec/**/*.rb'  
+    - 'spec/**/*.rb'
 Metrics/BlockLength:
   Exclude:
     - 'spec/**/*.rb'
 
-    

data/.travis.yml

@@ -2,7 +2,7 @@ sudo: false
 language: ruby
 cache: bundler
 rvm:
-- 2.4.2
+- 2.5.1
 before_install: gem install bundler -v 1.16.1
 before_script:
 - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at mestachs. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -1,6 +1,6 @@
 source "https://rubygems.org"
 
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
 # Specify your gem's dependencies in hesabu.gemspec
 gemspec

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    hesabu (0.1.1)
+    hesabu (0.1.2)
       parslet
 
 GEM

data/README.md

@@ -7,6 +7,47 @@
 
 Hesabu : equation solver based on parslet.
 
+## sample usage
+```ruby
+    solver = Hesabu::Solver.new
+    solver.add("c", "a + b")
+    solver.add("a", "10")
+    solver.add("b", "10 + a")
+
+    solution = solver.solve!
+
+    expect(solution).to eq("a" => 10, "b" => 20, "c" => 30)
+```
+
+The solver will deduce the correct order and find the values of a,b and c.
+
+The expressions can be more complex (excel like), see the supported functions [here](https://github.com/BLSQ/hesabu/blob/master/lib/hesabu/types/fun_call.rb#L87)
+
+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
+
+## Alternatives
+
+* https://github.com/rubysolo/dentaku more complete, currently less performant.
+
+
+# Development
+
+## Running the tests
+
+```
+# only the fast
+bundle exec rspec --tag ~slow
+# all with integration test, expect around 30-40 seconds depending on your machine
+bundle exec rspec
+```
 
 ## deployment to rubygems.org
 

data/Rakefile

@@ -3,4 +3,4 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec

data/hesabu.gemspec

@@ -1,5 +1,5 @@
 
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "hesabu/version"
 
@@ -9,15 +9,14 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Stéphan Mestach"]
   spec.email         = ["smestach@bluesquarehub.com"]
 
-  spec.summary       = %q{arithmetic equation solver.}
-  spec.description   = %q{arithmetic equation solver.}
+  spec.summary       = "arithmetic equation solver."
+  spec.description   = "arithmetic equation solver."
   spec.homepage      = "https://github.com/BLSQ/hesabu"
   spec.license       = "MIT"
 
-
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
   spec.bindir        = "exe"

data/lib/hesabu.rb

@@ -1,10 +1,13 @@
 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"

data/lib/hesabu/errors.rb

@@ -0,0 +1,15 @@
+
+module Hesabu
+  class Error < StandardError
+  end
+  class ParseError < Error
+  end
+  class CalculationError < Error
+  end
+  class DivideByZeroError < Error
+  end
+  class CyclicError < Error
+  end
+  class UnboundVariableError < Error
+  end
+end

data/lib/hesabu/interpreter.rb

@@ -1,20 +1,23 @@
 module Hesabu
   class Interpreter < Parslet::Transform
-    rule(left:  simple(:left),
-         right: simple(:right),
-         op:    simple(:op)) do
-      Hesabu::Types::Operation.new(left, op, right)
-    end
     rule(plist: sequence(:arr)) { arr }
     rule(plist: "()") { [] }
-    rule(fcall: { name: simple(:name), varlist: sequence(:vars) }) do
-      Hesabu::Types::FunCall.new(name, vars)
+    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) }

data/lib/hesabu/parser.rb

@@ -5,51 +5,56 @@ module Hesabu
     end
 
     # simple things
-    rule(:lparen)             { str('(') >> space? }
-    rule(:rparen)             { str(')') >> space? }
-    rule(:comma)              { str(',') >> space? }
+    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))
+      cts((match["a-zA-Z"] >> match["a-zA-Z0-9_"].repeat).as(:identifier))
     end
 
-    rule(:separator) { str(';') }
+    rule(:separator) { str(";") }
 
-    rule(:digit) { match['0-9'] }
+    rule(:digit) { match["0-9"] }
 
     rule(:integer) do
-      cts((str('-').maybe >> match['1-9'] >> digit.repeat).as(:integer) | str('0').as(:integer))
+      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("-").maybe >> digit.repeat(1) >> str(".") >> digit.repeat(1)).as(:float))
     end
 
     # arithmetic
 
-    rule(:expression)         { sum | comparison | variable | pexpression }
+    rule(:expression)         { iexpression | variable | pexpression }
     rule(:pexpression)        { lparen >> expression >> rparen }
 
-    rule(:variable)           { identifier.as(:variable) } # gets simplified into a value, an "identifier" does not
-    rule(:sum_op)             { match('[+-]') >> space? }
-    rule(:mul_op)             { match('[*/]') >> space? }
-    rule(:comparison_op)      { (str('<=') | str('>=') | str('==') | str('<') | str('=') | str('>')) >> space? }
-
-    rule(:atom) { pexpression | float | integer | fcall.as(:fcall) | variable }
-
-    rule(:comparison) do
-      atom.as(:left) >> comparison_op.as(:op) >> atom.as(:right)
+    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(:sum) do
-      mul.as(:left) >>  sum_op.as(:op) >> sum.as(:right) | mul | comparison
-    end
+    rule(:atom) { string | pexpression | float | integer | fcall.as(:fcall) | variable }
 
-    rule(:mul) do
-      atom.as(:left) >> mul_op.as(:op) >> mul.as(:right) | comparison | atom
+    rule(:iexpression) do
+      infix_expression(atom,
+                       [mul_op, 3, :left],
+                       [sum_op, 2, :left],
+                       [comparison_op, 1, :left])
     end
 
     # lists
@@ -57,13 +62,11 @@ module Hesabu
     rule(:pvarlist)   { (lparen >> varlist.repeat >> rparen).as(:plist) }
 
     # functions
-    rule(:fdef_keyword) { str('def ') >> space? }
-    rule(:fend_keyword) { str('endf') >> space? }
     rule(:fcall)        { identifier.as(:name) >> pvarlist.as(:varlist) }
 
     # root
     rule(:command) do
-      sum
+      iexpression | expression | atom
     end
     rule(:commands) { commands.repeat }
     root :command

data/lib/hesabu/solver.rb

@@ -2,7 +2,7 @@ module Hesabu
   class Solver
     include TSort
 
-    Equation = Struct.new(:name, :evaluable, :dependencies)
+    Equation = Struct.new(:name, :evaluable, :dependencies, :raw_expression)
     EMPTY_DEPENDENCIES = [].freeze
     FakeEvaluable = Struct.new(:eval)
 
@@ -13,50 +13,29 @@ module Hesabu
       @bindings = {}
     end
 
-    alias solving_order tsort
-
     def add(name, raw_expression)
-      expression = raw_expression
-      raw_expression_as_i = raw_expression.to_i
-      raw_expression_as_f = raw_expression.to_f
-
-      if raw_expression == raw_expression_as_i.to_s
-        @equations[name] = Equation.new(
-          name,
-          FakeEvaluable.new(raw_expression_as_i),
-          EMPTY_DEPENDENCIES
-        )
-      elsif raw_expression == raw_expression_as_f.to_s
-        @equations[name] = Equation.new(
-          name,
-          FakeEvaluable.new(raw_expression_as_f),
-          EMPTY_DEPENDENCIES
-        )
+      if ::Hesabu::Types.as_numeric(raw_expression)
+        add_numeric(name, raw_expression)
       else
-        expression = raw_expression.gsub(/\r\n?/, "")
-        ast_tree = begin
-          @parser.parse(expression)
-        rescue Parslet::ParseFailed => e
-          raise "failed to parse #{name} := #{expression} : #{e.message}"
-        end
-        var_identifiers = Set.new
-        interpretation = @interpreter.apply(
-          ast_tree,
-          doc:             @bindings,
-          var_identifiers: var_identifiers
-        )
-        @equations[name] = Equation.new(name, interpretation, var_identifiers)
+        add_equation(name, raw_expression)
       end
     end
 
     def solve!
       solving_order.each do |name|
-        equation = @equations[name]
-        @bindings[equation.name] = equation.evaluable.eval
+        evaluate_equation(@equations[name])
       end
       solution = @bindings.dup
       @bindings.clear
-      solution
+      to_numerics(solution)
+    rescue StandardError => e
+      log_and_raise(e)
+    end
+
+    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)
@@ -64,7 +43,75 @@ module Hesabu
     end
 
     def tsort_each_child(node, &block)
-      @equations[node].dependencies.each(&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
+    end
+
+    def log_and_raise(e)
+      log "Error during processing: #{$ERROR_INFO}"
+      log "Error : #{e.class} #{e.message}"
+      log "Backtrace:\n\t#{e.backtrace.join("\n\t")}"
+      raise e
+    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
+        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 unbound_message(node)
+      ref = first_reference(node)
+      "Unbound variable : #{node} used by #{ref.name} (#{ref.raw_expression})"
+    end
+
+    def first_reference(variable_name)
+      @equations.values.select { |v| v.dependencies.include?(variable_name) }.take(1).first
     end
   end
 end

data/lib/hesabu/types/float_lit.rb

@@ -2,7 +2,7 @@ module Hesabu
   module Types
     FloatLit = Struct.new(:float) do
       def eval
-        float.to_f
+        Hesabu::Types.as_bigdecimal(float)
       end
     end
   end

data/lib/hesabu/types/fun_call.rb

@@ -1,6 +1,11 @@
 module Hesabu
   module Types
-    class IfFunction
+    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]
@@ -9,14 +14,14 @@ module Hesabu
       end
     end
 
-    class SumFunction
+    class SumFunction < Function
       def call(args)
         values = args.map(&:eval)
         values.reduce(0, :+)
       end
     end
 
-    class ScoreTableFunction
+    class ScoreTableFunction < Function
       def call(args)
         values = args.map(&:eval)
         target = values.shift
@@ -27,21 +32,21 @@ module Hesabu
       end
     end
 
-    class AvgFunction
+    class AvgFunction < Function
       def call(args)
         values = args.map(&:eval)
         values.inject(0.0) { |acc, elem| acc + elem } / values.size
       end
     end
 
-    class SafeDivFunction
+    class SafeDivFunction < Function
       def call(args)
         eval_denom = args[1].eval
         if eval_denom == 0
           0
         else
           eval_num = args[0].eval
-          eval_num / eval_denom.to_f
+          eval_denom.zero? ? 0 : (eval_num / eval_denom)
         end
       end
     end
@@ -83,6 +88,15 @@ module Hesabu
       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,
@@ -93,7 +107,8 @@ module Hesabu
       "randbetween" => RandbetweenFunction.new,
       "score_table" => ScoreTableFunction.new,
       "abs"         => AbsFunction.new,
-      "access"         => AccessFunction.new,
+      "access"      => AccessFunction.new,
+      "round"       => RoundFunction.new
     }.freeze
 
     FunCall = Struct.new(:name, :args) do

data/lib/hesabu/types/int_lit.rb

@@ -2,7 +2,7 @@ module Hesabu
   module Types
     IntLit = Struct.new(:int) do
       def eval
-        int.to_i
+        ::Hesabu::Types.as_bigdecimal(int)
       end
     end
   end

data/lib/hesabu/types/numeric.rb

@@ -0,0 +1,34 @@
+require "bigdecimal"
+module Hesabu
+  module Types
+    MAXDECIMAL = Float::DIG + 1
+
+    def self.as_numeric!(value)
+      numeric = as_numeric(value)
+      return numeric if numeric
+      raise "Not a numeric : '#{value}' (#{value.class.name})"
+    end
+
+    def self.as_numeric(value)
+      if value.is_a?(::Numeric)
+        return value.to_i if value.to_i == value
+        return value
+      end
+      value = value.str if value.is_a?(::Parslet::Slice)
+      if value.is_a?(::String)
+        number = value[/\A-?\d*\.?\d+\z/]
+        if number
+          if number.include?(".")
+            return BigDecimal(number, MAXDECIMAL)
+          else
+            return number.to_i
+          end
+        end
+      end
+    end
+
+    def self.as_bigdecimal(number)
+      BigDecimal(number, MAXDECIMAL)
+    end
+  end
+end

data/lib/hesabu/types/operation.rb

@@ -3,30 +3,39 @@ module Hesabu
     Operation = Struct.new(:left, :operator, :right) do
       def eval
         op = operator.str.strip
+        result(op, left.eval, right.eval)
+      end
+
+      private
 
-        result = if op == "+"
-                   left.eval + right.eval
-                 elsif op == "-"
-                   left.eval - right.eval
-                 elsif op == "*"
-                   left.eval * right.eval
-                 elsif op == "/"
-                   left.eval / right.eval.to_f
-                 elsif op == ">"
-                   left.eval > right.eval
-                 elsif op == "<"
-                   left.eval < right.eval
-                 elsif op == ">="
-                   left.eval >= right.eval
-                 elsif op == "<="
-                   left.eval <= right.eval
-                 elsif op == "=" || op == "=="
-                   left.eval == right.eval
-                 else
-                   raise "unsupported operand : #{operator} : #{left} #{operator} #{right}"
-                 end
-        # puts "#{left.eval} #{op}  #{right.eval} => #{result}"
-        result
+      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

data/lib/hesabu/types/string_lit.rb

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

data/lib/hesabu/version.rb

@@ -1,3 +1,3 @@
 module Hesabu
-  VERSION = "0.1.2"
+  VERSION = "0.1.3".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hesabu
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Stéphan Mestach
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-03 00:00:00.000000000 Z
+date: 2018-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -157,11 +157,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/PULL_REQUEST_TEMPLATE.md"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
 - ".ruby-version"
 - ".travis.yml"
+- CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -171,6 +173,7 @@ files:
 - bin/setup
 - hesabu.gemspec
 - lib/hesabu.rb
+- lib/hesabu/errors.rb
 - lib/hesabu/interpreter.rb
 - lib/hesabu/parser.rb
 - lib/hesabu/solver.rb
@@ -178,7 +181,9 @@ files:
 - 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: