keisan 0.5.0 → 0.6.0

data/lib/keisan/functions/registry.rb

@@ -19,7 +19,7 @@ module Keisan
         end
 
         return default_registry[name] if @use_defaults && default_registry.has_name?(name)
-        raise Keisan::Exceptions::UndefinedFunctionError.new name
+        raise Exceptions::UndefinedFunctionError.new name
       end
 
       def locals
@@ -28,25 +28,25 @@ module Keisan
 
       def has?(name)
         !!self[name]
-      rescue Keisan::Exceptions::UndefinedFunctionError
+      rescue Exceptions::UndefinedFunctionError
         false
       end
 
       def register!(name, function, force: false)
-        raise Keisan::Exceptions::UnmodifiableError.new("Cannot modify frozen functions registry") if frozen?
+        raise Exceptions::UnmodifiableError.new("Cannot modify frozen functions registry") if frozen?
         name = name.to_s
 
         if !force && @use_defaults && default_registry.has_name?(name)
-          raise Keisan::Exceptions::UnmodifiableError.new("Cannot overwrite default function")
+          raise Exceptions::UnmodifiableError.new("Cannot overwrite default function")
         end
 
         case function
         when Proc
-          self[name] = Keisan::Functions::ProcFunction.new(name, function)
-        when Keisan::Function
+          self[name] = ProcFunction.new(name, function)
+        when Function
           self[name] = function
         else
-          raise Keisan::Exceptions::InvalidFunctionError.new
+          raise Exceptions::InvalidFunctionError.new
         end
       end
 

data/lib/keisan/functions/replace.rb

@@ -1,17 +1,17 @@
 module Keisan
   module Functions
-    class Replace < Keisan::Function
+    class Replace < Function
       def initialize
         @name = "replace"
       end
 
       def value(ast_function, context = nil)
-        context ||= Keisan::Context.new
+        context ||= Context.new
         evaluate(ast_function, context).value(context)
       end
 
       def evaluate(ast_function, context = nil)
-        context ||= Keisan::Context.new
+        context ||= Context.new
         expression, variable, replacement = expression_variable_replacement(ast_function)
 
         expression = expression.evaluate(context)
@@ -28,18 +28,18 @@ module Keisan
       private
 
       def expression_variable_replacement(ast_function)
-        unless ast_function.is_a?(Keisan::AST::Function) && ast_function.name == name
-          raise Keisan::Exceptions::InvalidFunctionError.new("Must receive replace function")
+        unless ast_function.is_a?(AST::Function) && ast_function.name == name
+          raise Exceptions::InvalidFunctionError.new("Must receive replace function")
         end
 
         unless ast_function.children.size == 3
-          raise Keisan::Exceptions::InvalidFunctionError.new("Require 3 arguments to replace")
+          raise Exceptions::InvalidFunctionError.new("Require 3 arguments to replace")
         end
 
         expression, variable, replacement = *ast_function.children.map(&:deep_dup)
 
-        unless variable.is_a?(Keisan::AST::Variable)
-          raise Keisan::Exceptions::InvalidFunctionError.new("Replace must replace a variable")
+        unless variable.is_a?(AST::Variable)
+          raise Exceptions::InvalidFunctionError.new("Replace must replace a variable")
         end
 
         [expression, variable, replacement]

data/lib/keisan/functions/sample.rb

@@ -3,6 +3,7 @@ module Keisan
     class Sample < ProcFunction
       def initialize
         @name = "sample"
+        @arity = 1
       end
 
       # Single argument: integer in range [0, max)
@@ -12,7 +13,7 @@ module Keisan
         when 1
           args.first.sample(random: context.random)
         else
-          raise Keisan::Exceptions::InvalidFunctionError.new
+          raise Exceptions::InvalidFunctionError.new
         end
       end
     end

data/lib/keisan/functions/sec.rb

@@ -8,7 +8,7 @@ module Keisan
       protected
 
       def self.derivative(argument)
-        Keisan::AST::Function.new([argument], "sin") * Keisan::AST::Exponent.new([Keisan::AST::Function.new([argument], "cos"), -2])
+        AST::Function.new([argument], "sin") * AST::Exponent.new([AST::Function.new([argument], "cos"), -2])
       end
     end
   end

data/lib/keisan/functions/sech.rb

@@ -8,7 +8,7 @@ module Keisan
       protected
 
       def self.derivative(argument)
-        -Keisan::AST::Function.new([argument], "sinh") * Keisan::AST::Exponent.new([Keisan::AST::Function.new([argument], "cosh"), -2])
+        -AST::Function.new([argument], "sinh") * AST::Exponent.new([AST::Function.new([argument], "cosh"), -2])
       end
     end
   end

data/lib/keisan/functions/sin.rb

@@ -8,7 +8,7 @@ module Keisan
       protected
 
       def self.derivative(argument)
-        Keisan::AST::Function.new([argument], "cos")
+        AST::Function.new([argument], "cos")
       end
     end
   end

data/lib/keisan/functions/sinh.rb

@@ -8,7 +8,7 @@ module Keisan
       protected
 
       def self.derivative(argument)
-        Keisan::AST::Function.new([argument], "cosh")
+        AST::Function.new([argument], "cosh")
       end
     end
   end

data/lib/keisan/functions/sqrt.rb

@@ -8,7 +8,7 @@ module Keisan
       protected
 
       def self.derivative(argument)
-        Keisan::AST::Exponent.new([argument, Rational(-1,2)]) / 2
+        AST::Exponent.new([argument, Rational(-1,2)]) / 2
       end
     end
   end

data/lib/keisan/functions/tan.rb

@@ -8,7 +8,7 @@ module Keisan
       protected
 
       def self.derivative(argument)
-        Keisan::AST::Exponent.new([Keisan::AST::Function.new([argument], "cos"), -2])
+        AST::Exponent.new([AST::Function.new([argument], "cos"), -2])
       end
     end
   end

data/lib/keisan/functions/tanh.rb

@@ -8,7 +8,7 @@ module Keisan
       protected
 
       def self.derivative(argument)
-        Keisan::AST::Exponent.new([Keisan::AST::Function.new([argument], "cosh"), -2])
+        AST::Exponent.new([AST::Function.new([argument], "cosh"), -2])
       end
     end
   end

data/lib/keisan/functions/while.rb

@@ -0,0 +1,46 @@
+module Keisan
+  module Functions
+    class While < Keisan::Function
+      def initialize
+        super("while", 2)
+      end
+
+      def value(ast_function, context = nil)
+        validate_arguments!(ast_function.children.count)
+        evaluate(ast_function, context)
+      end
+
+      def evaluate(ast_function, context = nil)
+        validate_arguments!(ast_function.children.count)
+        context ||= Keisan::Context.new
+        simplify(ast_function, context)
+      end
+
+      def simplify(ast_function, context = nil)
+        validate_arguments!(ast_function.children.count)
+        context ||= Context.new
+        while_loop(ast_function.children[0], ast_function.children[1], context)
+      end
+
+      private
+
+      def while_loop(logical_node, body_node, context)
+        current = Keisan::AST::Null.new
+
+        while logical_node_evaluates_to_true(logical_node, context)
+          current = body_node.evaluated(context)
+        end
+
+        current
+      end
+
+      def logical_node_evaluates_to_true(logical_node, context)
+        bool = logical_node.evaluated(context)
+        unless bool.is_a?(AST::Boolean)
+          raise Keisan::Exceptions::InvalidFunctionError.new("while condition must evaluate to a boolean")
+        end
+        bool.value(context)
+      end
+    end
+  end
+end

data/lib/keisan/parser.rb

@@ -1,31 +1,68 @@
 module Keisan
   class Parser
+    KEYWORDS = %w(let).freeze
+
     attr_reader :tokens, :components
 
     def initialize(string: nil, tokens: nil)
       if string.nil? && tokens.nil?
-        raise Keisan::Exceptions::InternalError.new("Invalid arguments")
+        raise Exceptions::InternalError.new("Invalid arguments")
       end
 
       if !string.nil?
         @tokens = Tokenizer.new(string).tokens
       else
-        raise Keisan::Exceptions::InternalError.new("Invalid argument: tokens = #{tokens}") if tokens.nil? || !tokens.is_a?(Array)
+        raise Exceptions::InternalError.new("Invalid argument: tokens = #{tokens}") if tokens.nil? || !tokens.is_a?(Array)
         @tokens = tokens
       end
 
       @components = []
 
-      parse_components!
-      remove_unary_identity!
+      if multi_line?
+        parse_multi_line!
+      elsif @tokens.first&.is_a?(Tokens::Word) && KEYWORDS.include?(@tokens.first.string)
+        parse_keyword!
+      else
+        parse_components!
+        remove_unary_identity!
+      end
     end
 
     def ast
-      @ast ||= Keisan::AST::Builder.new(parser: self).ast
+      @ast ||= AST::Builder.new(parser: self).ast
     end
 
     private
 
+    def multi_line?
+      @tokens.any? {|token| token.is_a?(Tokens::LineSeparator)}
+    end
+
+    def parse_multi_line!
+      line_parsers = @tokens.split {|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
+        if i < line_parsers.count - 1
+          @components << Parsing::LineSeparator.new
+        end
+      end
+    end
+
+    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|
+                      Parsing::Argument.new(argument_tokens)
+                    }
+                  else
+                    Parsing::Argument.new(tokens[1..-1])
+                  end
+      @components = [
+        Parsing::Function.new(keyword, arguments)
+      ]
+    end
+
     def parse_components!
       @unparsed_tokens = tokens.dup
 
@@ -39,10 +76,14 @@ module Keisan
 
     def remove_unary_identity!
       @components = @components.select do |component|
-        !component.is_a?(Keisan::Parsing::Operator) || !(component.node_class <= Keisan::AST::UnaryIdentity)
+        !component.is_a?(Parsing::Operator) || !(component.node_class <= AST::UnaryIdentity)
       end
     end
 
+    def is_start_of_line?
+      @components.empty? || @components.last.is_a?(Parsing::LineSeparator)
+    end
+
     # Elements are groups of tokens separated by (non-unary) operators
     # The following are basic elements:
     # number
@@ -54,7 +95,9 @@ module Keisan
     # and any number of indexing groups (square groups) at the back
     #
     def add_token_to_components!(token)
-      if @components.empty? || @components[-1].is_a?(Parsing::Operator)
+      if token.is_a?(Tokens::LineSeparator)
+        @components << Parsing::LineSeparator.new
+      elsif is_start_of_line? || @components[-1].is_a?(Parsing::Operator)
         # Expect an element or a unary operator
         if token.type == :operator
           # Here it must be a unary operator
@@ -64,17 +107,6 @@ module Keisan
           add_element_to_components!(token)
         end
 
-      elsif @components[-1].is_a?(Parsing::UnaryOperator)
-        # Expect an element or another unary operator
-        case token.type
-        when :operator
-          add_unary_operator_to_components!(token)
-        when :number, :string, :word, :group, :null, :boolean
-          add_element_to_components!(token)
-        else
-          raise Keisan::Exceptions::ParseError.new("Expected an element, received #{token.string}")
-        end
-
       elsif @components[-1].is_a?(Parsing::Element)
         # A word followed by a "round group" is actually a function: e.g. sin(x)
         if @components[-1].is_a?(Parsing::Variable) && token.type == :group && token.group_type == :round
@@ -83,11 +115,11 @@ module Keisan
         elsif token.type == :group && token.group_type == :square
           add_indexing_to_components!(token)
         elsif token.type == :dot
-          @components << Keisan::Parsing::Dot.new
-        else
-          # Expect an operator
-          raise Keisan::Exceptions::ParseError.new("Expected an operator, received #{token.string}") unless token.type == :operator
+          @components << Parsing::Dot.new
+        elsif token.type == :operator
           add_operator_to_components!(token)
+        else
+          raise Exceptions::ParseError.new("Expected an operator, received #{token.string}")
         end
 
       elsif @components[-1].is_a?(Parsing::Dot)
@@ -96,68 +128,86 @@ module Keisan
         when :word
           @components[-1] = Parsing::DotWord.new(token.string)
         else
-          raise Keisan::Exceptions::ParseError.new("A word must follow a dot, received #{token.string}")
+          raise Exceptions::ParseError.new("A word must follow a dot, received #{token.string}")
         end
 
       elsif @components[-1].is_a?(Parsing::DotWord)
-        # Expect a round group
-        if token.type == :group && token.group_type == :round
+        add_token_after_dot_word!(token)
+
+      else
+        raise Exceptions::ParseError.new("Token cannot be parsed, #{token.string}")
+      end
+    end
+
+    def add_token_after_dot_word!(token)
+      case token.type
+      when :group
+        case token.group_type
+        when :round
+          # Here it is a method call
           name = @components[-1].name
           @components[-1] = Parsing::DotOperator.new(name, arguments_from_group(token))
-        elsif token.type == :dot
-          @components << Keisan::Parsing::Dot.new
-        elsif token.type == :group && token.group_type == :square
+        when :square
+          # Here we are indexing after method call
           add_indexing_to_components!(token)
         else
-          raise Keisan::Exceptions::ParseError.new("Expected arguments to dot operator, received #{token.string}")
+          raise Exceptions::ParseError.new("Cannot take curly braces after function call")
         end
+      when :dot
+        # Chaining method calls
+        @components << Parsing::Dot.new
+      when :operator
+        # End of method call, move on to operator
+        add_operator_to_components!(token)
       else
-        raise Keisan::Exceptions::ParseError.new("Token cannot be parsed, #{token.string}")
+        raise Exceptions::ParseError.new("Expected arguments to dot operator, received #{token.string}")
       end
     end
 
     def add_unary_operator_to_components!(token)
       case token.operator_type
       when :+
-        @components << Keisan::Parsing::UnaryPlus.new
+        @components << Parsing::UnaryPlus.new
       when :-
-        @components << Keisan::Parsing::UnaryMinus.new
+        @components << Parsing::UnaryMinus.new
       when :"~"
-        @components << Keisan::Parsing::BitwiseNot.new
+        @components << Parsing::BitwiseNot.new
       when :"~~"
-        @components << Keisan::Parsing::BitwiseNotNot.new
+        @components << Parsing::BitwiseNotNot.new
       when :"!"
-        @components << Keisan::Parsing::LogicalNot.new
+        @components << Parsing::LogicalNot.new
       when :"!!"
-        @components << Keisan::Parsing::LogicalNotNot.new
+        @components << Parsing::LogicalNotNot.new
       else
-        raise Keisan::Exceptions::ParseError.new("Unhandled unary operator type #{token.operator_type}")
+        raise Exceptions::ParseError.new("Unhandled unary operator type #{token.operator_type}")
       end
     end
 
     def add_element_to_components!(token)
       case token
-      when Keisan::Tokens::Number
-        @components << Keisan::Parsing::Number.new(token.value)
-      when Keisan::Tokens::String
-        @components << Keisan::Parsing::String.new(token.value)
-      when Keisan::Tokens::Null
-        @components << Keisan::Parsing::Null.new
-      when Keisan::Tokens::Word
-        @components << Keisan::Parsing::Variable.new(token.string)
-      when Keisan::Tokens::Boolean
-        @components << Keisan::Parsing::Boolean.new(token.value)
-      when Keisan::Tokens::Group
+      when Tokens::Number
+        @components << Parsing::Number.new(token.value)
+      when Tokens::String
+        @components << Parsing::String.new(token.value)
+      when Tokens::Null
+        @components << Parsing::Null.new
+      when Tokens::Word
+        @components << Parsing::Variable.new(token.string)
+      when Tokens::Boolean
+        @components << Parsing::Boolean.new(token.value)
+      when Tokens::Group
         case token.group_type
         when :round
-          @components << Keisan::Parsing::RoundGroup.new(token.sub_tokens)
+          @components << Parsing::RoundGroup.new(token.sub_tokens)
         when :square
           @components << Parsing::List.new(arguments_from_group(token))
+        when :curly
+          @components << Parsing::CurlyGroup.new(token.sub_tokens)
         else
-          raise Keisan::Exceptions::ParseError.new("Unhandled group type #{token.group_type}")
+          raise Exceptions::ParseError.new("Unhandled group type #{token.group_type}")
         end
       else
-        raise Keisan::Exceptions::ParseError.new("Unhandled operator type #{token.operator_type}")
+        raise Exceptions::ParseError.new("Unhandled operator type #{token.operator_type}")
       end
     end
 
@@ -165,54 +215,46 @@ module Keisan
       case token.operator_type
       # Assignment
       when :"="
-        @components << Keisan::Parsing::Assignment.new
+        @components << Parsing::Assignment.new
       # Arithmetic
       when :+
-        @components << Keisan::Parsing::Plus.new
+        @components << Parsing::Plus.new
       when :-
-        @components << Keisan::Parsing::Minus.new
+        @components << Parsing::Minus.new
       when :*
-        @components << Keisan::Parsing::Times.new
+        @components << Parsing::Times.new
       when :/
-        @components << Keisan::Parsing::Divide.new
+        @components << Parsing::Divide.new
       when :**
-        @components << Keisan::Parsing::Exponent.new
+        @components << Parsing::Exponent.new
       when :%
-        @components << Keisan::Parsing::Modulo.new
+        @components << Parsing::Modulo.new
       # Bitwise
       when :"&"
-        @components << Keisan::Parsing::BitwiseAnd.new
+        @components << Parsing::BitwiseAnd.new
       when :"|"
-        @components << Keisan::Parsing::BitwiseOr.new
+        @components << Parsing::BitwiseOr.new
       when :"^"
-        @components << Keisan::Parsing::BitwiseXor.new
-      when :"~"
-        @components << Keisan::Parsing::BitwiseNot.new
-      when :"~~"
-        @components << Keisan::Parsing::BitwiseNotNot.new
+        @components << Parsing::BitwiseXor.new
       # Logical
       when :"=="
-        @components << Keisan::Parsing::LogicalEqual.new
+        @components << Parsing::LogicalEqual.new
       when :"!="
-        @components << Keisan::Parsing::LogicalNotEqual.new
+        @components << Parsing::LogicalNotEqual.new
       when :"&&"
-        @components << Keisan::Parsing::LogicalAnd.new
+        @components << Parsing::LogicalAnd.new
       when :"||"
-        @components << Keisan::Parsing::LogicalOr.new
-      when :"!"
-        @components << Keisan::Parsing::LogicalNot.new
-      when :"!!"
-        @components << Keisan::Parsing::LogicalNotNot.new
+        @components << Parsing::LogicalOr.new
       when :">"
-        @components << Keisan::Parsing::LogicalGreaterThan.new
+        @components << Parsing::LogicalGreaterThan.new
       when :"<"
-        @components << Keisan::Parsing::LogicalLessThan.new
+        @components << Parsing::LogicalLessThan.new
       when :">="
-        @components << Keisan::Parsing::LogicalGreaterThanOrEqualTo.new
+        @components << Parsing::LogicalGreaterThanOrEqualTo.new
       when :"<="
-        @components << Keisan::Parsing::LogicalLessThanOrEqualTo.new
+        @components << Parsing::LogicalLessThanOrEqualTo.new
       else
-        raise Keisan::Exceptions::ParseError.new("Unhandled operator type #{token.operator_type}")
+        raise Exceptions::ParseError.new("Unhandled operator type #{token.operator_type}")
       end
     end
 
@@ -229,7 +271,7 @@ module Keisan
       if token.sub_tokens.empty?
         []
       else
-        token.sub_tokens.split {|sub_token| sub_token.is_a?(Keisan::Tokens::Comma)}.map do |sub_tokens|
+        token.sub_tokens.split {|sub_token| sub_token.is_a?(Tokens::Comma)}.map do |sub_tokens|
           Parsing::Argument.new(sub_tokens)
         end
       end