kalc 1.2.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7dd87399e45a1819f532e20a2e4fed4be6824b6e
-  data.tar.gz: 17167d66287fe9869eed4c788eb8942b85551d76
+SHA256:
+  metadata.gz: c6b57e87fb3af0e7410e84529380e3b6e6b37d79ded5ba5956807803dfe4e9b1
+  data.tar.gz: 280bbed579405d13d7c31f0931ddd4d63904bb5759f0468409307b040ba4b4fd
 SHA512:
-  metadata.gz: 9019d6437db9acf668148ababebfa77e8120d44f916d84d082011d58836f7c2e09bda5b1bf55f50d82dc96df98525f105db3d82709f0c64c5ba37d03fe90614c
-  data.tar.gz: 930b53a089d8e62a093ef09bda37a4aab7004ab4d4b64a1f8636840819ae8c5b67c60c04c4bee6e84ceb469c551bba8365a5cb071e23c5e0fe4ce9c15bf7d474
+  metadata.gz: 22a28f8e0fc573736bf356a6e0744eef81a6e9d0ea7710ee1559094ffe1549d9ef01e4f9ca221dd93ff9d1f3813284b7e35cbfb79c63cbc18dc71c4a7d28b4ca
+  data.tar.gz: 70332cf06859be1a6ceb52ad2951acd5c5553bde9239d24210cec7a0ef142fe74bfa666ace03dc58cb3487039a76a0f3d0f9faec92ed154a002ed6a7515b54fa

data/Gemfile.lock

@@ -1,30 +1,28 @@
 PATH
   remote: .
   specs:
-    kalc (1.2.0)
-      parslet (~> 1.7)
+    kalc (1.7.0)
+      parslet (~> 1.8.2)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    blankslate (3.1.3)
-    diff-lcs (1.2.5)
-    parslet (1.7.1)
-      blankslate (>= 2.0, <= 4.0)
-    rake (11.2.2)
-    rspec (3.5.0)
-      rspec-core (~> 3.5.0)
-      rspec-expectations (~> 3.5.0)
-      rspec-mocks (~> 3.5.0)
-    rspec-core (3.5.0)
-      rspec-support (~> 3.5.0)
-    rspec-expectations (3.5.0)
+    diff-lcs (1.3)
+    parslet (1.8.2)
+    rake (12.1.0)
+    rspec (3.6.0)
+      rspec-core (~> 3.6.0)
+      rspec-expectations (~> 3.6.0)
+      rspec-mocks (~> 3.6.0)
+    rspec-core (3.6.0)
+      rspec-support (~> 3.6.0)
+    rspec-expectations (3.6.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.5.0)
-    rspec-mocks (3.5.0)
+      rspec-support (~> 3.6.0)
+    rspec-mocks (3.6.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.5.0)
-    rspec-support (3.5.0)
+      rspec-support (~> 3.6.0)
+    rspec-support (3.6.0)
 
 PLATFORMS
   java
@@ -36,4 +34,4 @@ DEPENDENCIES
   rspec
 
 BUNDLED WITH
-   1.12.5
+   1.16.2

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Chris Parker
+Copyright (c) 2012-2018 Chris Parker
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/kalc.gemspec

@@ -1,25 +1,23 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path('../lib', __FILE__)
+$LOAD_PATH.push File.expand_path('lib', __dir__)
 require 'kalc/version'
-#
 Gem::Specification.new do |s|
   s.name = 'kalc'
   s.version = Kalc::VERSION
   s.authors = ['Chris Parker']
-  s.email = %w(mrcsparker@gmail.com)
+  s.email = %w[mrcsparker@gmail.com]
   s.homepage = 'https://github.com/mrcsparker/kalc'
-  s.summary = %q{Small calculation language.}
-  s.description = %q{Calculation language slightly based on Excel's formula language.}
+  s.summary = 'Small calculation language.'
+  s.description = "Calculation language slightly based on Excel's formula language."
 
   s.rubyforge_project = 'kalc'
 
   s.files = `git ls-files`.split("\n")
   s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
-  s.require_paths = %w(lib)
+  s.require_paths = %w[lib]
 
   # specify any dependencies here; for example:
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec'
-  s.add_runtime_dependency 'parslet', '~> 1.7'
+  s.add_runtime_dependency 'parslet', '~> 1.8.2'
 end

data/lib/kalc/ast.rb

@@ -40,11 +40,9 @@ module Kalc
       end
 
       def eval(context)
-        begin
-          -(@value.eval(context))
-        rescue
-          @value.eval(context)
-        end
+        -@value.eval(context)
+      rescue StandardError
+        @value.eval(context)
       end
     end
 
@@ -57,11 +55,9 @@ module Kalc
       end
 
       def eval(context)
-        begin
-          +(@value.eval(context))
-        rescue
-          @value.eval(context)
-        end
+        +@value.eval(context)
+      rescue StandardError
+        @value.eval(context)
       end
     end
 
@@ -72,8 +68,8 @@ module Kalc
         @value = value
       end
 
-      def eval(context)
-        @value == 'TRUE' ? true : false
+      def eval(_context)
+        @value == 'TRUE'
       end
     end
 
@@ -81,11 +77,11 @@ module Kalc
       attr_reader :value
 
       def initialize(value)
-        @value = BigDecimal.new(value.to_s)
+        @value = BigDecimal(value.to_s)
       end
 
-      def eval(context)
-        BigDecimal.new(@value)
+      def eval(_context)
+        BigDecimal(@value)
       end
     end
 
@@ -123,10 +119,10 @@ module Kalc
       end
 
       def eval(context)
-        @ops.inject(@left.eval(context)) { |x, op|
+        @ops.inject(@left.eval(context)) do |x, op|
           a = Arithmetic.new(x, op[:right].eval(context), op[:operator])
           a.eval(context)
-        }
+        end
       end
     end
 
@@ -141,7 +137,7 @@ module Kalc
         @operator = operator
       end
 
-      def eval(context)
+      def eval(_context)
         case @operator.to_s.strip
         when '&&'
           @left && @right
@@ -218,7 +214,8 @@ module Kalc
 
       def eval(context)
         var = context.get_variable(@variable)
-        fail "Invalid variable: #{@variable}" unless var
+        raise "Invalid variable: #{@variable}" unless var
+
         var.class == BigDecimal ? var : var.eval(context)
       end
     end
@@ -230,7 +227,7 @@ module Kalc
         @value = value
       end
 
-      def eval(context)
+      def eval(_context)
         value.to_s
       end
     end
@@ -246,11 +243,12 @@ module Kalc
 
       def eval(context)
         to_call = context.get_function(@name)
-        fail "Unknown function #{@name}" unless to_call
+        raise "Unknown function #{@name}" unless to_call
+
         to_call.call(context, *@variable_list)
       rescue ArgumentError
-        fail "Argument Error. Function #{@name} was called with #{@variable_list.count} parameters. " +
-          "It needs at least #{to_call.parameters.select{|a| a.first == :req}.count - 1 } parameters"
+        raise "Argument Error. Function #{@name} was called with #{@variable_list.count} parameters. " \
+             "It needs at least #{to_call.parameters.select { |a| a.first == :req }.count - 1} parameters"
       end
     end
 

data/lib/kalc/environment.rb

@@ -11,31 +11,27 @@ module Kalc
     end
 
     def add_function(name, value)
-      @functions.update({ name.to_s.strip => value })
+      @functions.update(name.to_s.strip => value)
     end
 
     def get_function(name)
-      if fun = @functions[name.to_s.strip]
+      if (fun = @functions[name.to_s.strip])
         fun
       elsif !@parent.nil?
         @parent.get_function(name)
-      else
-        nil
       end
     end
 
     def add_variable(name, value)
-      @variables.update({ name.to_s.strip => value })
+      @variables.update(name.to_s.strip => value)
       value
     end
 
     def get_variable(name)
-      if var = @variables[name.to_s.strip]
+      if (var = @variables[name.to_s.strip])
         var
       elsif !@parent.nil?
         @parent.get_variable(name)
-      else
-        nil
       end
     end
   end

data/lib/kalc/grammar.rb

@@ -27,26 +27,24 @@ class Kalc::Grammar < Parslet::Parser
     end
   end
 
-  symbols :left_paren => '(',
-          :right_paren => ')',
-          :left_brace => '{',
-          :right_brace => '}',
-          :comma => ',',
-          :colon => ':',
-          :question_mark => '?'
+  symbols left_paren: '(',
+          right_paren: ')',
+          left_brace: '{',
+          right_brace: '}',
+          comma: ',',
+          colon: ':',
+          question_mark: '?'
 
   def self.operators(operators = {})
     trailing_chars = Hash.new { |hash, symbol| hash[symbol] = [] }
 
     operators.each_value do |symbol|
       operators.each_value do |op|
-        if op[0, symbol.length] == symbol
-          char = op[symbol.length, 1]
+        next unless op[0, symbol.length] == symbol
 
-          unless char.nil? || char.empty?
-            trailing_chars[symbol] << char
-          end
-        end
+        char = op[symbol.length, 1]
+
+        trailing_chars[symbol] << char unless char.nil? || char.empty?
       end
     end
 
@@ -54,238 +52,232 @@ class Kalc::Grammar < Parslet::Parser
       trailing = trailing_chars[symbol]
 
       if trailing.empty?
-        rule(name) { str(symbol).as(:operator) >> spaces? }
+        rule(name) {str(symbol).as(:operator) >> spaces?}
       else
         pattern = "[#{Regexp.escape(trailing.join)}]"
 
-        rule(name) {
+        rule(name) do
           (str(symbol) >> match(pattern).absnt?).as(:operator) >> spaces?
-        }
+        end
       end
     end
   end
 
-  operators :logical_and => '&&',
-            :string_and => 'and',
-            :logical_or => '||',
-            :string_or => 'or',
-            :less_equal => '<=',
-            :greater_equal => '>=',
-            :equal => '==',
-            :not_equal => '!=',
-
-            :assign => ':=',
-            :excel_equal => '=',
-
-            :subtract => '-',
-            :add => '+',
-            :multiply => '*',
-            :divide => '/',
-            :modulus => '%',
-            :power_of => '^',
-
-            :less => '<',
-            :greater => '>'
-
-  rule(:true_keyword) {
+  operators logical_and: '&&',
+            string_and: 'and',
+            logical_or: '||',
+            string_or: 'or',
+            less_equal: '<=',
+            greater_equal: '>=',
+            equal: '==',
+            not_equal: '!=',
+
+            assign: ':=',
+            excel_equal: '=',
+
+            subtract: '-',
+            add: '+',
+            multiply: '*',
+            divide: '/',
+            modulus: '%',
+            power_of: '^',
+
+            less: '<',
+            greater: '>'
+
+  rule(:true_keyword) do
     str('TRUE') >> spaces?
-  }
+  end
 
-  rule(:false_keyword) {
+  rule(:false_keyword) do
     str('FALSE') >> spaces?
-  }
+  end
 
-  rule(:boolean) {
+  rule(:boolean) do
     (true_keyword | false_keyword).as(:boolean)
-  }
+  end
 
-  rule(:string) {
+  rule(:string) do
     str('"') >>
-        (
-        str('\\') >> any |
-            str('"').absnt? >> any
-        ).repeat.as(:string) >>
-        str('"')
-  }
-
-  rule(:exponent) {
+      (
+        str('\\') >> any | str('"').absnt? >> any
+      ).repeat.as(:string) >> str('"')
+  end
+
+  rule(:exponent) do
     match('[eE]') >> match('[-+]').maybe >> digits
-  }
+  end
 
   # We are using a really broad definition of what a number is.
   # Numbers can be 1, 1.0, 0.1, 1.0e4, +1.0E10, etc
-  rule(:number) {
+  rule(:number) do
     (match('[+-]').maybe >>
-        (str('.') >> digits >> exponent.maybe).as(:number) >> spaces?) |
-        (match('[+-]').maybe >>
-            digits >> (str('.') >> digits).maybe >> exponent.maybe).as(:number) >> spaces?
-  }
+      (str('.') >> digits >> exponent.maybe).as(:number) >> spaces?) |
+      (match('[+-]').maybe >> digits >> (str('.') >> digits).maybe >> exponent.maybe).as(:number) >> spaces?
+  end
 
-  rule(:identifier) {
+  rule(:identifier) do
     (alpha >> (alpha | digit).repeat) >> spaces?
-  }
+  end
 
-  rule(:quoted_identifier) {
-    str("'") >>
-        (
-        str('\\') >> any | str("'").absnt? >> any
-        ).repeat(1) >>
-        str("'") >> spaces?
-  }
+  rule(:quoted_identifier) do
+    str("'") >> (
+      str('\\') >> any | str("'").absnt? >> any
+    ).repeat(1) >> str("'") >> spaces?
+  end
 
-  rule(:argument) {
+  rule(:argument) do
     identifier.as(:argument)
-  }
+  end
 
   # Should look like 'Name'
-  rule(:variable) {
-    #identifier | (str("'") >> spaces? >> identifier.repeat >> str("'")) >> spaces?
+  rule(:variable) do
     identifier | quoted_identifier
-  }
+  end
 
   # Does not self-evaluate
   # Use to call function: FUNCTION_NAME(variable_list, ..)
-  rule(:variable_list) {
+  rule(:variable_list) do
     conditional_expression >> (comma >> conditional_expression).repeat
-  }
+  end
 
-  rule(:paren_variable_list) {
+  rule(:paren_variable_list) do
     (left_paren >> variable_list.repeat >> right_paren).as(:paren_list)
-  }
+  end
 
   # Does not self-evaluate
   # Used to create function: DEF FUNCTION_NAME(argument_list, ..)
-  rule(:argument_list) {
+  rule(:argument_list) do
     argument >> (comma >> argument).repeat
-  }
+  end
 
-  rule(:paren_argument_list) {
+  rule(:paren_argument_list) do
     (left_paren >> argument_list.repeat >> right_paren).as(:paren_list)
-  }
+  end
 
   # Atoms can self-evaluate
   # This where the grammar starts
-  rule(:atom) {
+  rule(:atom) do
     paren_expression.as(:paren_expression) | boolean | variable.as(:variable) | number | string
-  }
+  end
 
   # (1 + 2)
-  rule(:paren_expression) {
+  rule(:paren_expression) do
     left_paren >> conditional_expression >> right_paren
-  }
+  end
 
-  rule(:non_ops_expression) {
+  rule(:non_ops_expression) do
     (atom.as(:left) >>
-        power_of >>
-        atom.as(:right)).as(:non_ops) | atom
-  }
+      power_of >>
+      atom.as(:right)).as(:non_ops) | atom
+  end
 
   # IF(1, 2, 3)
   # AND(1, 2, ...)
-  rule(:function_call_expression) {
+  rule(:function_call_expression) do
     (identifier.as(:name) >> paren_variable_list.as(:variable_list)).as(:function_call) |
-        (str('+') >> non_ops_expression).as(:positive) |
-        (str('-') >> non_ops_expression).as(:negative) | non_ops_expression
-  }
+      (str('+') >> non_ops_expression).as(:positive) |
+      (str('-') >> non_ops_expression).as(:negative) | non_ops_expression
+  end
 
   # 1 + 2
-  rule(:additive_expression) {
+  rule(:additive_expression) do
     multiplicative_expression.as(:left) >>
-        ((add | subtract) >>
-            multiplicative_expression.as(:right)).repeat.as(:ops)
-  }
+      ((add | subtract) >>
+        multiplicative_expression.as(:right)).repeat.as(:ops)
+  end
 
   # 1 * 2
-  rule(:multiplicative_expression) {
+  rule(:multiplicative_expression) do
     function_call_expression.as(:left) >>
-        ((multiply | divide | modulus) >>
-            function_call_expression.as(:right)).repeat.as(:ops)
-  }
+      ((multiply | divide | modulus) >>
+        function_call_expression.as(:right)).repeat.as(:ops)
+  end
 
   # 1 < 2
   # 1 > 2
   # 1 <= 2
   # 1 >= 2
-  rule(:relational_expression) {
+  rule(:relational_expression) do
     additive_expression.as(:left) >>
-        ((less | greater | less_equal | greater_equal) >>
-            relational_expression.as(:right)).repeat.as(:ops)
-  }
+      ((less | greater | less_equal | greater_equal) >>
+        relational_expression.as(:right)).repeat.as(:ops)
+  end
 
   # 1 = 2
-  rule(:equality_expression) {
+  rule(:equality_expression) do
     relational_expression.as(:left) >>
-        ((excel_equal | equal | not_equal) >>
-            equality_expression.as(:right)).repeat.as(:ops)
-  }
+      ((excel_equal | equal | not_equal) >>
+        equality_expression.as(:right)).repeat.as(:ops)
+  end
 
   # 1 && 2
-  rule(:logical_and_expression) {
+  rule(:logical_and_expression) do
     equality_expression.as(:left) >>
-        ((logical_and | string_and) >>
-            logical_and_expression.as(:right)).repeat.as(:ops)
-  }
+      ((logical_and | string_and) >>
+        logical_and_expression.as(:right)).repeat.as(:ops)
+  end
 
   # 1 || 2
-  rule(:logical_or_expression) {
+  rule(:logical_or_expression) do
     logical_and_expression.as(:left) >>
-        ((logical_or | string_or) >>
-            logical_or_expression.as(:right)).repeat.as(:ops)
-  }
+      ((logical_or | string_or) >>
+        logical_or_expression.as(:right)).repeat.as(:ops)
+  end
 
   # 1 > 2 ? 3 : 4
-  rule(:conditional_expression) {
+  rule(:conditional_expression) do
     logical_or_expression.as(:condition) >>
-        (question_mark >>
-            conditional_expression.as(:true_cond) >>
-            colon >>
-            conditional_expression.as(:false_cond)).maybe
-  }
+      (question_mark >>
+        conditional_expression.as(:true_cond) >>
+        colon >>
+        conditional_expression.as(:false_cond)).maybe
+  end
 
   # 'a' = 1
   # We don't allow for nested assignments:
   # IF('a' = 1, 1, 2)
-  rule(:assignment_expression) {
+  rule(:assignment_expression) do
     (variable.as(:identifier) >>
-        assign >>
-        assignment_expression.as(:value)).as(:assign) |
-        conditional_expression
-  }
+      assign >>
+      assignment_expression.as(:value)).as(:assign) |
+      conditional_expression
+  end
 
-  rule(:expression) {
+  rule(:expression) do
     assignment_expression
-  }
+  end
 
-  rule(:expressions) {
+  rule(:expressions) do
     expression >> (separator >> expressions).repeat
-  }
+  end
 
-  rule(:function_body) {
+  rule(:function_body) do
     expressions.as(:expressions)
-  }
+  end
 
-  rule(:function_definition_expression) {
+  rule(:function_definition_expression) do
     (str('DEFINE') >> spaces? >> identifier.as(:name) >>
-        paren_argument_list.as(:argument_list) >>
-        left_brace >> function_body.as(:body) >> right_brace).as(:function_definition) |
-        expressions.as(:expressions)
-  }
+      paren_argument_list.as(:argument_list) >>
+      left_brace >> function_body.as(:body) >> right_brace).as(:function_definition) |
+      expressions.as(:expressions)
+  end
 
-  rule(:function_definition_expressions) {
+  rule(:function_definition_expressions) do
     function_definition_expression >> separator.maybe >> function_definition_expressions.repeat
-  }
+  end
 
-  rule(:commands) {
+  rule(:commands) do
     function_definition_expressions | expressions
-  }
+  end
 
-  rule(:line) {
+  rule(:line) do
     commands.as(:commands)
-  }
+  end
 
-  rule(:lines) {
+  rule(:lines) do
     line >> (new_line >> lines).repeat
-  }
+  end
 
   root :lines
 end

data/lib/kalc/interpreter.rb

@@ -8,7 +8,6 @@ module Kalc
 
     def initialize
       @env = Environment.new do |env|
-
         env.add_function(:IF, lambda { |cxt, cond, if_true, if_false|
           cond.eval(cxt) ? if_true.eval(cxt) : if_false.eval(cxt)
         })
@@ -43,7 +42,7 @@ module Kalc
           rand(val.eval(cxt))
         })
 
-        env.add_function(:SYSTEM, lambda { |cxt, val|
+        env.add_function(:SYSTEM, lambda { |_cxt, _val|
           throw "Nope.  I don't think so!"
         })
 
@@ -99,15 +98,21 @@ module Kalc
         })
 
         env.add_function(:MAX, lambda { |cxt, first, *args|
-          (args<<first).map { |a| a.eval(cxt) }.max
+          evaluated_args = (args << first).map { |a| a.eval(cxt) }
+          return BigDecimal('NaN') if evaluated_args.any? { |a| a.is_a?(BigDecimal) && a.nan? }
+
+          evaluated_args.max
         })
 
         env.add_function(:MIN, lambda { |cxt, first, *args|
-          (args<<first).map { |a| a.eval(cxt) }.min
+          evaluated_args = (args << first).map { |a| a.eval(cxt) }
+          return BigDecimal('NaN') if evaluated_args.any? { |a| a.is_a?(BigDecimal) && a.nan? }
+
+          evaluated_args.min
         })
 
         math_funs =
-            %w(acos acosh asin asinh atan atanh cbrt cos cosh erf erfc exp gamma lgamma log log2 log10 sin sinh sqrt tan tanh)
+          %w[acos acosh asin asinh atan atanh cbrt cos cosh erf erfc exp gamma lgamma log log2 log10 sin sinh sqrt tan tanh]
 
         math_funs.each do |math_fun|
           env.add_function(math_fun.upcase.to_sym, lambda { |cxt, val|
@@ -117,12 +122,12 @@ module Kalc
 
         # Strings
         string_funs =
-            %w(chomp chop chr clear count
-               downcase
-               hex
-               inspect intern
-               to_sym length size lstrip succ next oct ord reverse rstrip strip
-               swapcase to_c to_f to_i to_r upcase)
+          %w[chomp chop chr clear count
+             downcase
+             hex
+             inspect intern
+             to_sym length size lstrip succ next oct ord reverse rstrip strip
+             swapcase to_c to_f to_i to_r upcase]
 
         string_funs.each do |str_fun|
           env.add_function(str_fun.upcase.to_sym, lambda { |cxt, val|
@@ -147,7 +152,7 @@ module Kalc
         })
 
         env.add_function(:DOLLAR, lambda { |cxt, val, decimal_places|
-          "%.#{Integer(decimal_places.eval(cxt))}f" % BigDecimal.new(val.eval(cxt))
+          format("%.#{Integer(decimal_places.eval(cxt))}f", BigDecimal(val.eval(cxt)))
         })
 
         env.add_function(:EXACT, lambda { |cxt, string1, string2|
@@ -160,8 +165,8 @@ module Kalc
         })
 
         env.add_function(:FIXED, lambda { |cxt, val, decimal_places, no_commas|
-          output = "%.#{Integer(decimal_places.eval(cxt))}f" % BigDecimal.new(val.eval(cxt))
-          output = output.to_s.reverse.scan(/(?:\d*\.)?\d{1,3}-?/).join(',').reverse if !no_commas.eval(cxt)
+          output = format("%.#{Integer(decimal_places.eval(cxt))}f", BigDecimal(val.eval(cxt)))
+          output = output.to_s.reverse.scan(/(?:\d*\.)?\d{1,3}-?/).join(',').reverse unless no_commas.eval(cxt)
           output
         })
 
@@ -179,7 +184,6 @@ module Kalc
         })
 
         env.add_function(:MID, lambda { |cxt, val, start_position, number_of_characters|
-
           start = Integer(start_position.eval(cxt)) - 1
           chars = Integer(number_of_characters.eval(cxt)) - 1
 
@@ -187,7 +191,7 @@ module Kalc
         })
 
         env.add_function(:PROPER, lambda { |cxt, val|
-          val.eval(cxt).split(' ').map { |c| c.capitalize }.join(' ')
+          val.eval(cxt).split(' ').map(&:capitalize).join(' ')
         })
 
         env.add_function(:REPLACE, lambda { |cxt, val, start_position, number_of_chars, new_text|
@@ -242,11 +246,11 @@ module Kalc
         })
 
         # Debug
-        env.add_function(:P, lambda { |cxt, *output|
+        env.add_function(:P, lambda { |_cxt, *output|
           p output
         })
 
-        env.add_function(:PP, lambda { |cxt, *output|
+        env.add_function(:PP, lambda { |_cxt, *output|
           pp output
         })
 
@@ -255,13 +259,18 @@ module Kalc
         })
 
         env.add_function(:FLOOR, lambda { |cxt, val|
-          val.eval(cxt).floor
+          value = val.eval(cxt)
+          return value if value.is_a?(BigDecimal) && (value.nan? || value.infinite?)
+
+          value.floor
         })
 
         env.add_function(:CEILING, lambda { |cxt, val|
-          val.eval(cxt).ceil
-        })
+          value = val.eval(cxt)
+          return value if value.is_a?(BigDecimal) && (value.nan? || value.infinite?)
 
+          value.ceil
+        })
       end
     end
 

data/lib/kalc/repl.rb

@@ -18,27 +18,26 @@ module Kalc
       puts 'You are ready to go.  Have fun!'
       puts ''
 
-      function_list = %w(quit exit functions variables ast) + @kalc.interpreter.env.functions.map { |f| f.first }
+      function_list = %w[quit exit functions variables ast] + @kalc.interpreter.env.functions.map(&:first)
 
       begin
         comp = proc { |s| function_list.grep(/^#{Regexp.escape(s)}/) }
         Readline.completion_append_character = ''
         Readline.completion_proc = comp
 
-        while input = Readline.readline("kalc-#{Kalc::VERSION} > ", true)
+        while (input = Readline.readline("kalc-#{Kalc::VERSION} > ", true))
           begin
-            case
-            when (input == 'quit' || input == 'exit')
+            if input == 'quit' || input == 'exit'
               break
-            when input == 'functions'
-              puts @kalc.interpreter.env.functions.map { |f| f.first }.join(', ')
-            when input == 'variables'
+            elsif input == 'functions'
+              puts @kalc.interpreter.env.functions.map(&:first).join(', ')
+            elsif input == 'variables'
               puts @kalc.interpreter.env.variables.map { |v| "#{v[0]} = #{v[1]}" }.join("\n\r")
-            when input == 'reload'
+            elsif input == 'reload'
               load_env
-            when input == 'ast'
+            elsif input == 'ast'
               pp @kalc.ast
-            when input != ''
+            elsif input != ''
               puts @kalc.run(input)
             end
           rescue Parslet::ParseFailed => e
@@ -55,12 +54,12 @@ module Kalc
     end
 
     def heading
-      %q{
+      '
         This is Kalc, a small line-based language.
         More information about Kalc can be found at https://github.com/mrcsparker/kalc.
 
         Kalc is free software, provided as is, with no warranty.
-      }
+      '
     end
   end
 end

data/lib/kalc/transform.rb

@@ -1,116 +1,115 @@
 module Kalc
   class Transform < Parslet::Transform
-
-    rule(:condition => subtree(:condition)) {
+    rule(condition: subtree(:condition)) do
       condition
-    }
+    end
 
-    rule(:right => subtree(:right), :ops => []) {
+    rule(right: subtree(:right), ops: []) do
       right
-    }
+    end
 
-    rule(:left => subtree(:left), :non_ops => []) {
+    rule(left: subtree(:left), non_ops: []) do
       left
-    }
+    end
 
-    rule(:right => subtree(:right), :non_ops => []) {
+    rule(right: subtree(:right), non_ops: []) do
       right
-    }
+    end
 
-    rule(:commands => sequence(:commands)) {
+    rule(commands: sequence(:commands)) do
       Ast::Commands.new(commands)
-    }
+    end
 
-    rule(:commands => simple(:commands)) {
+    rule(commands: simple(:commands)) do
       Ast::Commands.new([commands])
-    }
+    end
 
-    rule(:negative => simple(:negative)) {
+    rule(negative: simple(:negative)) do
       Ast::Negative.new(negative)
-    }
+    end
 
-    rule(:positive => simple(:positive)) {
+    rule(positive: simple(:positive)) do
       Ast::Positive.new(positive)
-    }
+    end
 
-    rule(:expressions => sequence(:expressions)) {
+    rule(expressions: sequence(:expressions)) do
       Ast::Expressions.new(expressions)
-    }
+    end
 
-    rule(:expressions => simple(:expressions)) {
+    rule(expressions: simple(:expressions)) do
       Ast::Expressions.new([expressions])
-    }
+    end
 
-    rule(:string => simple(:string)) {
+    rule(string: simple(:string)) do
       Ast::StringValue.new(string)
-    }
+    end
 
-    rule(:string => sequence(:string)) {
-      string = '' if string == nil
+    rule(string: sequence(:string)) do
+      string = '' if string.nil?
       Ast::StringValue.new(string)
-    }
+    end
 
-    rule(:boolean => simple(:boolean)) {
+    rule(boolean: simple(:boolean)) do
       Ast::BooleanValue.new(boolean)
-    }
+    end
 
-    rule(:number => simple(:number)) {
+    rule(number: simple(:number)) do
       Ast::BigDecimalNumber.new(number)
-    }
+    end
 
-    rule(:non_ops => subtree(:non_ops)) {
+    rule(non_ops: subtree(:non_ops)) do
       Ast::NonOps.new(non_ops)
-    }
+    end
 
-    rule(:left => simple(:left), :ops => subtree(:ops)) {
+    rule(left: simple(:left), ops: subtree(:ops)) do
       ops.empty? ? left : Ast::Ops.new(left, ops)
-    }
+    end
 
-    rule(:left => simple(:left), :right => simple(:right), :operator => simple(:operator)) {
+    rule(left: simple(:left), right: simple(:right), operator: simple(:operator)) do
       Ast::Arithmetic.new(left, right, operator)
-    }
+    end
 
-    rule(:condition => simple(:condition), :true_cond => simple(:true_cond), :false_cond => simple(:false_cond)) {
+    rule(condition: simple(:condition), true_cond: simple(:true_cond), false_cond: simple(:false_cond)) do
       Ast::Conditional.new(condition, true_cond, false_cond)
-    }
+    end
 
-    rule(:variable => simple(:variable)) {
+    rule(variable: simple(:variable)) do
       Ast::Variable.new(variable)
-    }
+    end
 
-    rule(:identifier => simple(:identifier)) {
+    rule(identifier: simple(:identifier)) do
       identifier
-    }
+    end
 
-    rule(:assign => {:value => simple(:value), :identifier => simple(:identifier), :operator => simple(:operator)}) {
+    rule(assign: { value: simple(:value), identifier: simple(:identifier), operator: simple(:operator) }) do
       Ast::Identifier.new(identifier, value)
-    }
+    end
 
-    rule(:paren_list => sequence(:paren_list)) {
+    rule(paren_list: sequence(:paren_list)) do
       paren_list
-    }
+    end
 
-    rule(:paren_list => '()') {
+    rule(paren_list: '()') do
       []
-    }
+    end
 
-    rule(:paren_expression => simple(:paren_expression)) {
+    rule(paren_expression: simple(:paren_expression)) do
       Ast::ParenExpression.new(paren_expression)
-    }
+    end
 
-    rule(:function_call => {:name => simple(:name),
-                            :variable_list => sequence(:variable_list)}) {
+    rule(function_call: { name: simple(:name),
+                          variable_list: sequence(:variable_list) }) do
       Ast::FunctionCall.new(name, variable_list)
-    }
+    end
 
-    rule(:argument => simple(:argument)) {
+    rule(argument: simple(:argument)) do
       Ast::Identifier.new(argument, argument)
-    }
+    end
 
-    rule(:function_definition => {:name => simple(:name),
-                                  :argument_list => sequence(:argument_list),
-                                  :body => simple(:body)}) {
+    rule(function_definition: { name: simple(:name),
+                                argument_list: sequence(:argument_list),
+                                body: simple(:body) }) do
       Ast::FunctionDefinition.new(name, argument_list, body)
-    }
+    end
   end
 end

data/lib/kalc/version.rb

@@ -1,3 +1,3 @@
 module Kalc
-  VERSION = '1.2.0'
+  VERSION = '1.7.0'.freeze
 end

data/spec/grammar_spec.rb

@@ -5,7 +5,7 @@ describe Kalc::Grammar do
 
   context 'integers' do
     1.upto(10) do |i|
-      it { expect(grammar).to parse("#{i}") }
+      it { expect(grammar).to parse(i.to_s) }
     end
   end
 

data/spec/interpreter_spec.rb

@@ -44,7 +44,7 @@ describe Kalc::Interpreter do
     expect(evaluate("'a b' := 1; 'a b' + 1")).to eq(2)
   end
 
-  it { expect(evaluate('((75.0)*(25.0))+((125.0)*(25.0))+((150.0)*(25.0))+((250.0)*(25.0))')).to eq(15000) }
+  it { expect(evaluate('((75.0)*(25.0))+((125.0)*(25.0))+((150.0)*(25.0))+((250.0)*(25.0))')).to eq(15_000) }
 
   it { expect(evaluate('(((40.0)/1000*(4380.0)*(200.0))-((40.0)/1000*(4380.0)*((((75.0)*(25.0))+((125.0)*(25.0))+((150.0)*(25.0))+((250.0)*(25.0)))/(10.0)/(40.0)/(0.8))))*(0.05)')).to eq(1341.375) }
 
@@ -52,21 +52,21 @@ describe Kalc::Interpreter do
     it { expect(evaluate('-2')).to eq(-2) }
     it { expect(evaluate('-1000')).to eq(-1000) }
     it { expect(evaluate('-1000.0001')).to eq(-1000.0001) }
-    it { expect(evaluate('1 + -1')).to eq(0 )}
+    it { expect(evaluate('1 + -1')).to eq(0) }
     it { expect(evaluate('1 + -10')).to eq(-9) }
   end
 
   context 'Positive numbers' do
     it { expect(evaluate('1 + +1')).to eq(2) }
     it { expect(evaluate('1 + +1 - 1')).to eq(1) }
-    it { expect(evaluate('+10000.0001')).to eq(10000.0001) }
+    it { expect(evaluate('+10000.0001')).to eq(10_000.0001) }
   end
 
   context 'Boolean value' do
     it { expect(evaluate('TRUE')).to eq(true) }
     it { expect(evaluate('FALSE')).to eq(false) }
     it { expect(evaluate('FALSE || TRUE')).to eq(true) }
-    it { expect(evaluate('FALSE && TRUE')).to  eq(false) }
+    it { expect(evaluate('FALSE && TRUE')).to eq(false) }
   end
 
   context 'Decimal numbers' do
@@ -84,7 +84,7 @@ describe Kalc::Interpreter do
   end
 
   context 'Exponents' do
-    it { expect(evaluate('1.23e+10')).to eq(12300000000.0) }
+    it { expect(evaluate('1.23e+10')).to eq(12_300_000_000.0) }
     it { expect(evaluate('1.23e-10')).to eq(1.23e-10) }
   end
 
@@ -96,8 +96,12 @@ describe Kalc::Interpreter do
   context 'Min and Max Functions' do
     it { expect(evaluate('MAX(3, 1, 2)')).to eq(3) }
     it { expect(evaluate('MAX(-1, 2*4, (3-1)*2, 5, 6)')).to eq(8) }
+    it { expect(evaluate('MAX(0/0, 2)').to_s).to eq('NaN') }
+    it { expect(evaluate('MAX(1/0, 3)').to_s).to eq('Infinity') }
     it { expect(evaluate('MIN(3, 1, 2)')).to eq(1) }
     it { expect(evaluate('MIN(-1, 2*4, (3-1)*2, 5, 6)')).to eq(-1) }
+    it { expect(evaluate('MIN(0/0, 2)').to_s).to eq('NaN') }
+    it { expect(evaluate('MIN(-1/0, 3)').to_s).to eq('-Infinity') }
     context 'having variables' do
       it { expect(evaluate('var := 15; MAX(1, var, 10)')).to eq(15) }
       it { expect(evaluate('var := 15; MIN(1, var, -10)')).to eq(-10) }
@@ -109,10 +113,14 @@ describe Kalc::Interpreter do
     it { expect(evaluate('FLOOR(3.8)')).to eq(3) }
     it { expect(evaluate('FLOOR(-3.4)')).to eq(-4) }
     it { expect(evaluate('FLOOR(3)')).to eq(3) }
+    it { expect(evaluate('FLOOR(0/0)').to_s).to eq('NaN') }
+    it { expect(evaluate('FLOOR(1/0)').to_s).to eq('Infinity') }
     it { expect(evaluate('CEILING(3)')).to eq(3) }
     it { expect(evaluate('CEILING(3.8)')).to eq(4) }
     it { expect(evaluate('CEILING(3.8)')).to eq(4) }
     it { expect(evaluate('CEILING(-3.2)')).to eq(-3) }
+    it { expect(evaluate('CEILING(0/0)').to_s).to eq('NaN') }
+    it { expect(evaluate('CEILING(1/0)').to_s).to eq('Infinity') }
 
     context 'having variables' do
       it { expect(evaluate('var := 2.456; FLOOR(var)')).to eq(2) }
@@ -135,6 +143,7 @@ describe Kalc::Interpreter do
   end
 
   private
+
   def evaluate(expression)
     g = @grammar.parse(expression)
     ast = @transform.apply(g)

data/spec/stdlib_spec.rb

@@ -1,11 +1,9 @@
 require 'spec_helper'
 
 class Kalc::Stdlib
-
 end
 
 describe Kalc::Stdlib do
-
   before(:each) do
     @grammar = Kalc::Grammar.new
     @transform = Kalc::Transform.new
@@ -51,6 +49,7 @@ describe Kalc::Stdlib do
   end
 
   private
+
   def evaluate(expression)
     r = Kalc::Runner.new
     r.run(expression)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kalc
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Chris Parker
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-08 00:00:00.000000000 Z
+date: 2018-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: 1.8.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: 1.8.2
 description: Calculation language slightly based on Excel's formula language.
 email:
 - mrcsparker@gmail.com
@@ -103,13 +103,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: kalc
-rubygems_version: 2.6.4
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Small calculation language.
-test_files:
-- spec/grammar_spec.rb
-- spec/interpreter_spec.rb
-- spec/spec_helper.rb
-- spec/stdlib_spec.rb
-has_rdoc: 
+test_files: []