keisan 0.1.0

data/lib/keisan/parsing/group.rb

@@ -0,0 +1,11 @@
+module Keisan
+  module Parsing
+    class Group < Element
+      attr_reader :components
+
+      def initialize(sub_tokens)
+        @components = Keisan::Parser.new(tokens: sub_tokens).components
+      end
+    end
+  end
+end

data/lib/keisan/parsing/indexing.rb

@@ -0,0 +1,14 @@
+module Keisan
+  module Parsing
+    class Indexing < SquareGroup
+      attr_reader :arguments
+      def initialize(arguments)
+        @arguments = arguments
+      end
+
+      def node_class
+        Keisan::AST::Indexing
+      end
+    end
+  end
+end

data/lib/keisan/parsing/list.rb

@@ -0,0 +1,10 @@
+module Keisan
+  module Parsing
+    class List < SquareGroup
+      attr_reader :arguments
+      def initialize(arguments)
+        @arguments = arguments
+      end
+    end
+  end
+end

data/lib/keisan/parsing/logical_and.rb

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

data/lib/keisan/parsing/logical_greater_than.rb

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

data/lib/keisan/parsing/logical_greater_than_or_equal_to.rb

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

data/lib/keisan/parsing/logical_less_than.rb

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

data/lib/keisan/parsing/logical_less_than_or_equal_to.rb

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

data/lib/keisan/parsing/logical_not.rb

@@ -0,0 +1,9 @@
+module Keisan
+  module Parsing
+    class LogicalNot < UnaryOperator
+      def node_class
+        Keisan::AST::UnaryLogicalNot
+      end
+    end
+  end
+end

data/lib/keisan/parsing/logical_not_not.rb

@@ -0,0 +1,9 @@
+module Keisan
+  module Parsing
+    class LogicalNotNot < UnaryOperator
+      def node_class
+        Keisan::AST::UnaryIdentity
+      end
+    end
+  end
+end

data/lib/keisan/parsing/logical_operator.rb

@@ -0,0 +1,6 @@
+module Keisan
+  module Parsing
+    class LogicalOperator < Operator
+    end
+  end
+end

data/lib/keisan/parsing/logical_or.rb

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

data/lib/keisan/parsing/minus.rb

@@ -0,0 +1,9 @@
+module Keisan
+  module Parsing
+    class Minus < ArithmeticOperator
+      def node_class
+        Keisan::AST::Plus
+      end
+    end
+  end
+end

data/lib/keisan/parsing/null.rb

@@ -0,0 +1,6 @@
+module Keisan
+  module Parsing
+    class Null < Element
+    end
+  end
+end

data/lib/keisan/parsing/number.rb

@@ -0,0 +1,10 @@
+module Keisan
+  module Parsing
+    class Number < Element
+      attr_reader :value
+      def initialize(value)
+        @value = value
+      end
+    end
+  end
+end

data/lib/keisan/parsing/operator.rb

@@ -0,0 +1,13 @@
+module Keisan
+  module Parsing
+    class Operator < Component
+      def priority
+        node_class.priority
+      end
+
+      def node_class
+        raise Keisan::Exceptions::NotImplementedError.new
+      end
+    end
+  end
+end

data/lib/keisan/parsing/plus.rb

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

data/lib/keisan/parsing/round_group.rb

@@ -0,0 +1,6 @@
+module Keisan
+  module Parsing
+    class RoundGroup < Group
+    end
+  end
+end

data/lib/keisan/parsing/square_group.rb

@@ -0,0 +1,6 @@
+module Keisan
+  module Parsing
+    class SquareGroup < Group
+    end
+  end
+end

data/lib/keisan/parsing/string.rb

@@ -0,0 +1,10 @@
+module Keisan
+  module Parsing
+    class String < Element
+      attr_reader :value
+      def initialize(value)
+        @value = value
+      end
+    end
+  end
+end

data/lib/keisan/parsing/times.rb

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

data/lib/keisan/parsing/unary_minus.rb

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

data/lib/keisan/parsing/unary_operator.rb

@@ -0,0 +1,9 @@
+module Keisan
+  module Parsing
+    class UnaryOperator < Component
+      def node_class
+        raise Keisan::Exponent::NotImplementedError.new
+      end
+    end
+  end
+end

data/lib/keisan/parsing/unary_plus.rb

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

data/lib/keisan/parsing/variable.rb

@@ -0,0 +1,11 @@
+module Keisan
+  module Parsing
+    class Variable < Element
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+    end
+  end
+end

data/lib/keisan/token.rb

@@ -0,0 +1,25 @@
+module Keisan
+  class Token
+    attr_reader :string
+    def initialize(string)
+      raise Exceptions::InvalidToken.new(string) unless string.match(regex)
+      @string = string
+    end
+
+    def type
+      self.class.type
+    end
+
+    def self.type
+      @type ||= self.to_s.split("::").last.underscore.to_sym
+    end
+
+    def regex
+      self.class.regex
+    end
+
+    def self.regex
+      raise Exceptions::NotImplementedError.new(:regex)
+    end
+  end
+end

data/lib/keisan/tokenizer.rb

@@ -0,0 +1,41 @@
+module Keisan
+  class Tokenizer
+    TOKEN_CLASSES = [
+      Tokens::Group,
+      Tokens::String,
+      Tokens::Null,
+      Tokens::Boolean,
+      Tokens::Word,
+      Tokens::Number,
+      Tokens::ArithmeticOperator,
+      Tokens::LogicalOperator,
+      Tokens::BitwiseOperator,
+      Tokens::Comma
+    ]
+
+    TOKEN_REGEX = Regexp::new(
+      TOKEN_CLASSES.map(&:regex).join("|")
+    )
+
+    attr_reader :expression, :tokens
+
+    def initialize(expression)
+      @expression = expression.split(Keisan::Tokens::String.regex).map.with_index {|s,i| i.even? ? s.gsub(/\s+/, "") : s}.join
+
+      @scan = @expression.scan(TOKEN_REGEX)
+
+      tokenizing_check = ""
+
+      @tokens = @scan.map do |scan_result|
+        i = scan_result.find_index {|token| !token.nil?}
+        token_string = scan_result[i]
+        tokenizing_check << token_string
+        token_class = TOKEN_CLASSES[i].new(token_string)
+      end
+
+      unless tokenizing_check == @expression
+        raise Keisan::Exceptions::TokenizingError.new("Expected \"#{@expression}\", tokenized \"#{tokenizing_check}\"")
+      end
+    end
+  end
+end

data/lib/keisan/tokens/arithmetic_operator.rb

@@ -0,0 +1,29 @@
+module Keisan
+  module Tokens
+    class ArithmeticOperator < Operator
+      EXPONENT = /(?:\*\*)/
+      TIMES = /(?:\*)/
+      DIVIDE = /(?:\/)/
+      PLUS_OR_MINUS = /(?:[\+\-]+)/
+      REGEX = /(#{EXPONENT}|#{TIMES}|#{DIVIDE}|#{PLUS_OR_MINUS})/
+
+      def self.regex
+        REGEX
+      end
+
+      def operator_type
+        case string
+        when EXPONENT
+          # Must match first to override matching against single "*"
+          :**
+        when TIMES
+          :*
+        when DIVIDE
+          :/
+        when PLUS_OR_MINUS
+          string.count("-").even? ? :+ : :-
+        end
+      end
+    end
+  end
+end

data/lib/keisan/tokens/bitwise_operator.rb

@@ -0,0 +1,29 @@
+module Keisan
+  module Tokens
+    class BitwiseOperator < Operator
+      AND = /(?:\&)/
+      OR = /(?:\|)/
+      XOR = /(?:\^)/
+      NOT = /(?:\~+)/
+
+      REGEX = /(#{AND}|#{OR}|#{XOR}|#{NOT})/
+
+      def self.regex
+        REGEX
+      end
+
+      def operator_type
+        case string
+        when AND
+          :"&"
+        when OR
+          :"|"
+        when XOR
+          :"^"
+        when NOT
+          string.count("~").even? ? :"~~" : :"~"
+        end
+      end
+    end
+  end
+end

data/lib/keisan/tokens/boolean.rb

@@ -0,0 +1,20 @@
+module Keisan
+  module Tokens
+    class Boolean < Token
+      REGEX = /((?:\btrue\b)|(?:\bfalse\b))/
+
+      def self.regex
+        REGEX
+      end
+
+      def value
+        case string
+        when "true"
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/keisan/tokens/comma.rb

@@ -0,0 +1,11 @@
+module Keisan
+  module Tokens
+    class Comma < Token
+      REGEX = /(\,)/
+
+      def self.regex
+        REGEX
+      end
+    end
+  end
+end

data/lib/keisan/tokens/group.rb

@@ -0,0 +1,28 @@
+module Keisan
+  module Tokens
+    class Group < Token
+      REGEX = /(\((?:[^\[\]\(\)]*\g<0>*)*\)|\[(?:[^\[\]\(\)]*\g<0>*)*\])/
+
+      attr_reader :sub_tokens
+
+      def initialize(string)
+        super
+        @sub_tokens = Tokenizer.new(string[1...-1]).tokens
+      end
+
+      def self.regex
+        REGEX
+      end
+
+      # Either :round, :square
+      def group_type
+        case string[0]
+        when "("
+          :round
+        when "["
+          :square
+        end
+      end
+    end
+  end
+end