keisan 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1e9c5a4aead65a954cbf6f2dc06d4ccb579e0edf
-  data.tar.gz: 2bbd7406b68ac4bd56f589fab026c303cf474edb
+  metadata.gz: 3b56feddfbcabbb14a37f3b278a234d1c110bdc4
+  data.tar.gz: 78ce88cb37946bc9356a78056a6ae2bbaa7ea788
 SHA512:
-  metadata.gz: f71593bb29b2f3c088eb1f2ea759c80cdf9afc8a93f2f6f4ed30e9b706a3e528d07f57930d0397c1f4e8c27a927d058fc2fbb9f3961ff2abf3c5a33aac7770fb
-  data.tar.gz: a2239cf26bb7d53c650308b2110b6f097801dc90a57bb5b69d1348a4b32902e74f6a2fb275eebcbd64d64f24865685bf2f442288cd976df3359996642a83aaae
+  metadata.gz: 4fe9d5949164c273f8b7634595630758e12905be56adb2df12c3fd1ea0491ccb063ff7a1348ab27d88a1f1b6286d2a17e1c65565d192a1d8c0682c4cd4e75a3a
+  data.tar.gz: 020dc6b00c5a8b24b98cbca79121a24321cea76067b31acca979a2f5f799f144b9ea0fb12f77fba474a5ce10f96aedc6375f065c0489e52f5c39112bff8922aa

data/README.md

@@ -4,8 +4,10 @@
 [![Build Status](https://travis-ci.org/project-eutopia/keisan.png?branch=master)](https://travis-ci.org/project-eutopia/keisan)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
 [![Hakiri](https://hakiri.io/github/project-eutopia/keisan/master.svg)](https://hakiri.io/github/project-eutopia/keisan)
+[![Maintainability](https://api.codeclimate.com/v1/badges/760e213d5ea81bca4480/maintainability)](https://codeclimate.com/github/project-eutopia/keisan/maintainability)
+[![Coverage Status](https://coveralls.io/repos/github/project-eutopia/keisan/badge.svg?branch=master)](https://coveralls.io/github/project-eutopia/keisan?branch=master)
 
-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.
+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 also has support for variables, functions, conditionals, and loops, making it a Turing complete programming language.
 
 ## Installation
 
@@ -173,6 +175,39 @@ calculator.evaluate("my_fact(5)")
 #=> 120
 ```
 
+##### Multiple lines and blocks
+
+Keisan understands strings which contain multiple lines.  It will evaluate each line separately, and the last line will be the the result of the total evaluation.  Lines can be separated by newlines or semi-colons.
+
+```ruby
+calculator = Keisan::Calculator.new
+calculator.evaluate("x = 2; y = 5\n x+y")
+#=> 7
+```
+
+The use of curly braces `{}` can be used to create block which has a new closure where variable definitions are local to the block itself.  Inside a block, external variables are still visible and re-assignable, but new variable definitions remain local.
+
+```ruby
+calculator = Keisan::Calculator.new
+calculator.evaluate("x = 10; y = 20")
+calculator.evaluate("{a = 100; x = 15; a+x+y}")
+#=> 135
+calculator.evaluate("x")
+#=> 15
+calculator.evaluate("a")
+#=> Keisan::Exceptions::UndefinedVariableError: a
+```
+
+By default assigning to a variable or function will bubble up to the first definition available in the parent scopes.  To assign to a local variable, you can use the `let` keyword.  The difference is illustrated below.
+
+```ruby
+calculator = Keisan::Calculator.new
+calculator.evaluate("x = 1; {x = 2}; x")
+#=> 2
+calculator.evaluate("x = 11; {let x = 12}; x")
+#=> 11
+```
+
 ##### Lists
 
 Just like in Ruby, lists can be defined using square brackets, and indexed using square brackets
@@ -183,6 +218,10 @@ calculator.evaluate("[2, 3, 5, 8]")
 #=> [2, 3, 5, 8]
 calculator.evaluate("[[1,2,3],[4,5,6],[7,8,9]][1][2]")
 #=> 6
+calculator.evaluate("a = [1,2,3]")
+calculator.evaluate("a[1] = 22")
+calculator.evaluate("a")
+#=> [1, 22, 3]
 ```
 
 They can also be concatenated using the `+` operator
@@ -253,6 +292,15 @@ calculator.evaluate("2 + if(1 > 0, 10, 29)")
 #=> 12
 ```
 
+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.  This works just like the normal `while` loop.
+
+```ruby
+calculator = Keisan::Calculator.new
+calculator.evaluate("my_sum(a) = {let i = 0; let total = 0; while(i < a.size, {total = total + a[i]; i = i + 1}); total}")
+calculator.evaluate("my_sum([1,3,5,7,9])")
+#=> 25
+```
+
 ##### Bitwise operations
 
 The basic bitwise operations, NOT `~`, OR `|`, XOR `^`, and AND `&` are also available for use

data/keisan.gemspec

@@ -23,6 +23,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "activesupport", ">= 4.2.2"
 
+  spec.add_development_dependency "coveralls"
   spec.add_development_dependency "bundler", "~> 1.14"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"

data/lib/keisan.rb

@@ -5,6 +5,7 @@ require "keisan/version"
 require "keisan/exceptions"
 
 require "keisan/ast/node"
+require "keisan/ast/cell"
 
 require "keisan/ast/literal"
 require "keisan/ast/variable"
@@ -14,9 +15,11 @@ require "keisan/ast/string"
 require "keisan/ast/null"
 require "keisan/ast/boolean"
 
+require "keisan/ast/block"
 require "keisan/ast/parent"
 require "keisan/ast/operator"
 require "keisan/ast/assignment"
+require "keisan/ast/multi_line"
 require "keisan/ast/unary_operator"
 require "keisan/ast/unary_identity"
 require "keisan/ast/unary_plus"
@@ -47,6 +50,7 @@ require "keisan/ast/function"
 require "keisan/ast/list"
 require "keisan/ast/indexing"
 
+require "keisan/ast/line_builder"
 require "keisan/ast/builder"
 require "keisan/ast"
 
@@ -73,6 +77,7 @@ require "keisan/tokens/arithmetic_operator"
 require "keisan/tokens/logical_operator"
 require "keisan/tokens/bitwise_operator"
 require "keisan/tokens/word"
+require "keisan/tokens/line_separator"
 
 require "keisan/tokenizer"
 
@@ -91,9 +96,11 @@ require "keisan/parsing/function"
 require "keisan/parsing/group"
 require "keisan/parsing/round_group"
 require "keisan/parsing/square_group"
+require "keisan/parsing/curly_group"
 require "keisan/parsing/list"
 require "keisan/parsing/indexing"
 require "keisan/parsing/argument"
+require "keisan/parsing/line_separator"
 
 require "keisan/parsing/operator"
 
@@ -134,4 +141,27 @@ require "keisan/calculator"
 require "keisan/evaluator"
 
 module Keisan
+  def self.calculator
+    @@calculator ||= Calculator.new
+  end
+
+  def self.reset
+    @@calculator = nil
+  end
+
+  def self.[](expression)
+    simplify(expression)
+  end
+
+  def self.evaluate(expression)
+    calculator.evaluate(expression)
+  end
+
+  def self.simplify(expression)
+    calculator.simplify(expression)
+  end
+
+  def self.ast(expression)
+    calculator.ast(expression)
+  end
 end

data/lib/keisan/ast/assignment.rb

@@ -1,12 +1,19 @@
 module Keisan
   module AST
     class Assignment < Operator
+      attr_reader :local
+
+      def initialize(children = [], parsing_operators = [], local: false)
+        super(children, parsing_operators)
+        @local = local
+      end
+
       def self.symbol
         :"="
       end
 
       def evaluate(context = nil)
-        context ||= Keisan::Context.new
+        context ||= Context.new
 
         lhs = children.first
         rhs = children.last
@@ -16,7 +23,8 @@ module Keisan
         elsif is_function_definition?
           evaluate_function(context, lhs, rhs)
         else
-          raise Keisan::Exceptions::InvalidExpression.new("Unhandled left hand side #{lhs} in assignment")
+          # Try cell assignment
+          evaluate_cell_assignment(context, lhs, rhs)
         end
       end
 
@@ -24,6 +32,10 @@ module Keisan
         evaluate(context)
       end
 
+      def evaluate_assignments(context = nil)
+        evaluate(context)
+      end
+
       def unbound_variables(context = nil)
         variables = super(context)
         if is_variable_definition?
@@ -43,52 +55,67 @@ module Keisan
       end
 
       def is_variable_definition?
-        children.first.is_a?(Keisan::AST::Variable)
+        children.first.is_a?(Variable)
       end
 
       def is_function_definition?
-        children.first.is_a?(Keisan::AST::Function)
+        children.first.is_a?(Function)
       end
 
       private
 
+      def evaluate_cell_assignment(context, lhs, rhs)
+        lhs = lhs.evaluate(context)
+        unless lhs.is_a?(Cell)
+          raise Exceptions::InvalidExpression.new("Unhandled left hand side #{lhs} in assignment")
+        end
+
+        rhs = rhs.evaluate(context)
+
+        lhs.node = rhs
+        rhs
+      end
+
       def evaluate_variable(context, lhs, rhs)
         rhs = rhs.evaluate(context)
 
         unless rhs.well_defined?
-          raise Keisan::Exceptions::InvalidExpression.new("Right hand side of assignment to variable must be well defined")
+          raise Exceptions::InvalidExpression.new("Right hand side of assignment to variable must be well defined")
         end
 
         rhs_value = rhs.value(context)
-        context.register_variable!(lhs.name, rhs_value)
+        context.register_variable!(lhs.name, rhs_value, local: local)
         # Return the variable assigned value
         rhs
       end
 
       def evaluate_function(context, lhs, rhs)
-        unless lhs.children.all? {|arg| arg.is_a?(Keisan::AST::Variable)}
-          raise Keisan::Exceptions::InvalidExpression.new("Left hand side function must have variables as arguments")
+        unless lhs.children.all? {|arg| arg.is_a?(Variable)}
+          raise Exceptions::InvalidExpression.new("Left hand side function must have variables as arguments")
         end
 
         argument_names = lhs.children.map(&:name)
         function_definition_context = context.spawn_child(shadowed: argument_names, transient: true)
 
-        unless rhs.unbound_variables(context) <= Set.new(argument_names)
-          raise Keisan::Exceptions::InvalidExpression.new("Unbound variables found in function definition")
-        end
-
-        unless context.allow_recursive || rhs.unbound_functions(context).empty?
-          raise Keisan::Exceptions::InvalidExpression.new("Unbound function definitions are not allowed by current context")
+        # Blocks might have local variable/function definitions
+        if !rhs.is_a?(Block)
+          unless rhs.unbound_variables(context) <= Set.new(argument_names)
+            raise Exceptions::InvalidExpression.new("Unbound variables found in function definition")
+          end
+          unless context.allow_recursive || rhs.unbound_functions(context).empty?
+            raise Exceptions::InvalidExpression.new("Unbound function definitions are not allowed by current context")
+          end
         end
 
         context.register_function!(
           lhs.name,
-          Keisan::Functions::ExpressionFunction.new(
+          Functions::ExpressionFunction.new(
             lhs.name,
             argument_names,
-            rhs.simplify(function_definition_context),
+            rhs.evaluate_assignments(function_definition_context),
             context.transient_definitions
-          )
+          ),
+          local: local
         )
 
         rhs

data/lib/keisan/ast/block.rb

@@ -0,0 +1,60 @@
+module Keisan
+  module AST
+    class Block < Node
+      attr_reader :child
+
+      def initialize(child)
+        @child = child
+      end
+
+      def unbound_variables(context = nil)
+        local = get_local_context(context)
+        child.unbound_variables(local)
+      end
+
+      def unbound_functions(context = nil)
+        local = get_local_context(context)
+        child.unbound_functions(local)
+      end
+
+      def deep_dup
+        dupped = dup
+        dupped.instance_variable_set(
+          :@child,
+          dupped.child.deep_dup
+        )
+        dupped
+      end
+
+      def value(context = nil)
+        local = get_local_context(context)
+        child.evaluated(local).value(local)
+      end
+
+      def evaluate(context = nil)
+        local = get_local_context(context)
+        child.evaluate(local)
+      end
+
+      def simplify(context = nil)
+        local = get_local_context(context)
+        child.simplify(local)
+      end
+
+      def replace(variable, replacement)
+        self
+      end
+
+      def to_s
+        "{#{child}}"
+      end
+
+      private
+
+      def get_local_context(context)
+        context ||= Context.new
+        context.spawn_child(transient: false)
+      end
+    end
+  end
+end

data/lib/keisan/ast/boolean.rb

@@ -12,14 +12,14 @@ module Keisan
       end
 
       def !
-        AST::Boolean.new(!bool)
+        Boolean.new(!bool)
       end
 
       def and(other)
         other = other.to_node
         case other
-        when AST::Boolean
-          AST::Boolean.new(bool && other.bool)
+        when Boolean
+          Boolean.new(bool && other.bool)
         else
           super
         end
@@ -28,8 +28,8 @@ module Keisan
       def or(other)
         other = other.to_node
         case other
-        when AST::Boolean
-          AST::Boolean.new(bool || other.bool)
+        when Boolean
+          Boolean.new(bool || other.bool)
         else
           super
         end

data/lib/keisan/ast/builder.rb

@@ -4,234 +4,37 @@ module Keisan
       # Build from parser
       def initialize(string: nil, parser: nil, components: nil)
         if [string, parser, components].select(&:nil?).size != 2
-          raise Keisan::Exceptions::InternalError.new("Require one of string, parser or components")
+          raise Exceptions::InternalError.new("Require one of string, parser or components")
         end
 
         if !string.nil?
-          @components = Keisan::Parser.new(string: string).components
+          @components = Parser.new(string: string).components
         elsif !parser.nil?
           @components = parser.components
         else
           @components = Array.wrap(components)
         end
 
-        @nodes = components_to_basic_nodes(@components)
+        @lines = @components.split {|component|
+          component.is_a?(Parsing::LineSeparator)
+        }.reject(&:empty?)
 
-        # Negative means not an operator
-        @priorities = @nodes.map {|node| node.is_a?(Keisan::Parsing::Operator) ? node.priority : -1}
+        @line_builders = @lines.map {|line| LineBuilder.new(line)}
 
-        consume_operators!
-
-        case @nodes.count
-        when 0
-          # Empty string, set to just Null
-          @nodes = [Keisan::AST::Null.new]
-        when 1
-          # Good
+        if @line_builders.size == 1
+          @node = @line_builders.first.ast
         else
-          raise Keisan::Exceptions::ASTError.new("Should end up with a single node")
+          @node = MultiLine.new(@line_builders.map(&:ast))
         end
       end
 
       def node
-        @nodes.first
+        @node
       end
 
       def ast
         node
       end
-
-      private
-
-      # Array of AST elements, and Parsing operators
-      def components_to_basic_nodes(components)
-        nodes_components = []
-
-        components.each do |component|
-          if nodes_components.empty?
-            nodes_components << [component]
-          else
-            is_operator = [nodes_components.last.last.is_a?(Keisan::Parsing::Operator), component.is_a?(Keisan::Parsing::Operator)]
-
-            if is_operator.first == is_operator.last
-              nodes_components.last << component
-            else
-              nodes_components << [component]
-            end
-          end
-        end
-
-        nodes_components.inject([]) do |nodes, node_or_component_group|
-          if node_or_component_group.first.is_a?(Keisan::Parsing::Operator)
-            node_or_component_group.each do |component|
-              nodes << component
-            end
-          else
-            nodes << node_from_components(node_or_component_group)
-          end
-
-          nodes
-        end
-      end
-
-      def node_from_components(components)
-        node, postfix_components = *node_postfixes(components)
-        # Apply postfix operators
-        postfix_components.each do |postfix_component|
-          node = apply_postfix_component_to_node(postfix_component, node)
-        end
-
-        node
-      end
-
-      def apply_postfix_component_to_node(postfix_component, node)
-        case postfix_component
-        when Keisan::Parsing::Indexing
-          postfix_component.node_class.new(
-            node,
-            postfix_component.arguments.map {|parsing_argument|
-              Builder.new(components: parsing_argument.components).node
-            }
-          )
-        when Keisan::Parsing::DotWord
-          Keisan::AST::Function.new(
-            [node],
-            postfix_component.name
-          )
-        when Keisan::Parsing::DotOperator
-          Keisan::AST::Function.new(
-            [node] + postfix_component.arguments.map {|parsing_argument|
-              Builder.new(components: parsing_argument.components).node
-            },
-            postfix_component.name
-          )
-        else
-          raise Keisan::Exceptions::ASTError.new("Invalid postfix component #{postfix_component}")
-        end
-      end
-
-      # Returns an array of the form
-      # [node, postfix_operators]
-      # middle_node is the main node which will be modified by prefix and postfix operators
-      # postfix_operators is an array of Keisan::Parsing::Indexing, DotWord, and DotOperator objects
-      def node_postfixes(components)
-        index_of_postfix_components = components.map.with_index {|c,i| [c,i]}.select {|c,i|
-          c.is_a?(Keisan::Parsing::Indexing) || c.is_a?(Keisan::Parsing::DotWord) || c.is_a?(Keisan::Parsing::DotOperator)
-        }.map(&:last)
-        unless index_of_postfix_components.reverse.map.with_index.all? {|i,j| i + j == components.size - 1 }
-          raise Keisan::Exceptions::ASTError.new("postfix components must be in back")
-        end
-
-        num_postfix = index_of_postfix_components.size
-
-        unless num_postfix + 1 == components.size
-          raise Keisan::Exceptions::ASTError.new("have too many components")
-        end
-
-        [
-          node_of_component(components[0]),
-          index_of_postfix_components.map {|i| components[i]}
-        ]
-      end
-
-      def node_of_component(component)
-        case component
-        when Keisan::Parsing::Number
-          Keisan::AST::Number.new(component.value)
-        when Keisan::Parsing::String
-          Keisan::AST::String.new(component.value)
-        when Keisan::Parsing::Null
-          Keisan::AST::Null.new
-        when Keisan::Parsing::Variable
-          Keisan::AST::Variable.new(component.name)
-        when Keisan::Parsing::Boolean
-          Keisan::AST::Boolean.new(component.value)
-        when Keisan::Parsing::List
-          Keisan::AST::List.new(
-            component.arguments.map {|parsing_argument|
-              Builder.new(components: parsing_argument.components).node
-            }
-          )
-        when Keisan::Parsing::Group
-          Builder.new(components: component.components).node
-        when Keisan::Parsing::Function
-          Keisan::AST::Function.new(
-            component.arguments.map {|parsing_argument|
-              Builder.new(components: parsing_argument.components).node
-            },
-            component.name
-          )
-        when Keisan::Parsing::DotWord
-          Keisan::AST::Function.new(
-            [node_of_component(component.target)],
-            component.name
-          )
-        when Keisan::Parsing::DotOperator
-          Keisan::AST::Function.new(
-            [node_of_component(component.target)] + component.arguments.map {|parsing_argument|
-              Builder.new(components: parsing_argument.components).node
-            },
-            component.name
-          )
-        else
-          raise Keisan::Exceptions::ASTError.new("Unhandled component, #{component}")
-        end
-      end
-
-      def consume_operators!
-        loop do
-          break if @priorities.empty?
-          max_priority = @priorities.max
-          break if max_priority < 0
-
-          consume_operators_with_priority!(max_priority)
-        end
-      end
-
-      def consume_operators_with_priority!(priority)
-        p_indexes = @priorities.map.with_index.select {|p,index| p == priority}
-        # :left, :right, or :none
-        associativity = AST::Operator.associativity_of_priority(priority)
-
-        if associativity == :right
-          index = p_indexes[-1][1]
-        else
-          index = p_indexes[0][1]
-        end
-
-        operator = @nodes[index]
-
-        # If has unary operators after, must process those first
-        if @nodes[index+1].is_a?(Keisan::Parsing::UnaryOperator)
-          loop do
-            break if !@nodes[index+1].is_a?(Keisan::Parsing::UnaryOperator)
-            index += 1
-          end
-          operator = @nodes[index]
-        end
-
-        # operator is the current operator to process, and index is its index
-        if operator.is_a?(Keisan::Parsing::UnaryOperator)
-          replacement_node = operator.node_class.new(
-            children = [@nodes[index+1]]
-          )
-          @nodes.delete_if.with_index {|node, i| i >= index && i <= index+1}
-          @priorities.delete_if.with_index {|node, i| i >= index && i <= index+1}
-          @nodes.insert(index, replacement_node)
-          @priorities.insert(index, -1)
-        elsif operator.is_a?(Keisan::Parsing::Operator)
-          replacement_node = operator.node_class.new(
-            children = [@nodes[index-1],@nodes[index+1]],
-            parsing_operators = [operator]
-          )
-          @nodes.delete_if.with_index {|node, i| i >= index-1 && i <= index+1}
-          @priorities.delete_if.with_index {|node, i| i >= index-1 && i <= index+1}
-          @nodes.insert(index-1, replacement_node)
-          @priorities.insert(index-1, -1)
-        else
-          raise Keisan::Exceptions::ASTError.new("Can only consume operators")
-        end
-      end
     end
   end
 end