keisan 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 900d86c9daad1cab75e6140a21785f6de67ead1c
-  data.tar.gz: f2c5f2abc85d46ce71aa651f0cc860363a8790bf
+SHA256:
+  metadata.gz: f2d556d5ef3e67015596fee5856e2fe0b27295b227f7d4edf8cb41c037aed98b
+  data.tar.gz: c8c20ac6ba6a9ad27654931238a2dbafcbbbc509b58fd2a74161b7a38b3edaab
 SHA512:
-  metadata.gz: 4f5e7ea1fd844e7927af6eb5b66edacc53dac30541cb670d6208e43d0a9edb4611417943be232ba8188c275fa8890ee3c3e7f43a874ae32085f80b05092ecef6
-  data.tar.gz: 588daa93a53120d0456f38e66f5fa27d50b5e517516c3e0747519e51aeb5ca49dc317187e85ec420e5eec5bc722732138499e16188bf7271afbc4481ba1980bd
+  metadata.gz: 9ccc5172adc0b5ebafabe3cd5846fb455ada6e1351c94deab4da5bfd38617c0e0692258e9384d760d25b88a899b46de1899b1688850bfac8ddcdd432091ddf50
+  data.tar.gz: cb2ca195319a744f3ee9b56ef7df14d8dfcf36dbcafcbe1e675a858f232457d39cb3fe96d7f056a26746630d4a7f1c47a8fe6fc75a880683cd2120428a448ff6

data/.travis.yml

@@ -1,6 +1,7 @@
 sudo: false
 language: ruby
 rvm:
-  - 2.3.5
-  - 2.4.2
-before_install: gem install bundler -v 1.16.0
+  - 2.3.6
+  - 2.4.3
+  - 2.5.0
+before_install: gem install bundler -v 1.16.1

data/README.md

@@ -9,7 +9,7 @@
 
 Keisan ([計算, to calculate](https://en.wiktionary.org/wiki/%E8%A8%88%E7%AE%97#Japanese)) is a Ruby library for parsing equations into an abstract syntax tree.
 This allows for safe evaluation of string representations of mathematical/logical expressions.
-It has support for variables, functions, conditionals, and loops, making it a Turing complete programming language.
+It has support for variables, functions, conditionals, and loops, making it a [Turing complete](https://github.com/project-eutopia/keisan/blob/master/spec/keisan/turing_machine_spec.rb) programming language.
 
 ## Installation
 
@@ -119,6 +119,9 @@ calculator.evaluate("f(0-a)", a: 2)
 #=> -20
 calculator.evaluate("n") # n only exists in the definition of f(x)
 #=> Keisan::Exceptions::UndefinedVariableError: n
+calculator.evaluate("includes(a, element) = a.reduce(false, found, x, found || (x == element))")
+calculator.evaluate("[3, 9].map(x, [1, 3, 5].includes(x))").value
+#=> [true, false]
 ```
 
 This form even supports recursion, but you must explicitly allow it.
@@ -248,6 +251,36 @@ calculator.evaluate("range(1, 6).map(x, [x, x**2]).to_h")
 #=> {1 => 1, 2 => 4, 3 => 9, 4 => 16, 5 => 25}
 ```
 
+##### Date and time objects
+
+Keisan supports date and time objects like in Ruby.
+You create a date object using either the method `date` (either a string to be parsed, or year, month, day numerical arguments) or `today`.
+They support methods `year`, `month`, `day`, `weekday`, `strftime`, and `to_time` to convert to a time object.
+
+```ruby
+calculator = Keisan::Calculator.new
+calculator.evaluate("x = 11")
+calculator.evaluate("(5 + date(2018, x, 2*x)).day")
+#=> 27
+calculator.evaluate("today() > date(2018, 11, 1)")
+#=> true
+calculator.evaluate("date('1999-12-31').to_time + 10")
+#=> Time.new(1999, 12, 31, 0, 0, 10)
+```
+
+Time objects are created using `time` (either a string to be parsed, or year, month, day, hour, minute, second arguments) or `now`.
+They support methods `year`, `month`, `day`, `hour`, `minute`, `second`, `weekday`, `strftime`, and `to_date` to convert to a date object.
+
+```ruby
+calculator = Keisan::Calculator.new
+calculator.evaluate("time(2018, 11, 22, 12, 0, 0).to_date <= date(2018, 11, 22)")
+#=> true
+calculator.evaluate("time('2000-4-15 12:34:56').minute")
+#=> 34
+calculator.evaluate("time('5000-10-10 20:30:40').strftime('%b %d, %Y')")
+#=> "Oct 10, 5000"
+```
+
 ##### Functional programming methods
 
 Keisan also supports the basic functional programming operators `map` (or `collect`), `filter` (or `select`), and `reduce` (or `inject`).
@@ -293,12 +326,16 @@ calculator.evaluate("2 + if(1 > 0, 10, 29)")
 ```
 
 For looping, you can use the basic `while` loop, which has an expression that evaluates to a boolean as the first argument, and any expression in the second argument.
+One can use the keywords `break` and `continue` to control loop flow as well.
 
 ```ruby
 calculator = Keisan::Calculator.new
 calculator.evaluate("my_sum(a) = {let i = 0; let total = 0; while(i < a.size, {total += a[i]; i += 1}); total}")
 calculator.evaluate("my_sum([1,3,5,7,9])")
 #=> 25
+calculator.evaluate("has_element(a, x) = {let i=0; let found=false; while(i<a.size, if(a[i] == x, found = true; break); i+=1); found}")
+calculator.evaluate("[2, 3, 7, 11].has_element(11)")
+#=> true
 ```
 
 ##### Bitwise operations
@@ -368,7 +405,7 @@ calculator.evaluate("log10(1000)")
 #=> 3.0
 ```
 
-Furthermore, the constants `PI`, `E`, and `I` are included.
+Furthermore, the constants `PI`, `E`, `I`, and `INF` are included.
 
 ```ruby
 calculator = Keisan::Calculator.new

data/keisan.gemspec

@@ -19,9 +19,7 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = ">= 2.0.0"
-
-  spec.add_dependency "activesupport", ">= 4.2.2"
+  spec.required_ruby_version = ">= 2.3.0"
 
   spec.add_development_dependency "coveralls"
   spec.add_development_dependency "bundler", "~> 1.14"

data/lib/keisan.rb

@@ -1,8 +1,6 @@
-require "active_support"
-require "active_support/core_ext"
-
 require "keisan/version"
 require "keisan/exceptions"
+require "keisan/util"
 
 require "keisan/ast/node"
 require "keisan/ast/cell"
@@ -14,6 +12,8 @@ require "keisan/ast/number"
 require "keisan/ast/string"
 require "keisan/ast/null"
 require "keisan/ast/boolean"
+require "keisan/ast/date"
+require "keisan/ast/time"
 
 require "keisan/ast/block"
 require "keisan/ast/parent"

data/lib/keisan/ast.rb

@@ -1,3 +1,6 @@
+require "date"
+require "time"
+
 module Keisan
   module AST
     def self.parse(expression)
@@ -76,6 +79,26 @@ module KeisanHash
   end
 end
 
+module KeisanDate
+  def to_node
+    Keisan::AST::Date.new(self)
+  end
+
+  def value(context = nil)
+    self
+  end
+end
+
+module KeisanTime
+  def to_node
+    Keisan::AST::Time.new(self)
+  end
+
+  def value(context = nil)
+    self
+  end
+end
+
 class Numeric; prepend KeisanNumeric; end
 class String; prepend KeisanString; end
 class TrueClass; prepend KeisanTrueClass; end
@@ -83,3 +106,5 @@ class FalseClass; prepend KeisanFalseClass; end
 class NilClass; prepend KeisanNilClass; end
 class Array; prepend KeisanArray; end
 class Hash; prepend KeisanHash; end
+class Date; prepend KeisanDate; end
+class Time; prepend KeisanTime; end

data/lib/keisan/ast/boolean.rb

@@ -12,7 +12,7 @@ module Keisan
       end
 
       def true?
-        false
+        bool
       end
 
       def !

data/lib/keisan/ast/builder.rb

@@ -12,10 +12,10 @@ module Keisan
         elsif !parser.nil?
           @components = parser.components
         else
-          @components = Array.wrap(components)
+          @components = Array(components)
         end
 
-        @lines = @components.split {|component|
+        @lines = Util.array_split(@components) {|component|
           component.is_a?(Parsing::LineSeparator)
         }.reject(&:empty?)
 

data/lib/keisan/ast/cell.rb

@@ -72,6 +72,12 @@ module Keisan
       def to_node
         node
       end
+
+      %i(< <= > >= equal not_equal).each do |sym|
+        define_method(sym) {|other|
+          node.send(sym, other.to_node)
+        }
+      end
     end
   end
 end

data/lib/keisan/ast/date.rb

@@ -0,0 +1,23 @@
+require_relative "date_time_methods"
+
+module Keisan
+  module AST
+    class Date < ConstantLiteral
+      include DateTimeMethods
+
+      attr_reader :date
+
+      def initialize(date)
+        @date = date
+      end
+
+      def value(context = nil)
+        date
+      end
+
+      def to_s
+        value.to_s
+      end
+    end
+  end
+end

data/lib/keisan/ast/date_time_methods.rb

@@ -0,0 +1,75 @@
+module Keisan
+  module AST
+    module DateTimeMethods
+      def +(other)
+        other = other.to_node
+        case other
+        when Number
+          self.class.new(value + other.value)
+        else
+          super
+        end
+      end
+
+      def >(other)
+        other = other.to_node
+        case other
+        when self.class
+          Boolean.new(value.to_time > other.value.to_time)
+        else
+          super
+        end
+      end
+
+      def <(other)
+        other = other.to_node
+        case other
+        when self.class
+          Boolean.new(value.to_time < other.value.to_time)
+        else
+          super
+        end
+      end
+
+      def >=(other)
+        other = other.to_node
+        case other
+        when self.class
+          Boolean.new(value.to_time >= other.value.to_time)
+        else
+          super
+        end
+      end
+
+      def <=(other)
+        other = other.to_node
+        case other
+        when self.class
+          Boolean.new(value.to_time <= other.value.to_time)
+        else
+          super
+        end
+      end
+
+      def equal(other)
+        other = other.to_node
+        case other
+        when self.class
+          Boolean.new(value.to_time == other.value.to_time)
+        else
+          super
+        end
+      end
+
+      def not_equal(other)
+        other = other.to_node
+        case other
+        when self.class
+          Boolean.new(value.to_time != other.value.to_time)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/keisan/ast/function.rb

@@ -13,6 +13,15 @@ module Keisan
         function_from_context(context).value(self, context)
       end
 
+      def unbound_variables(context = nil)
+        context ||= Context.new
+        if context.has_function?(name)
+          function_from_context(context).unbound_variables(children, context)
+        else
+          super
+        end
+      end
+
       def unbound_functions(context = nil)
         context ||= Context.new
 

data/lib/keisan/ast/logical_and.rb

@@ -5,18 +5,35 @@ module Keisan
         :"&&"
       end
 
+      def blank_value
+        true
+      end
+
       def evaluate(context = nil)
-        children[0].evaluate(context).and(children[1].evaluate(context))
+        short_circuit_do(:evaluate, context)
       end
 
-      def blank_value
-        true
+      def simplify(context = nil)
+        short_circuit_do(:simplify, context)
       end
 
       def value(context = nil)
         context ||= Context.new
         children[0].value(context) && children[1].value(context)
       end
+
+      private
+
+      def short_circuit_do(method, context)
+        context ||= Context.new
+        lhs = children[0].send(method, context)
+        case lhs
+        when AST::Boolean
+          lhs.false? ? AST::Boolean.new(false) : children[1].send(method, context)
+        else
+          lhs.and(children[1].send(method, context))
+        end
+      end
     end
   end
 end

data/lib/keisan/ast/logical_equal.rb

@@ -5,13 +5,14 @@ module Keisan
         :"=="
       end
 
-      def evaluate(context = nil)
-        children[0].evaluate(context).equal(children[1].evaluate(context))
+      protected
+
+      def value_operator
+        :==
       end
 
-      def value(context=nil)
-        context ||= Context.new
-        children[0].value(context) == children[1].value(context)
+      def operator
+        :equal
       end
     end
   end

data/lib/keisan/ast/logical_greater_than.rb

@@ -5,12 +5,14 @@ module Keisan
         :">"
       end
 
-      def evaluate(context = nil)
-        children[0].evaluate(context) > children[1].evaluate(context)
+      protected
+
+      def value_operator
+        :>
       end
 
-      def value(context = nil)
-        children.first.value(context) > children.last.value(context)
+      def operator
+        :>
       end
     end
   end

data/lib/keisan/ast/logical_greater_than_or_equal_to.rb

@@ -5,12 +5,14 @@ module Keisan
         :">="
       end
 
-      def evaluate(context = nil)
-        children[0].evaluate(context) >= children[1].evaluate(context)
+      protected
+
+      def value_operator
+        :>=
       end
 
-      def value(context = nil)
-        children.first.value(context) >= children.last.value(context)
+      def operator
+        :>=
       end
     end
   end

data/lib/keisan/ast/logical_less_than.rb

@@ -5,12 +5,14 @@ module Keisan
         :"<"
       end
 
-      def evaluate(context = nil)
-        children[0].evaluate(context) < children[1].evaluate(context)
+      protected
+
+      def value_operator
+        :<
       end
 
-      def value(context = nil)
-        children.first.value(context) < children.last.value(context)
+      def operator
+        :<
       end
     end
   end

data/lib/keisan/ast/logical_less_than_or_equal_to.rb

@@ -5,12 +5,14 @@ module Keisan
         :"<="
       end
 
-      def evaluate(context = nil)
-        children[0].evaluate(context) <= children[1].evaluate(context)
+      protected
+
+      def value_operator
+        :<=
       end
 
-      def value(context = nil)
-        children.first.value(context) <= children.last.value(context)
+      def operator
+        :<=
       end
     end
   end

data/lib/keisan/ast/logical_not_equal.rb

@@ -5,13 +5,14 @@ module Keisan
         :"!="
       end
 
-      def evaluate(context = nil)
-        children[0].evaluate(context).not_equal(children[1].evaluate(context))
+      protected
+
+      def value_operator
+        :!=
       end
 
-      def value(context=nil)
-        context ||= Context.new
-        children[0].value(context) != children[1].value(context)
+      def operator
+        :not_equal
       end
     end
   end

data/lib/keisan/ast/logical_operator.rb

@@ -1,6 +1,30 @@
 module Keisan
   module AST
     class LogicalOperator < Operator
+      def evaluate(context = nil)
+        context ||= Context.new
+        children[0].evaluate(context).send(operator, children[1].evaluate(context))
+      end
+
+      def simplify(context = nil)
+        context ||= Context.new
+        children[0].simplify(context).send(operator, children[1].simplify(context))
+      end
+
+      def value(context=nil)
+        context ||= Context.new
+        children[0].value(context).send(value_operator, children[1].value(context))
+      end
+
+      protected
+
+      def value_operator
+        raise Exceptions::NotImplementedError.new
+      end
+
+      def operator
+        raise Exceptions::NotImplementedError.new
+      end
     end
   end
 end

data/lib/keisan/ast/logical_or.rb

@@ -10,13 +10,30 @@ module Keisan
       end
 
       def evaluate(context = nil)
-        children[0].evaluate(context).or(children[1].evaluate(context))
+        short_circuit_do(:evaluate, context)
+      end
+
+      def simplify(context = nil)
+        short_circuit_do(:simplify, context)
       end
 
       def value(context = nil)
         context ||= Context.new
         children[0].value(context) || children[1].value(context)
       end
+
+      private
+
+      def short_circuit_do(method, context)
+        context ||= Context.new
+        lhs = children[0].send(method, context)
+        case lhs
+        when AST::Boolean
+          lhs.true? ? AST::Boolean.new(true) : children[1].send(method, context)
+        else
+          lhs.or(children[1].send(method, context))
+        end
+      end
     end
   end
 end

data/lib/keisan/ast/number.rb

@@ -24,6 +24,10 @@ module Keisan
         case other
         when Number
           Number.new(value + other.value)
+        when Date
+          Date.new(other.value + value)
+        when Time
+          Time.new(other.value + value)
         else
           super
         end

data/lib/keisan/ast/operator.rb

@@ -41,7 +41,7 @@ module Keisan
           raise Exceptions::ASTError.new("Mismatch of children and operators")
         end
 
-        children = Array.wrap(children)
+        children = Array(children)
         super(children)
 
         @parsing_operators = parsing_operators

data/lib/keisan/ast/parent.rb

@@ -4,7 +4,7 @@ module Keisan
       attr_reader :children
 
       def initialize(children = [])
-        children = Array.wrap(children).map do |child|
+        children = Array(children).map do |child|
           child.is_a?(Cell) ? child : child.to_node
         end
         raise Exceptions::InternalError.new unless children.is_a?(Array)

data/lib/keisan/ast/plus.rb

@@ -22,6 +22,10 @@ module Keisan
         # Special case of array concatenation
         elsif children_values.all? {|child| child.is_a?(::Array)}
           children_values.inject([], &:+)
+        elsif children_values.one? {|child| child.is_a?(::Date)}
+          date_time_plus(children_values, ::Date)
+        elsif children_values.one? {|child| child.is_a?(::Time)}
+          date_time_plus(children_values, ::Time)
         else
           children_values.inject(0, &:+)
         end.to_node.value(context)
@@ -77,6 +81,12 @@ module Keisan
 
       private
 
+      def date_time_plus(elements, klass)
+        date_time = elements.select {|child| child.is_a?(klass)}.first
+        others = elements.select {|child| !child.is_a?(klass)}
+        date_time + others.inject(0, &:+)
+      end
+
       def convert_minus_to_plus!
         @parsing_operators.each.with_index do |parsing_operator, index|
           if parsing_operator.is_a?(Parsing::Minus)

data/lib/keisan/ast/time.rb

@@ -0,0 +1,23 @@
+require_relative "date_time_methods"
+
+module Keisan
+  module AST
+    class Time < ConstantLiteral
+      include DateTimeMethods
+
+      attr_reader :time
+
+      def initialize(time)
+        @time = time
+      end
+
+      def value(context = nil)
+        time
+      end
+
+      def to_s
+        value.strftime("%Y-%m-%d %H:%M:%S")
+      end
+    end
+  end
+end

data/lib/keisan/ast/unary_operator.rb

@@ -2,7 +2,7 @@ module Keisan
   module AST
     class UnaryOperator < Operator
       def initialize(children = [])
-        children = Array.wrap(children)
+        children = Array(children)
         super(children)
         if children.count != 1
           raise Exceptions::ASTError.new("Unary operator takes has a single child")

data/lib/keisan/ast/variable.rb

@@ -60,11 +60,8 @@ module Keisan
       end
 
       def replace(variable, replacement)
-        if name == variable.name
-          replacement
-        else
-          self
-        end
+        to_replace_name = variable.is_a?(::String) ? variable : variable.name
+        name == to_replace_name ? replacement : self
       end
 
       def differentiate(variable, context = nil)

data/lib/keisan/context.rb

@@ -4,8 +4,8 @@ module Keisan
 
     def initialize(parent: nil, random: nil, allow_recursive: false, shadowed: [])
       @parent = parent
-      @function_registry = Functions::Registry.new(parent: @parent.try(:function_registry))
-      @variable_registry = Variables::Registry.new(parent: @parent.try(:variable_registry), shadowed: shadowed)
+      @function_registry = Functions::Registry.new(parent: @parent&.function_registry)
+      @variable_registry = Variables::Registry.new(parent: @parent&.variable_registry, shadowed: shadowed)
       @random            = random
       @allow_recursive   = allow_recursive
     end
@@ -47,7 +47,7 @@ module Keisan
 
     def transient_definitions
       return {} unless @transient
-      parent_definitions = @parent.present? ? @parent.transient_definitions : {}
+      parent_definitions = @parent.nil? ? {} : @parent.transient_definitions
       parent_definitions.merge(
         @variable_registry.locals
       ).merge(
@@ -73,7 +73,7 @@ module Keisan
 
     def register_variable!(name, value, local: false)
       if !@variable_registry.shadowed.member?(name) && (transient? || !local && @parent&.variable_is_modifiable?(name))
-        @parent.register_variable!(name, value)
+        @parent.register_variable!(name, value, local: local)
       else
         @variable_registry.register!(name, value)
       end
@@ -93,14 +93,14 @@ module Keisan
 
     def register_function!(name, function, local: false)
       if transient? || !local && @parent&.function_is_modifiable?(name)
-        @parent.register_function!(name, function)
+        @parent.register_function!(name, function, local: local)
       else
         @function_registry.register!(name.to_s, function)
       end
     end
 
     def random
-      @random || @parent.try(:random) || Random.new
+      @random || @parent&.random || Random.new
     end
 
     protected

data/lib/keisan/exceptions.rb

@@ -18,5 +18,8 @@ module Keisan
     class InvalidExpression < StandardError; end
     class TypeError < StandardError; end
     class NonDifferentiableError < StandardError; end
+
+    class BreakError < StandardError; end
+    class ContinueError < StandardError; end
   end
 end

data/lib/keisan/function.rb

@@ -23,6 +23,12 @@ module Keisan
       raise Exceptions::NotImplementedError.new
     end
 
+    def unbound_variables(children, context)
+      children.inject(Set.new) do |vars, child|
+        vars | child.unbound_variables(context)
+      end
+    end
+
     protected
 
     def validate_arguments!(count)

data/lib/keisan/functions/break.rb

@@ -0,0 +1,11 @@
+require_relative "loop_control_flow_function"
+
+module Keisan
+  module Functions
+    class Break < LoopControlFlowFuntion
+      def initialize
+        super("break", Exceptions::BreakError)
+      end
+    end
+  end
+end

data/lib/keisan/functions/continue.rb

@@ -0,0 +1,11 @@
+require_relative "loop_control_flow_function"
+
+module Keisan
+  module Functions
+    class Continue < LoopControlFlowFuntion
+      def initialize
+        super("continue", Exceptions::ContinueError)
+      end
+    end
+  end
+end

data/lib/keisan/functions/default_registry.rb

@@ -1,5 +1,7 @@
 require_relative "let"
 require_relative "puts"
+require_relative "break"
+require_relative "continue"
 
 require_relative "if"
 require_relative "while"
@@ -49,6 +51,8 @@ module Keisan
       def self.register_defaults!(registry)
         registry.register!(:let, Let.new, force: true)
         registry.register!(:puts, Puts.new, force: true)
+        registry.register!(:break, Break.new, force: true)
+        registry.register!(:continue, Continue.new, force: true)
 
         registry.register!(:if, If.new, force: true)
         registry.register!(:while, While.new, force: true)
@@ -65,6 +69,7 @@ module Keisan
         register_math!(registry)
         register_array_methods!(registry)
         register_random_methods!(registry)
+        register_date_time_methods!(registry)
       end
 
       def self.register_math!(registry)
@@ -124,6 +129,37 @@ module Keisan
         registry.register!(:rand, Rand.new, force: true)
         registry.register!(:sample, Sample.new, force: true)
       end
+
+      def self.register_date_time_methods!(registry)
+        register_date_time!(registry)
+
+        registry.register!(:today, Proc.new { ::Date.today }, force: true)
+        registry.register!(:day,  Proc.new {|d| d.mday }, force: true)
+        registry.register!(:weekday,  Proc.new {|d| d.wday }, force: true)
+        registry.register!(:month, Proc.new {|d| d.month }, force: true)
+        registry.register!(:year,  Proc.new {|d| d.year }, force: true)
+
+        registry.register!(:now, Proc.new { ::Time.now }, force: true)
+        registry.register!(:hour,  Proc.new {|t| t.hour }, force: true)
+        registry.register!(:minute,  Proc.new {|t| t.min }, force: true)
+        registry.register!(:second, Proc.new {|t| t.sec }, force: true)
+        registry.register!(:strftime, Proc.new {|*args| args.first.strftime(*args[1..-1]) }, force: true)
+
+        registry.register!(:to_time, Proc.new {|d| d.to_time }, force: true)
+        registry.register!(:to_date, Proc.new {|t| t.to_date }, force: true)
+      end
+
+      def self.register_date_time!(registry)
+        [::Date, ::Time].each do |klass|
+          registry.register!(klass.to_s.downcase.to_sym, Proc.new {|*args|
+            if args.count == 1 && args.first.is_a?(::String)
+              AST.const_get(klass.to_s).new(klass.parse(args.first))
+            else
+              AST.const_get(klass.to_s).new(klass.new(*args))
+            end
+          }, force: true)
+        end
+      end
     end
   end
 end

data/lib/keisan/functions/enumerable_function.rb

@@ -12,6 +12,10 @@ module Keisan
         evaluate(ast_function, context)
       end
 
+      def unbound_variables(children, context)
+        super - Set.new(shadowing_variable_names(children).map(&:name))
+      end
+
       def evaluate(ast_function, context = nil)
         validate_arguments!(ast_function.children.count)
         context ||= Context.new
@@ -20,9 +24,9 @@ module Keisan
 
         case operand
         when AST::List
-          evaluate_list(operand, arguments, expression, context)
+          evaluate_list(operand, arguments, expression, context).evaluate(context)
         when AST::Hash
-          evaluate_hash(operand, arguments, expression, context)
+          evaluate_hash(operand, arguments, expression, context).evaluate(context)
         else
           raise Exceptions::InvalidFunctionError.new("Unhandled first argument to #{name}: #{operand}")
         end
@@ -34,6 +38,10 @@ module Keisan
 
       protected
 
+      def shadowing_variable_names(children)
+        raise Exceptions::NotImplementedError.new
+      end
+
       def verify_arguments!(arguments)
         unless arguments.all? {|argument| argument.is_a?(AST::Variable)}
           raise Exceptions::InvalidFunctionError.new("Middle arguments to #{name} must be variables")

data/lib/keisan/functions/filter.rb

@@ -10,6 +10,12 @@ module Keisan
         super("filter")
       end
 
+      protected
+
+      def shadowing_variable_names(children)
+        children.size == 3 ? children[1..1] : children[1..2]
+      end
+
       private
 
       def evaluate_list(list, arguments, expression, context)

data/lib/keisan/functions/loop_control_flow_function.rb

@@ -0,0 +1,22 @@
+module Keisan
+  module Functions
+    class LoopControlFlowFuntion < Function
+      def initialize(name, exception_class)
+        super(name, 0)
+        @exception_class = exception_class
+      end
+
+      def value(ast_function, context = nil)
+        raise @exception_class.new
+      end
+
+      def evaluate(ast_function, context = nil)
+        raise @exception_class.new
+      end
+
+      def simplify(ast_function, context = nil)
+        raise @exception_class.new
+      end
+    end
+  end
+end

data/lib/keisan/functions/map.rb

@@ -10,6 +10,12 @@ module Keisan
         super("map")
       end
 
+      protected
+
+      def shadowing_variable_names(children)
+        children.size == 3 ? children[1..1] : children[1..2]
+      end
+
       private
 
       def evaluate_list(list, arguments, expression, context)

data/lib/keisan/functions/reduce.rb

@@ -6,12 +6,17 @@ module Keisan
       # Reduces (list, initial, accumulator, variable, expression)
       # e.g. reduce([1,2,3,4], 0, total, x, total+x)
       # should give 10
+      # When hash: (hash, initial, accumulator, key, value, expression)
       def initialize
         super("reduce")
       end
 
       protected
 
+      def shadowing_variable_names(children)
+        children.size == 5 ? children[2..3] : children[2..4]
+      end
+
       def verify_arguments!(arguments)
         unless arguments[1..-1].all? {|argument| argument.is_a?(AST::Variable)}
           raise Exceptions::InvalidFunctionError.new("Middle arguments to #{name} must be variables")

data/lib/keisan/functions/while.rb

@@ -28,7 +28,13 @@ module Keisan
         current = Keisan::AST::Null.new
 
         while logical_node_evaluates_to_true(logical_node, context)
-          current = body_node.evaluated(context)
+          begin
+            current = body_node.evaluated(context)
+          rescue Exceptions::BreakError
+            break
+          rescue Exceptions::ContinueError
+            next
+          end
         end
 
         current

data/lib/keisan/parser.rb

@@ -1,6 +1,6 @@
 module Keisan
   class Parser
-    KEYWORDS = %w(let puts).freeze
+    KEYWORDS = %w(let puts break continue).freeze
 
     attr_reader :tokens, :components
 
@@ -39,7 +39,7 @@ module Keisan
     end
 
     def parse_multi_line!
-      line_parsers = @tokens.split {|token| token.is_a?(Tokens::LineSeparator)}.map {|tokens| self.class.new(tokens: tokens)}
+      line_parsers = Util.array_split(@tokens) {|token| token.is_a?(Tokens::LineSeparator)}.map {|tokens| self.class.new(tokens: tokens)}
       @components = []
       line_parsers.each.with_index do |line_parser, i|
         @components += line_parser.components
@@ -52,7 +52,7 @@ module Keisan
     def parse_keyword!
       keyword = tokens.first.string
       arguments = if tokens[1].is_a?(Tokens::Group)
-                    tokens[1].sub_tokens.split {|token| token.is_a?(Tokens::Comma)}.map {|argument_tokens|
+                    Util.array_split(tokens[1].sub_tokens) {|token| token.is_a?(Tokens::Comma)}.map {|argument_tokens|
                       Parsing::Argument.new(argument_tokens)
                     }
                   else
@@ -212,7 +212,7 @@ module Keisan
         @components << Parsing::List.new(arguments_from_group(token))
       when :curly
         if token.sub_tokens.any? {|token| token.is_a?(Tokens::Colon)}
-          @components << Parsing::Hash.new(token.sub_tokens.split {|token| token.is_a?(Tokens::Comma)})
+          @components << Parsing::Hash.new(Util.array_split(token.sub_tokens) {|token| token.is_a?(Tokens::Comma)})
         else
           @components << Parsing::CurlyGroup.new(token.sub_tokens)
         end
@@ -280,7 +280,7 @@ module Keisan
       if token.sub_tokens.empty?
         []
       else
-        token.sub_tokens.split {|sub_token| sub_token.is_a?(Tokens::Comma)}.map do |sub_tokens|
+        Util.array_split(token.sub_tokens) {|sub_token| sub_token.is_a?(Tokens::Comma)}.map do |sub_tokens|
           Parsing::Argument.new(sub_tokens)
         end
       end

data/lib/keisan/parsing/function.rb

@@ -5,7 +5,7 @@ module Keisan
 
       def initialize(name, arguments)
         @name = name
-        @arguments = Array.wrap(arguments)
+        @arguments = Array(arguments)
       end
     end
   end

data/lib/keisan/parsing/hash.rb

@@ -4,7 +4,7 @@ module Keisan
       attr_reader :key_value_pairs
 
       def initialize(key_value_pairs)
-        @key_value_pairs = Array.wrap(key_value_pairs).map {|key_value_pair|
+        @key_value_pairs = Array(key_value_pairs).map {|key_value_pair|
           validate_and_extract_key_value_pair(key_value_pair)
         }
       end
@@ -12,7 +12,7 @@ module Keisan
       private
 
       def validate_and_extract_key_value_pair(key_value_pair)
-        key, value = key_value_pair.split {|token| token.is_a?(Tokens::Colon)}
+        key, value = Util.array_split(key_value_pair) {|token| token.is_a?(Tokens::Colon)}
         raise Exceptions::ParseError.new("Invalid hash") unless key.size == 1 && value.size >= 1
 
         key = key.first

data/lib/keisan/token.rb

@@ -12,7 +12,7 @@ module Keisan
     end
 
     def self.type
-      @type ||= self.to_s.split("::").last.underscore.to_sym
+      @type ||= Util.underscore(self.to_s.split("::").last).to_sym
     end
 
     def regex

data/lib/keisan/util.rb

@@ -0,0 +1,19 @@
+module Keisan
+  class Util
+    def self.underscore(str)
+      str.to_s.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').downcase
+    end
+
+    def self.array_split(array, &block)
+      array.inject([[]]) do |results, element|
+        if yield(element)
+          results << []
+        else
+          results.last << element
+        end
+
+        results
+      end
+    end
+  end
+end

data/lib/keisan/variables/default_registry.rb

@@ -4,7 +4,8 @@ module Keisan
       VARIABLES = {
         "PI" => Math::PI,
         "E" => Math::E,
-        "I" => Complex(0,1)
+        "I" => Complex(0,1),
+        "INF" => Float::INFINITY
       }
 
       def self.registry

data/lib/keisan/version.rb

@@ -1,3 +1,3 @@
 module Keisan
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: keisan
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Christopher Locke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-29 00:00:00.000000000 Z
+date: 2018-11-23 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 4.2.2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 4.2.2
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
@@ -140,6 +126,8 @@ files:
 - lib/keisan/ast/cell.rb
 - lib/keisan/ast/cell_assignment.rb
 - lib/keisan/ast/constant_literal.rb
+- lib/keisan/ast/date.rb
+- lib/keisan/ast/date_time_methods.rb
 - lib/keisan/ast/exponent.rb
 - lib/keisan/ast/function.rb
 - lib/keisan/ast/function_assignment.rb
@@ -166,6 +154,7 @@ files:
 - lib/keisan/ast/parent.rb
 - lib/keisan/ast/plus.rb
 - lib/keisan/ast/string.rb
+- lib/keisan/ast/time.rb
 - lib/keisan/ast/times.rb
 - lib/keisan/ast/unary_bitwise_not.rb
 - lib/keisan/ast/unary_identity.rb
@@ -182,8 +171,10 @@ files:
 - lib/keisan/exceptions.rb
 - lib/keisan/function.rb
 - lib/keisan/functions/abs.rb
+- lib/keisan/functions/break.rb
 - lib/keisan/functions/cbrt.rb
 - lib/keisan/functions/cmath_function.rb
+- lib/keisan/functions/continue.rb
 - lib/keisan/functions/cos.rb
 - lib/keisan/functions/cosh.rb
 - lib/keisan/functions/cot.rb
@@ -201,6 +192,7 @@ files:
 - lib/keisan/functions/imag.rb
 - lib/keisan/functions/let.rb
 - lib/keisan/functions/log.rb
+- lib/keisan/functions/loop_control_flow_function.rb
 - lib/keisan/functions/map.rb
 - lib/keisan/functions/math_function.rb
 - lib/keisan/functions/proc_function.rb
@@ -292,6 +284,7 @@ files:
 - lib/keisan/tokens/string.rb
 - lib/keisan/tokens/unknown.rb
 - lib/keisan/tokens/word.rb
+- lib/keisan/util.rb
 - lib/keisan/variables/default_registry.rb
 - lib/keisan/variables/registry.rb
 - lib/keisan/version.rb
@@ -308,7 +301,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -316,7 +309,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: An equation parser and evaluator