keisan 0.7.0 → 0.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 900d86c9daad1cab75e6140a21785f6de67ead1c
-  data.tar.gz: f2c5f2abc85d46ce71aa651f0cc860363a8790bf
+SHA256:
+  metadata.gz: de85515fc642eede46d24bdb2347a7f8bbe32c4d317fd305404c08367e742ecf
+  data.tar.gz: 0ce75e5555ca880e690e1cae4b76820594899706aa5608944fa5c9eedd0be9c8
 SHA512:
-  metadata.gz: 4f5e7ea1fd844e7927af6eb5b66edacc53dac30541cb670d6208e43d0a9edb4611417943be232ba8188c275fa8890ee3c3e7f43a874ae32085f80b05092ecef6
-  data.tar.gz: 588daa93a53120d0456f38e66f5fa27d50b5e517516c3e0747519e51aeb5ca49dc317187e85ec420e5eec5bc722732138499e16188bf7271afbc4481ba1980bd
+  metadata.gz: cd6b7cee90edee2d0ba51eb6b4d0a223305eeaf75a85ec6c2c6dbd9c3310ecd035c00d4a86d16768303f28d61996291e6e4d3ac7e5323a3a4df0c22f6343ff58
+  data.tar.gz: '05873d8324f622a818f5cba2b9ef260e61f3500154db3ab0ecb9570bf308a686f4b32eddcbfb664afab76845fe71da7c82f47dd511f845f33498045011024a8a'

data/.travis.yml

@@ -1,6 +1,9 @@
 sudo: false
 language: ruby
+before_install:
+  - gem install bundler
 rvm:
-  - 2.3.5
-  - 2.4.2
-before_install: gem install bundler -v 1.16.0
+  - 2.4.9
+  - 2.5.7
+  - 2.6.5
+  - 2.7.0

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,42 @@ 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.
+`epoch_days` computes the number of days since Unix epoch (Jan 1, 1970).
+
+```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)
+calculator.evaluate("date(1970, 1, 15).epoch_days")
+#=> 14
+```
+
+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.
+`epoch_seconds` computes the number of seconds since Unix epoch (00:00:00 on Jan 1, 1970).
+
+```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"
+calculator.evaluate("time(1970, 1, 1, 2, 3, 4).epoch_seconds")
+#=> 7384
+```
+
 ##### Functional programming methods
 
 Keisan also supports the basic functional programming operators `map` (or `collect`), `filter` (or `select`), and `reduce` (or `inject`).
@@ -293,17 +332,21 @@ 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
 
-The basic bitwise operations, NOT `~`, OR `|`, XOR `^`, and AND `&` are also available for use
+The basic bitwise operations, NOT `~`, OR `|`, XOR `^`, AND `&`, and left/right bitwise shifts (`<<` and `>>`) are also available for use
 
 ```ruby
 calculator = Keisan::Calculator.new
@@ -368,7 +411,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
@@ -448,6 +491,7 @@ calculator.evaluate("puts x**2") # prints "25\n" to STDOUT
 
 #### Bitwise operators
 - `&`, `|`, `^`: bitwise **and**, **or**, **xor** operators
+- `<<`, `>>` bitwise shift operators
 - `~`: unary bitwise not
 
 #### Indexing of arrays/hashes

data/keisan.gemspec

@@ -19,14 +19,14 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = ">= 2.0.0"
+  spec.required_ruby_version = ">= 2.3.0"
 
-  spec.add_dependency "activesupport", ">= 4.2.2"
+  spec.add_dependency "cmath", "~> 1.0"
 
-  spec.add_development_dependency "coveralls"
-  spec.add_development_dependency "bundler", "~> 1.14"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "pry-stack_explorer"
+  spec.add_development_dependency "simplecov"
 end

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"
@@ -37,6 +37,8 @@ require "keisan/ast/bitwise_operator"
 require "keisan/ast/bitwise_and"
 require "keisan/ast/bitwise_or"
 require "keisan/ast/bitwise_xor"
+require "keisan/ast/bitwise_left_shift"
+require "keisan/ast/bitwise_right_shift"
 require "keisan/ast/logical_operator"
 require "keisan/ast/logical_and"
 require "keisan/ast/logical_or"
@@ -78,10 +80,12 @@ require "keisan/tokens/assignment"
 require "keisan/tokens/arithmetic_operator"
 require "keisan/tokens/logical_operator"
 require "keisan/tokens/bitwise_operator"
+require "keisan/tokens/bitwise_shift"
 require "keisan/tokens/word"
 require "keisan/tokens/line_separator"
 require "keisan/tokens/unknown"
 
+require "keisan/string_and_group_parser"
 require "keisan/tokenizer"
 
 require "keisan/parsing/component"
@@ -128,6 +132,8 @@ require "keisan/parsing/bitwise_or"
 require "keisan/parsing/bitwise_xor"
 require "keisan/parsing/bitwise_not"
 require "keisan/parsing/bitwise_not_not"
+require "keisan/parsing/bitwise_left_shift"
+require "keisan/parsing/bitwise_right_shift"
 require "keisan/parsing/logical_operator"
 require "keisan/parsing/logical_less_than"
 require "keisan/parsing/logical_greater_than"

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/bitwise_left_shift.rb

@@ -0,0 +1,17 @@
+module Keisan
+  module AST
+    class BitwiseLeftShift < BitwiseOperator
+      def self.symbol
+        :<<
+      end
+
+      def blank_value
+        0
+      end
+
+      def evaluate(context = nil)
+        children[1..-1].inject(children.first.evaluate(context)) {|total, child| total << child.evaluate(context)}
+      end
+    end
+  end
+end

data/lib/keisan/ast/bitwise_right_shift.rb

@@ -0,0 +1,17 @@
+module Keisan
+  module AST
+    class BitwiseRightShift < BitwiseOperator
+      def self.symbol
+        :>>
+      end
+
+      def blank_value
+        0
+      end
+
+      def evaluate(context = nil)
+        children[1..-1].inject(children.first.evaluate(context)) {|total, child| total >> child.evaluate(context)}
+      end
+    end
+  end
+end

data/lib/keisan/ast/block.rb

@@ -17,6 +17,10 @@ module Keisan
         child.unbound_functions(local)
       end
 
+      def contains_a?(klass)
+        super || child.contains_a?(klass)
+      end
+
       def deep_dup
         dupped = dup
         dupped.instance_variable_set(

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

@@ -15,6 +15,10 @@ module Keisan
         node.unbound_functions(context)
       end
 
+      def contains_a?(klass)
+        super || node.contains_a?(klass)
+      end
+
       def deep_dup
         dupped = dup
         dupped.instance_variable_set(
@@ -72,6 +76,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