keisan 0.7.0 → 0.8.4

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

@@ -28,7 +28,7 @@ module Keisan
 
         ast_function.instance_variable_set(
           :@children,
-          ast_function.children.map {|child| child.evaluate(context).to_node}
+          ast_function.children.map {|child| child.simplify(context).to_node}
         )
 
         if ast_function.children.all? {|child| child.well_defined?(context)}
@@ -44,7 +44,7 @@ module Keisan
 
         ast_function.instance_variable_set(
           :@children,
-          ast_function.children.map {|child| child.evaluate(context)}
+          ast_function.children.map {|child| child.simplify(context)}
         )
 
         if ast_function.children.all? {|child| child.is_a?(AST::ConstantLiteral)}

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

@@ -10,19 +10,19 @@ module Keisan
         evaluate(ast_function, context).value(context)
       end
 
-      def evaluate(ast_function, context = nil)
+      def simplify(ast_function, context = nil)
         context ||= Context.new
         expression, variable, replacement = expression_variable_replacement(ast_function)
 
-        expression = expression.evaluate(context)
-        replacement = replacement.evaluate(context)
+        expression = expression.simplify(context)
+        replacement = replacement.simplify(context)
 
-        expression.replace(variable, replacement).evaluate(context)
+        expression.replace(variable, replacement).simplify(context)
       end
 
-      def simplify(ast_function, context = nil)
+      def evaluate(ast_function, context = nil)
         context ||= Context.new
-        evaluate(ast_function, context).simplify(context)
+        simplify(ast_function, context).evaluate(context)
       end
 
       private

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
@@ -241,6 +241,8 @@ module Keisan
       :"&"  => Parsing::BitwiseAnd,
       :"|"  => Parsing::BitwiseOr,
       :"^"  => Parsing::BitwiseXor,
+      :<<   => Parsing::BitwiseLeftShift,
+      :>>   => Parsing::BitwiseRightShift,
       :"==" => Parsing::LogicalEqual,
       :"!=" => Parsing::LogicalNotEqual,
       :"&&" => Parsing::LogicalAnd,
@@ -280,7 +282,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/bitwise_left_shift.rb

@@ -0,0 +1,9 @@
+module Keisan
+  module Parsing
+    class BitwiseLeftShift < BitwiseOperator
+      def node_class
+        AST::BitwiseLeftShift
+      end
+    end
+  end
+end

data/lib/keisan/parsing/bitwise_right_shift.rb

@@ -0,0 +1,9 @@
+module Keisan
+  module Parsing
+    class BitwiseRightShift < BitwiseOperator
+      def node_class
+        AST::BitwiseRightShift
+      end
+    end
+  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/string_and_group_parser.rb

@@ -0,0 +1,229 @@
+module Keisan
+  class StringAndGroupParser
+    class Portion
+      attr_reader :start_index, :end_index
+
+      def initialize(start_index)
+        @start_index = start_index
+      end
+    end
+
+    class StringPortion < Portion
+      attr_reader :string
+
+      def initialize(expression, start_index)
+        super(start_index)
+
+        @string = expression[start_index]
+        @end_index = start_index + 1
+
+        while @end_index < expression.size
+          if expression[@end_index] == quote_type
+            @string << quote_type
+            @end_index += 1
+            # Successfully parsed the string
+            return
+          end
+
+          n, c = process_next_character(expression, @end_index)
+          @string << c
+          @end_index += n
+        end
+
+        raise Keisan::Exceptions::TokenizingError.new("Tokenizing error, no closing quote #{quote_type}")
+      end
+
+      def size
+        string.size
+      end
+
+      def to_s
+        string
+      end
+
+      private
+
+      # Returns number of processed input characters, and the output character
+      def process_next_character(expression, index)
+        # escape character
+        if expression[index] == "\\"
+          return [2, escaped_character(expression[index + 1])]
+        else
+          return [1, expression[index]]
+        end
+      end
+
+      def quote_type
+        @string[0]
+      end
+
+      def escaped_character(character)
+        case character
+        when "\\", '"', "'"
+          character
+        when "a"
+          "\a"
+        when "b"
+          "\b"
+        when "r"
+          "\r"
+        when "n"
+          "\n"
+        when "s"
+          "\s"
+        when "t"
+          "\t"
+        else
+          raise Keisan::Exceptions::TokenizingError.new("Tokenizing error, unknown escape character: \"\\#{character}\"")
+        end
+      end
+    end
+
+    class GroupPortion < Portion
+      attr_reader :opening_brace, :closing_brace ,:portions, :size
+
+      OPENING_TO_CLOSING_BRACE = {
+        "(" => ")",
+        "{" => "}",
+        "[" => "]",
+      }
+
+      def initialize(expression, start_index)
+        super(start_index)
+
+        case expression[start_index]
+        when OPEN_GROUP_REGEX
+          @opening_brace = expression[start_index]
+        else
+          raise Keisan::Exceptions::TokenizingError.new("Internal error, GroupPortion did not start with brace")
+        end
+
+        @closing_brace = OPENING_TO_CLOSING_BRACE[opening_brace]
+
+        parser = StringAndGroupParser.new(expression, start_index: start_index + 1, ending_character: closing_brace)
+        @portions = parser.portions
+        @size = parser.size + 2
+
+        if start_index + size > expression.size || expression[start_index + size - 1] != closing_brace
+          raise Keisan::Exceptions::TokenizingError.new("Tokenizing error, group with opening brace #{opening_brace} did not have closing brace")
+        end
+      end
+
+      def to_s
+        opening_brace + portions.map(&:to_s).join + closing_brace
+      end
+    end
+
+    class OtherPortion < Portion
+      attr_reader :string
+
+      def initialize(expression, start_index)
+        super(start_index)
+
+        case expression[start_index]
+        when STRING_CHARACTER_REGEX, OPEN_GROUP_REGEX, CLOSED_GROUP_REGEX
+          raise Keisan::Exceptions::TokenizingError.new("Internal error, OtherPortion should not have string/braces at start")
+        else
+          index = start_index + 1
+        end
+
+        while index < expression.size
+          case expression[index]
+          when STRING_CHARACTER_REGEX, OPEN_GROUP_REGEX, CLOSED_GROUP_REGEX, COMMENT_CHARACTER_REGEX
+            break
+          else
+            index += 1
+          end
+        end
+
+        @end_index = index
+        @string = expression[start_index...end_index]
+      end
+
+      def size
+        string.size
+      end
+
+      def to_s
+        string
+      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 = /[\)\}\]]/
+
+    # Ending character is used as a second ending condition besides expression size
+    def initialize(expression, start_index: 0, ending_character: nil)
+      index = start_index
+      @portions = []
+
+      while index < expression.size && (ending_character.nil? || expression[index] != ending_character)
+        case expression[index]
+        when STRING_CHARACTER_REGEX
+          portion = StringPortion.new(expression, index)
+          index = portion.end_index
+          @portions << portion
+
+        when OPEN_GROUP_REGEX
+          portion = GroupPortion.new(expression, index)
+          index += portion.size
+          @portions << portion
+
+        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
+          @portions << portion
+        end
+      end
+
+      @size = index - start_index
+    end
+
+    def to_s
+      portions.map(&:to_s).join
+    end
+  end
+end

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

@@ -1,13 +1,12 @@
 module Keisan
   class Tokenizer
     TOKEN_CLASSES = [
-      Tokens::Group,
-      Tokens::String,
       Tokens::Null,
       Tokens::Boolean,
       Tokens::Word,
       Tokens::Number,
       Tokens::Assignment,
+      Tokens::BitwiseShift,
       Tokens::LogicalOperator,
       Tokens::ArithmeticOperator,
       Tokens::BitwiseOperator,
@@ -25,28 +24,31 @@ module Keisan
     attr_reader :expression, :tokens
 
     def initialize(expression)
-      @expression = self.class.normalize_expression(expression)
-      @scan = @expression.scan(TOKEN_REGEX)
-      @tokens = tokenize!
-    end
+      @expression = expression
 
-    def self.normalize_expression(expression)
-      expression = normalize_line_delimiters(expression)
-      expression = remove_comments(expression)
-    end
+      portions = StringAndGroupParser.new(expression).portions.reject do |portion|
+        portion.is_a? StringAndGroupParser::CommentPortion
+      end
 
-    private
+      @tokens = portions.inject([]) do |tokens, portion|
+        case portion
+        when StringAndGroupParser::StringPortion
+          tokens << Tokens::String.new(portion.to_s)
+        when StringAndGroupParser::GroupPortion
+          tokens << Tokens::Group.new(portion.to_s)
+        when StringAndGroupParser::OtherPortion
+          scan = portion.to_s.scan(TOKEN_REGEX)
+          tokens += tokenize!(scan)
+        end
 
-    def self.normalize_line_delimiters(expression)
-      expression.gsub(/\n/, ";")
+        tokens
+      end
     end
 
-    def self.remove_comments(expression)
-      expression.gsub(/#[^;]*/, "")
-    end
+    private
 
-    def tokenize!
-      @scan.map do |scan_result|
+    def tokenize!(scan)
+      scan.map do |scan_result|
         i = scan_result.find_index {|token| !token.nil?}
         token_string = scan_result[i]
         token = TOKEN_CLASSES[i].new(token_string)