keisan 0.8.1 → 0.8.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25f0cd7f7a5bd124a62c244a270bb4db0632fc0ce295d7f55fa25409eae66473
-  data.tar.gz: 5cdeae27276969608966b56891abe91fe8b2bddaef9f7ef3fdeb6a3fe6696176
+  metadata.gz: 496551eafa9e9774866f8322a750ec0e0b88c463c9cb0f9174cd3461003d95a5
+  data.tar.gz: 9d509cb07d53c12758bf3cbc1ddb45c4e75809432267cbf3215ab0ce9451404f
 SHA512:
-  metadata.gz: 32d761e97663ad54bc37d2e3894875068daa8567ae521dd877879a94f66417c752cc338eba7f1a06bbe23f2a1455fce7751690323fcf4948f243d8254c69f1b4
-  data.tar.gz: 6c62bfc43752fe4918022e0217227c4a31d1fae6225bf70d65bc61afb025dbef5af74597055b1216a4ef9d261252e2f2d9ac26467319e33c4c842a2764711053
+  metadata.gz: a0047d2ffeea473809ce46b8e7a0c5458012a5ee27182384d28f9ce5706eeaf0385a7c6aecf4619b637760ec235d8c55f8815c537665f03af58ed388180d5fe4
+  data.tar.gz: 29d2bf8124706bc44129abec0839bba5809678e71c50ac6b2b6d56e2584f4d7cf3f094005db1e8f6e2606334a637f6df90ab95f1a80ac8e6f9e844f67aaf032d

data/README.md

@@ -178,6 +178,22 @@ calculator.evaluate("x = 11; {let x = 12}; x")
 #=> 11
 ```
 
+##### Comments
+
+When working with multi-line blocks of code, sometimes comments are useful to include.
+Comments are parts of a string from the `#` character to the end of a line (indicated by a newline character `"\n"`).
+
+```
+calculator = Keisan::Calculator.new
+calculator.evaluate("""
+  # This is a comment
+  x = 'foo'
+  x += '#bar' # Notice that `#` inside strings is not part of the comment
+  x # Should print 'foo#bar'
+""")
+#=> "foo#bar"
+```
+
 ##### Lists
 
 Just like in Ruby, lists can be defined using square brackets, and indexed using square brackets
@@ -256,6 +272,7 @@ calculator.evaluate("range(1, 6).map(x, [x, x**2]).to_h")
 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
@@ -266,10 +283,13 @@ 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
@@ -279,6 +299,8 @@ 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

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/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(

data/lib/keisan/ast/function_assignment.rb

@@ -29,8 +29,7 @@ module Keisan
 
       def evaluate
         # Blocks might have local variable/function definitions, so skip check
-        verify_rhs_of_function_assignment_is_valid! unless rhs.is_a?(Block)
-
+        verify_rhs_of_function_assignment_is_valid!
         context.register_function!(lhs.name, expression_function, local: local)
         rhs
       end
@@ -38,15 +37,26 @@ module Keisan
       private
 
       def verify_rhs_of_function_assignment_is_valid!
-        # Only variables that can appear are those that are arguments to the function
-        unless rhs.unbound_variables(context) <= Set.new(argument_names)
-          raise Exceptions::InvalidExpression.new("Unbound variables found in function definition")
-        end
+        verify_unbound_functions!
+        verify_unbound_variables!
+      end
+
+      def verify_unbound_functions!
         # Cannot have undefined functions unless allowed by context
         unless context.allow_recursive || rhs.unbound_functions(context).empty?
           raise Exceptions::InvalidExpression.new("Unbound function definitions are not allowed by current context")
         end
       end
+
+      def verify_unbound_variables!
+        # We allow unbound variables inside block statements, as they could be temporary
+        # variables assigned locally
+        return if rhs.is_a?(Block)
+        # Only variables that can appear are those that are arguments to the function
+        unless rhs.unbound_variables(context) <= Set.new(argument_names)
+          raise Exceptions::InvalidExpression.new("Unbound variables found in function definition")
+        end
+      end
     end
   end
 end

data/lib/keisan/ast/hash.rb

@@ -21,6 +21,10 @@ module Keisan
         end
       end
 
+      def contains_a?(klass)
+        super || @hash.any? {|k, v| k.to_node.contains_a?(klass) || v.contains_a?(klass) }
+      end
+
       def evaluate(context = nil)
         context ||= Context.new
 

data/lib/keisan/ast/node.rb

@@ -37,6 +37,15 @@ module Keisan
         value(context)
       end
 
+      def contains_a?(klass)
+        case klass
+        when Array
+          klass.any? {|k| is_a?(k) }
+        else
+          is_a?(klass)
+        end
+      end
+
       def evaluate_assignments(context = nil)
         self
       end

data/lib/keisan/ast/parent.rb

@@ -25,6 +25,10 @@ module Keisan
         end
       end
 
+      def contains_a?(klass)
+        super || children.any? {|child| child.contains_a?(klass) }
+      end
+
       def freeze
         children.each(&:freeze)
         super

data/lib/keisan/calculator.rb

@@ -2,8 +2,14 @@ module Keisan
   class Calculator
     attr_reader :context
 
-    def initialize(context: nil, allow_recursive: false)
-      @context = context || Context.new(allow_recursive: allow_recursive)
+    # Note, allow_recursive would be more appropriately named:
+    # allow_unbound_functions_in_function_definitions, but it is too late for that.
+    def initialize(context: nil, allow_recursive: false, allow_blocks: true, allow_multiline: true)
+      @context = context || Context.new(
+        allow_recursive: allow_recursive,
+        allow_blocks: allow_blocks,
+        allow_multiline: allow_multiline
+      )
     end
 
     def allow_recursive
@@ -14,6 +20,14 @@ module Keisan
       context.allow_recursive!
     end
 
+    def allow_blocks
+      context.allow_blocks
+    end
+
+    def allow_multiline
+      context.allow_multiline
+    end
+
     def evaluate(expression, definitions = {})
       Evaluator.new(self).evaluate(expression, definitions)
     end
@@ -23,7 +37,7 @@ module Keisan
     end
 
     def ast(expression)
-      Evaluator.new(self).ast(expression)
+      Evaluator.new(self).parse_ast(expression)
     end
 
     def define_variable!(name, value)

data/lib/keisan/context.rb

@@ -1,13 +1,24 @@
 module Keisan
   class Context
-    attr_reader :function_registry, :variable_registry, :allow_recursive
-
-    def initialize(parent: nil, random: nil, allow_recursive: false, shadowed: [])
+    attr_reader :function_registry,
+      :variable_registry,
+      :allow_recursive,
+      :allow_multiline,
+      :allow_blocks
+
+    def initialize(parent: nil,
+                   random: nil,
+                   allow_recursive: false,
+                   allow_multiline: true,
+                   allow_blocks: true,
+                   shadowed: [])
       @parent = parent
       @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
+      @allow_multiline   = allow_multiline
+      @allow_blocks      = allow_blocks
     end
 
     def allow_recursive!
@@ -110,7 +121,13 @@ module Keisan
     end
 
     def pure_child(shadowed: [])
-      self.class.new(parent: self, shadowed: shadowed, allow_recursive: allow_recursive)
+      self.class.new(
+        parent: self,
+        shadowed: shadowed,
+        allow_recursive: allow_recursive,
+        allow_multiline: allow_multiline,
+        allow_blocks: allow_blocks
+      )
     end
   end
 end

data/lib/keisan/evaluator.rb

@@ -8,7 +8,7 @@ module Keisan
 
     def evaluate(expression, definitions = {})
       context = calculator.context.spawn_child(definitions: definitions, transient: true)
-      ast = ast(expression)
+      ast = parse_ast(expression)
       last_line = last_line(ast)
 
       evaluation = ast.evaluated(context)
@@ -24,16 +24,28 @@ module Keisan
 
     def simplify(expression, definitions = {})
       context = calculator.context.spawn_child(definitions: definitions, transient: true)
-      ast = AST.parse(expression)
+      ast = parse_ast(expression)
       ast.simplify(context)
     end
 
-    def ast(expression)
-      AST.parse(expression)
+    def parse_ast(expression)
+      AST.parse(expression).tap do |ast|
+        disallowed = disallowed_nodes
+        if !disallowed.empty? && ast.contains_a?(disallowed)
+          raise Keisan::Exceptions::InvalidExpression.new("Context does not permit expressions with #{disallowed}")
+        end
+      end
     end
 
     private
 
+    def disallowed_nodes
+      disallowed = []
+      disallowed << Keisan::AST::Block unless calculator.allow_blocks
+      disallowed << Keisan::AST::MultiLine unless calculator.allow_multiline
+      disallowed
+    end
+
     def last_line(ast)
       ast.is_a?(AST::MultiLine) ? ast.children.last : ast
     end

data/lib/keisan/functions/default_registry.rb

@@ -147,6 +147,9 @@ module Keisan
 
         registry.register!(:to_time, Proc.new {|d| d.to_time }, force: true)
         registry.register!(:to_date, Proc.new {|t| t.to_date }, force: true)
+
+        registry.register!(:epoch_seconds, Proc.new {|d| d.to_time - Time.new(1970, 1, 1, 0, 0, 0) }, force: true)
+        registry.register!(:epoch_days, Proc.new {|t| t.to_date  - Date.new(1970, 1, 1) }, force: true)
       end
 
       def self.register_date_time!(registry)

data/lib/keisan/functions/enumerable_function.rb

@@ -21,14 +21,17 @@ module Keisan
         context ||= Context.new
 
         operand, arguments, expression = operand_arguments_expression_for(ast_function, context)
+        
+        # Extract underlying operand for cells
+        real_operand = operand.is_a?(AST::Cell) ? operand.node : operand
 
-        case operand
+        case real_operand
         when AST::List
-          evaluate_list(operand, arguments, expression, context).evaluate(context)
+          evaluate_list(real_operand, arguments, expression, context).evaluate(context)
         when AST::Hash
-          evaluate_hash(operand, arguments, expression, context).evaluate(context)
+          evaluate_hash(real_operand, arguments, expression, context).evaluate(context)
         else
-          raise Exceptions::InvalidFunctionError.new("Unhandled first argument to #{name}: #{operand}")
+          raise Exceptions::InvalidFunctionError.new("Unhandled first argument to #{name}: #{real_operand}")
         end
       end
 

data/lib/keisan/string_and_group_parser.rb

@@ -9,24 +9,26 @@ module Keisan
     end
 
     class StringPortion < Portion
-      attr_reader :string
+      attr_reader :string, :escaped_string
 
       def initialize(expression, start_index)
         super(start_index)
 
         @string = expression[start_index]
+        @escaped_string = expression[start_index]
         @end_index = start_index + 1
 
         while @end_index < expression.size
           if expression[@end_index] == quote_type
             @string << quote_type
+            @escaped_string << quote_type
             @end_index += 1
             # Successfully parsed the string
             return
           end
 
-          n, c = process_next_character(expression, @end_index)
-          @string << c
+          n, c = get_potentially_escaped_next_character(expression, @end_index)
+          @escaped_string << c
           @end_index += n
         end
 
@@ -44,9 +46,13 @@ module Keisan
       private
 
       # Returns number of processed input characters, and the output character
-      def process_next_character(expression, index)
-        # escape character
-        if expression[index] == "\\"
+      # If a sequence like '\"' is encountered, the first backslash escapes the
+      # second double-quote, and the two characters will act as a one double-quote
+      # character.
+      def get_potentially_escaped_next_character(expression, index)
+        @string << expression[index]
+        if expression[index] == "\\" && index + 1 < expression.size
+          @string << expression[index + 1]
           return [2, escaped_character(expression[index + 1])]
         else
           return [1, expression[index]]
@@ -129,7 +135,7 @@ module Keisan
 
         while index < expression.size
           case expression[index]
-          when STRING_CHARACTER_REGEX, OPEN_GROUP_REGEX, CLOSED_GROUP_REGEX
+          when STRING_CHARACTER_REGEX, OPEN_GROUP_REGEX, CLOSED_GROUP_REGEX, COMMENT_CHARACTER_REGEX
             break
           else
             index += 1
@@ -149,9 +155,40 @@ module Keisan
       end
     end
 
+    class CommentPortion < Portion
+      attr_reader :string
+
+      def initialize(expression, start_index)
+        super(start_index)
+
+        if expression[start_index] != '#'
+          raise Keisan::Exceptions::TokenizingError.new("Comment should start with '#'")
+        else
+          index = start_index + 1
+        end
+
+        while index < expression.size
+          break if expression[index] == "\n"
+          index += 1
+        end
+
+        @end_index = index
+        @string = expression[start_index...end_index]
+      end
+
+      def size
+        string.size
+      end
+
+      def to_s
+        string
+      end
+    end
+
     # An ordered array of "portions", which
     attr_reader :portions, :size
 
+    COMMENT_CHARACTER_REGEX = /[#]/
     STRING_CHARACTER_REGEX = /["']/
     OPEN_GROUP_REGEX = /[\(\{\[]/
     CLOSED_GROUP_REGEX = /[\)\}\]]/
@@ -176,6 +213,11 @@ module Keisan
         when CLOSED_GROUP_REGEX
           raise Keisan::Exceptions::TokenizingError.new("Tokenizing error, unexpected closing brace #{expression[start_index]}")
 
+        when COMMENT_CHARACTER_REGEX
+          portion = CommentPortion.new(expression, index)
+          index += portion.size
+          @portions << portion
+
         else
           portion = OtherPortion.new(expression, index)
           index += portion.size

data/lib/keisan/tokenizer.rb

@@ -24,14 +24,16 @@ module Keisan
     attr_reader :expression, :tokens
 
     def initialize(expression)
-      @expression = self.class.normalize_expression(expression)
+      @expression = expression
 
-      portions = StringAndGroupParser.new(@expression).portions
+      portions = StringAndGroupParser.new(expression).portions.reject do |portion|
+        portion.is_a? StringAndGroupParser::CommentPortion
+      end
 
       @tokens = portions.inject([]) do |tokens, portion|
         case portion
         when StringAndGroupParser::StringPortion
-          tokens << Tokens::String.new(portion.to_s)
+          tokens << Tokens::String.new(portion.escaped_string)
         when StringAndGroupParser::GroupPortion
           tokens << Tokens::Group.new(portion.to_s)
         when StringAndGroupParser::OtherPortion
@@ -43,21 +45,8 @@ module Keisan
       end
     end
 
-    def self.normalize_expression(expression)
-      expression = normalize_line_delimiters(expression)
-      expression = remove_comments(expression)
-    end
-
     private
 
-    def self.normalize_line_delimiters(expression)
-      expression.gsub(/\n/, ";")
-    end
-
-    def self.remove_comments(expression)
-      expression.gsub(/#[^;]*/, "")
-    end
-
     def tokenize!(scan)
       scan.map do |scan_result|
         i = scan_result.find_index {|token| !token.nil?}

data/lib/keisan/version.rb

@@ -1,3 +1,3 @@
 module Keisan
-  VERSION = "0.8.1"
+  VERSION = "0.8.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: keisan
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.6
 platform: ruby
 authors:
 - Christopher Locke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-15 00:00:00.000000000 Z
+date: 2020-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmath