kalculator 0.6.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b8d9f63d9aa766d2a26f0b17d63f2ed90dccb7ea1cc98013f2e5703445a2fc9
-  data.tar.gz: 54bdd33465e18514a700e1f2a49d24b399ff19556a375c68fda95d868f05145a
+  metadata.gz: 96f3aedf0934ea881aac16720904825d1861878d7e00d55b8ce81f3f01b4ffdd
+  data.tar.gz: c5ceb6b7b8b9b232b31a81c08f03499c3fdd46b7968fb99f48f240929dfcbb40
 SHA512:
-  metadata.gz: 2162cfd1c00584151fc1148dc8d0dc3d2e779bf634a623ea9d816270b7d5ceff241421307905b5eb5b72bf7bc979251c1be7232867d2499ea195fc549f466971
-  data.tar.gz: cf4a5db28cb6280c2b7761c6a6ace135103341f987a63b7b6d4bc1ef3476213346e4992590c686f88938b2c4da40bebcb71720247c7c0220e615099741342fec
+  metadata.gz: eeb67bb90056d4d8ffc9d3b9d0f07dc0a1441c9da6a3285dca9c6102653e2fb95b0057223ab88d0171dd2030ea3f9cbe43e2986b6ebf8e7aabf7c6acadb645fd
+  data.tar.gz: 581292d72c21d1d8d593a50863ccab63c776570e725bf1444c9b1fa8db63a4e4448a74cff0201932d4191b6e42284ff06b2761fc9e9397646119bf453df27f54

data/lib/kalculator.rb

@@ -1,19 +1,30 @@
 require "rltk"
+require "date"
+require "kalculator/built_in_functions"
 require "kalculator/data_sources"
 require "kalculator/errors"
 require "kalculator/evaluator"
 require "kalculator/formula"
 require "kalculator/lexer"
-require "kalculator/nested_lookup"
 require "kalculator/parser"
+require "kalculator/pointer"
 require "kalculator/transform"
+require "kalculator/type_sources"
+require "kalculator/types"
+require "kalculator/validator"
 require "kalculator/version"
 
+
+
+
+
 class Kalculator
-  def self.evaluate(formula, data_source = {})
-    Kalculator::Formula.new(formula).evaluate(data_source)
+  def self.evaluate(formula, data_source = {}, custom_functions = {})
+    Kalculator::Formula.new(formula).evaluate(data_source, custom_functions)
+  end
+  def self.validate(formula,  type_source = Kalculator::TypeSources.new(Hash.new) )
+    Kalculator::Formula.new(formula).validate(type_source)
   end
-
   def self.new(*args)
     Kalculator::Formula.new(*args)
   end

data/lib/kalculator/built_in_functions.rb

@@ -0,0 +1,22 @@
+class Kalculator
+  BUILT_IN_FUNCTIONS = {
+    ["contains", 2] => lambda { |collection, item|
+        collection.include?(item)
+    },
+    ["count", 1] => lambda { |list|
+      list.count
+    },
+    ["date", 1] => lambda { |str|
+      Date.parse(str)
+    },
+    ["max", 2] => lambda { |left, right|
+      [left, right].max
+    },
+    ["min", 2] => lambda { |left, right|
+      [left, right].min
+    },
+    ["sum", 1] => lambda { |list|
+      list.inject(0){|sum, num| sum + num}
+    },
+  }.freeze
+end

data/lib/kalculator/errors.rb

@@ -1,5 +1,11 @@
 class Kalculator
-  class Error < ::StandardError; end
+  class Error < ::StandardError ##an error that holds metadata
+    attr_reader :metadata
+    def initialize(metadata)
+      @metadata = metadata
+    end
+  end
   class TypeError < Error; end
+  class UndefinedFunctionError < Error; end
   class UndefinedVariableError < Error; end
 end

data/lib/kalculator/evaluator.rb

@@ -1,97 +1,96 @@
-require "date"
 
 class Kalculator
   class Evaluator
-    def initialize(data_source)
+    def initialize(data_source, custom_functions = {})
+
       @data_source = data_source
+      @functions = Kalculator::BUILT_IN_FUNCTIONS.merge(custom_functions)
     end
 
     def evaluate(ast)
+
       send(ast.first, *ast)
     end
 
-    def +(_, left, right)
+    def access(_, identifier, object, metadata)
+      a = evaluate(object)
+      if(a.key?(identifier))
+        b =a[identifier]
+        if(b.is_a?(Kalculator::Pointer))
+          b = @data_source[b.p]
+        end
+        if(b.is_a?(Kalculator::AnonymousPointer))
+          b = b.p
+        end
+        return b
+      end
+      raise UndefinedVariableError.new(metadata), "object #{a} doesn't have attribute #{identifier}"
+    end
+    def +(_, left, right, metadata)
       evaluate(left) + evaluate(right)
     end
 
-    def -(_, left, right)
+    def -(_, left, right, metadata)
       evaluate(left) - evaluate(right)
     end
 
-    def *(_, left, right)
+    def *(_, left, right, metadata)
       evaluate(left) * evaluate(right)
     end
 
-    def /(_, left, right)
+    def /(_, left, right, metadata)
       evaluate(left) / evaluate(right)
     end
 
-    def >(_, left, right)
+    def >(_, left, right, metadata)
       evaluate(left) > evaluate(right)
     end
 
-    def >=(_, left, right)
+    def >=(_, left, right, metadata)
       evaluate(left) >= evaluate(right)
     end
 
-    def <(_, left, right)
+    def <(_, left, right, metadata)
       evaluate(left) < evaluate(right)
     end
 
-    def <=(_, left, right)
+    def <=(_, left, right, metadata)
       evaluate(left) <= evaluate(right)
     end
 
-    def ==(_, left, right)
+    def ==(_, left, right, metadata)
       evaluate(left) == evaluate(right)
     end
 
-    def !=(_, left, right)
+    def !=(_, left, right, metadata)
       evaluate(left) != evaluate(right)
     end
 
-    def and(_, left, right)
+    def and(_, left, right, metadata)
       evaluate(left) && evaluate(right)
     end
 
-    def or(_, left, right)
+    def or(_, left, right, metadata)
       evaluate(left) || evaluate(right)
     end
 
-    def boolean(_, boolean)
+    def boolean(_, boolean,_, metadata)
       boolean
     end
 
-    def contains(_, collection, item)
-      collection = evaluate(collection)
-      item = evaluate(item)
-      if collection.is_a?(Array)
-        collection.include?(item)
-      elsif collection.is_a?(String) && item.is_a?(String)
-        collection.include?(item)
-      else
-        raise TypeError, "contains only works with strings or lists, got #{collection.inspect} and #{item.inspect}"
-      end
-    end
-
-    def count(_, collection)
-      collection = evaluate(collection)
-      raise TypeError, "count only works with Enumerable types, got #{collection.inspect}" unless collection.is_a?(Enumerable)
-      collection.count
+    def exists(_, variable, metadata)
+      @data_source.key?(variable)
     end
 
-    def date(_, expression)
-      value = evaluate(expression)
-      raise TypeError, "date only works with Strings, got #{value.inspect}" unless value.is_a?(String)
-      Date.parse(value)
+    def fn_call(_, fn_name, expressions, metadata)
+      key = [fn_name, expressions.count]
+      fn = @functions[key]
+      raise UndefinedFunctionError.new(metadata), "no such function #{fn_name}/#{expressions.count}" if fn.nil?
+      args = expressions.map{|expression| evaluate(expression) }
+      return fn.call(*args)
     end
 
-    def exists(_, variable)
-      (_variable, name) = variable
-      @data_source.key?(name)
-    end
-
-    def if(_, condition, true_clause, false_clause)
+    def if(_, condition, true_clause, false_clause, metadata)
       if evaluate(condition)
         evaluate(true_clause)
       else
@@ -99,59 +98,41 @@ class Kalculator
       end
     end
 
-    def list(_, expressions)
+    def list(_, expressions, metadata)
       expressions.map{|expression| evaluate(expression) }
     end
 
-    def max(_, left, right)
-      left = evaluate(left)
-      right = evaluate(right)
-      raise TypeError, "max only works with numbers, got #{left.inspect}" unless left.is_a?(Numeric)
-      raise TypeError, "max only works with numbers, got #{right.inspect}" unless right.is_a?(Numeric)
-      [left, right].max
-    end
-
-    def min(_, left, right)
-      left = evaluate(left)
-      right = evaluate(right)
-      raise TypeError, "min only works with numbers, got #{left.inspect}" unless left.is_a?(Numeric)
-      raise TypeError, "min only works with numbers, got #{right.inspect}" unless right.is_a?(Numeric)
-      [left, right].min
-    end
-
-    def not(_, expression)
+    def not(_, expression, metadata)
       bool = evaluate(expression)
-      raise TypeError, "! only works with booleans, got #{bool.inspect}" unless bool === true || bool === false
       !bool
     end
 
-    def null(_, _)
+    def null(_, _,_, metadata)
       nil
     end
 
-    def number(_, number)
+    def number(_, number,_, metadata)
       number
     end
 
-    def percent(_, percent)
+    def percent(_, percent,_, metadata)
       percent / 100.0
     end
 
-    def string(_, string)
+    def string(_, string,_, metadata)
       string
     end
 
-    def sum(_, array)
-      array = evaluate(array)
-      unless array.is_a?(Array) && array.all?{|n| n.is_a?(Numeric)}
-        raise TypeError, "sum only works with lists of numbers, got #{array.inspect}"
+    def variable(_, name, metadata)
+      raise UndefinedVariableError.new(metadata), "undefined variable #{name}" unless @data_source.key?(name)
+      a = @data_source[name]
+      if(a.is_a?(Pointer))
+        a = @data_source[a.p]
       end
-      array.inject(0){|sum, num| sum + num}
-    end
-
-    def variable(_, name)
-      raise UndefinedVariableError, "undefined variable #{name}" unless @data_source.key?(name)
-      @data_source[name]
+      if(a.is_a?(Kalculator::AnonymousPointer))
+        a = a.p
+      end
+      return a
     end
   end
 end

data/lib/kalculator/formula.rb

@@ -1,3 +1,4 @@
+
 class Kalculator
   class Formula
     attr_reader :ast, :string
@@ -7,8 +8,13 @@ class Kalculator
       @string = string
     end
 
-    def evaluate(data_source = {})
-      Kalculator::Evaluator.new(data_source).evaluate(ast)
+    def validate( type_source = Kalculator::TypeSources.new(Hash.new))
+      Kalculator::Validator.new(type_source).validate(ast)
+    end
+
+    def evaluate(data_source = {}, custom_functions = {})
+      Kalculator::Evaluator.new(data_source, custom_functions).evaluate(ast)
     end
+
   end
 end

data/lib/kalculator/lexer.rb

@@ -1,6 +1,7 @@
 class Kalculator
   class Lexer < RLTK::Lexer
     rule(/\s/)
+    rule(/\./)       { :PERIOD   }
     rule(/\(/)       { :LPAREN   }
     rule(/\)/)       { :RPAREN   }
     rule(/\[/)       { :LBRACKET }
@@ -27,14 +28,8 @@ class Kalculator
     rule(/\-?\d+/)      { |t| [:NUMBER, t.to_i] }
     rule(/\-?\.\d+/)    { |t| [:NUMBER, t.to_f] }
     rule(/\-?\d+\.\d+/) { |t| [:NUMBER, t.to_f] }
-    rule(/contains/) { |t| :CONTAINS }
-    rule(/count/)    { |t| :COUNT }
-    rule(/date/)     { |t| :DATE }
     rule(/exists/)   { |t| :EXISTS }
     rule(/if/)       { |t| :IF }
-    rule(/max/)      { |t| :MAX }
-    rule(/min/)      { |t| :MIN }
-    rule(/sum/)      { |t| :SUM }
     rule(/true/)     { |t| :TRUE }
     rule(/false/)    { |t| :FALSE }
     rule(/null/)     { |t| :NULL }
@@ -42,6 +37,6 @@ class Kalculator
     rule(/FALSE/)    { |t| :FALSE }
     rule(/NULL/)     { |t| :NULL }
     rule(/"[^"]*"/)  { |t| [:STRING, t[1..-2]] }
-    rule(/[A-Za-z][A-Za-z0-9\._]*/) { |t| [:IDENT, t] }
+    rule(/[A-Za-z][A-Za-z0-9_]*/) { |t| [:IDENT, t] }
   end
 end

data/lib/kalculator/parser.rb

@@ -1,59 +1,62 @@
+
 class Kalculator
   class Parser < RLTK::Parser
+    #code taken from spiff-rb
+    class Environment < Environment
+      def metadata(first_token = nil, last_token = nil)
+        first_token ||= @positions.first
+        last_token  ||= @positions.last
+        begins_at = first_token.stream_offset
+        ends_at   = last_token.stream_offset + last_token.length - 1
+        {
+          offset: begins_at..ends_at,
+        }
+      end
+    end
     left :AND, :OR
-    left :GT, :GTE, :LT, :LTE, :EQ
+    left :GT, :GTE, :LT, :LTE, :EQ, :NEQ
     left :PLUS, :SUB
     left :MUL, :DIV
+    left :PERIOD
     #Left     600 '.'.
 
     production(:expression) do
-      clause('CONTAINS LPAREN expression COMMA expression RPAREN') do |_, _, collection, _, item, _|
-        [:contains, collection, item]
-      end
       clause('IF LPAREN expression COMMA expression COMMA expression RPAREN') do |_, _, condition, _, true_clause, _, false_clause, _|
-        [:if, condition, true_clause, false_clause]
-      end
-      clause('SUM LPAREN expression RPAREN') do |_, _, e0, _|
-        [:sum, e0]
-      end
-      clause('COUNT LPAREN expression RPAREN') do |_, _, e0, _|
-        [:count, e0]
-      end
-      clause('DATE LPAREN expression RPAREN') do |_, _, e0, _|
-        [:date, e0]
+        [:if, condition, true_clause, false_clause, metadata]
       end
       clause('EXISTS LPAREN IDENT RPAREN') do |_, _, n, _|
-        [:exists, [:variable, n]]
+        [:exists, n, metadata]
       end
-      clause('MAX LPAREN expression COMMA expression RPAREN') { |_, _, left, _, right, _| [:max, left, right] }
-      clause('MIN LPAREN expression COMMA expression RPAREN') { |_, _, left, _, right, _| [:min, left, right] }
       clause('LPAREN expression RPAREN') { |_, expression, _| expression }
-      clause('LBRACKET expressions RBRACKET') { |_, expressions, _| [:list, expressions] }
+      clause('LBRACKET expressions RBRACKET') { |_, expressions, _| [:list, expressions, metadata] }
+      clause('IDENT LPAREN expressions RPAREN') { |fn_name, _, expressions, _| [:fn_call, fn_name, expressions, metadata] }
+      clause('expression LBRACKET STRING RBRACKET') { |object, _,ident, _| [:access, ident, object, metadata]}
 
-      clause('NUMBER') { |n| [:number, n] }
-      clause('PERCENT') { |n| [:percent, n] }
-      clause('STRING') { |s| [:string, s] }
-      clause('IDENT') { |n| [:variable, n] }
-      clause('TRUE') { |n| [:boolean, true] }
-      clause('FALSE') { |n| [:boolean, false] }
-      clause('NULL') { |n| [:null, nil] }
+      clause('NUMBER') { |n| [:number, n, Number, metadata] }
+      clause('PERCENT') { |n| [:percent, n, Percent, metadata] }
+      clause('STRING') { |s| [:string, s, String.new, metadata] }
+      clause('IDENT') { |n| [:variable, n, metadata] }
+      clause('TRUE') { |n| [:boolean, true, Bool, metadata] }
+      clause('FALSE') { |n| [:boolean, false, Bool, metadata] }
+      clause('NULL') { |n| [:null, nil, Object, metadata] }
 
-      clause('expression GT expression') { |e0, _, e1| [:>, e0, e1] }
-      clause('expression GTE expression') { |e0, _, e1| [:>=, e0, e1] }
-      clause('expression LT expression') { |e0, _, e1| [:<, e0, e1] }
-      clause('expression LTE expression') { |e0, _, e1| [:<=, e0, e1] }
-      clause('expression EQ expression') { |e0, _, e1| [:==, e0, e1] }
-      clause('expression NEQ expression') { |e0, _, e1| [:!=, e0, e1] }
+      clause('expression PERIOD IDENT')  {  |e0, _, i| [:access,i, e0, metadata] }
+      clause('expression GT expression') { |e0, _, e1| [:>, e0, e1, metadata] }
+      clause('expression GTE expression') { |e0, _, e1| [:>=, e0, e1, metadata] }
+      clause('expression LT expression') { |e0, _, e1| [:<, e0, e1, metadata] }
+      clause('expression LTE expression') { |e0, _, e1| [:<=, e0, e1, metadata] }
+      clause('expression EQ expression') { |e0, _, e1| [:==, e0, e1, metadata] }
+      clause('expression NEQ expression') { |e0, _, e1| [:!=, e0, e1, metadata] }
 
-      clause('expression AND expression') { |e0, _, e1| [:and, e0, e1] }
-      clause('expression OR expression') { |e0, _, e1| [:or, e0, e1] }
+      clause('expression AND expression') { |e0, _, e1| [:and, e0, e1, metadata] }
+      clause('expression OR expression') { |e0, _, e1| [:or, e0, e1, metadata] }
 
-      clause('expression PLUS expression') { |e0, _, e1| [:+, e0, e1] }
-      clause('expression SUB expression')  { |e0, _, e1| [:-, e0, e1] }
-      clause('expression MUL expression')  { |e0, _, e1| [:*, e0, e1] }
-      clause('expression DIV expression')  { |e0, _, e1| [:/, e0, e1] }
+      clause('expression PLUS expression') { |e0, _, e1| [:+, e0, e1, metadata] }
+      clause('expression SUB expression')  { |e0, _, e1| [:-, e0, e1, metadata] }
+      clause('expression MUL expression')  { |e0, _, e1| [:*, e0, e1, metadata] }
+      clause('expression DIV expression')  { |e0, _, e1| [:/, e0, e1, metadata] }
 
-      clause('BANG expression')           { |_, e0| [:not, e0] }
+      clause('BANG expression')           { |_, e0| [:not, e0, metadata] }
     end
 
     production(:expressions) do
@@ -62,5 +65,9 @@ class Kalculator
     end
 
     finalize()
+
+    def metadata(num_tokens)
+      {offset: pos(0).stream_offset..pos(num_tokens-1).stream_offset}
+    end
   end
 end

data/lib/kalculator/pointer.rb

@@ -0,0 +1,16 @@
+class Kalculator
+  class Pointer
+    attr_reader :p
+    def initialize( p)
+      @p = p
+    end
+  end
+
+  class AnonymousPointer
+    attr_reader :p
+
+    def initialize(p)
+      @p = p
+    end
+  end
+end

data/lib/kalculator/transform.rb

@@ -2,13 +2,18 @@ class Kalculator
   module Transform
     def self.run(node, &block)
       new_node = yield node
-      return new_node if is_terminal?(new_node)
-      args = new_node[1..-1].map{ |arg| run(arg, &block) }
-      args.unshift(new_node.first)
+      if is_terminal?(new_node)
+        new_node
+      elsif new_node.first.is_a?(Symbol)
+        args = new_node[1..-1].map{ |arg| run(arg, &block) }
+        args.unshift(new_node.first)
+      else
+        new_node.map{|node| run(node, &block) }
+      end
     end
 
     def self.is_terminal?(node)
-      return false if node.is_a?(Array) && node.first.is_a?(Symbol)
+      return false if node.is_a?(Array)
       true
     end
   end

data/lib/kalculator/type_sources.rb

@@ -0,0 +1,36 @@
+##
+#Author: Benjamin Walter Newhall, 12/17/19, github: bennewhall
+#Explanation: much like the data sources class, this stores type data in the form {"variable-name"=>String}
+##
+
+class Kalculator
+  class TypeSources
+
+    def initialize(*sources)# sources is an array of Hashes
+      @sources = sources
+    end
+
+    def key?(name)
+      ret = false
+      @sources.each do |source|
+        break ret = true if source.key?(name)
+      end
+      ret
+    end
+
+    def [](name)
+      ret = nil
+      @sources.each do |source|
+        break ret = source[name] if source.key?(name)
+      end
+      ret
+    end
+
+    #returns a hash of variable name to type of variable
+    def toHash
+      a = Hash.new
+      @sources.each { |i| a = a.merge(i)}
+      return a
+    end
+  end
+end

data/lib/kalculator/types.rb

@@ -0,0 +1,86 @@
+##
+#Author: Benjamin Walter Newhall 12/17/19 github: bennewhall
+#Explanation: A class that holds the types used for the validator
+##
+
+
+class Kalculator
+  class Comparable; end #A Type that can be used in <, >, etc. operations
+  class Number< Comparable; end #A Type that can be used in +,-,etc operations
+  class Percent < Number; end #a type of number
+  class Bool; end
+  class Time; end
+
+  #a generic collection type of type Collection<othertype> where othertype is stored in the type instance variable
+  class Collection
+    attr_reader :type
+    def initialize(type)
+      @type = type
+    end
+    def generic_type?(possible_type) #possibleType has to either be a collection or a type
+      if(possible_type.class <= Kalculator::Collection)
+        return possible_type.type <= @type
+      end
+      if(possible_type.class == Class)
+        return possible_type <= @type
+      end
+      return false
+    end
+
+    def ==(other_type) #othertype has to be a collection or a type
+      if(other_type.class <= self.class)
+          return other_type.type == self.type
+      end
+      return false
+    end
+
+    def <=(other_object) # otherobject has to be a collection, a type, or some other object
+      if(other_object.class <= Kalculator::Collection)
+        return ((self.class<= other_object.class) and (self.type <= other_object.type))
+      elsif(other_object.class == Class)
+        if(other_object == Object)
+          return true
+        end
+        return false
+      elsif(other_object.class != Class)
+        return false
+      end
+
+      return false
+    end
+
+    def >=(other_object) # otherobject has to be a collection, a type, or some other object
+      if(other_object.class <=Kalculator::Collection)
+        return other_object<= self
+      elsif(other_object.class == Class)
+        return false
+      elsif(other_object.class != Class)
+        return false
+      end
+
+      return false
+    end
+
+  end
+
+
+  class String < Collection #a collection that holds strings
+    def initialize()
+      super(String)
+    end
+  end
+
+  class List < Collection #a collection that holds one type of data
+    def initialize(type)
+      super(type)
+    end
+  end
+
+  class MappedObject < Collection #a collection that represents an object and holds any type of data
+    attr_reader :hash
+    def initialize(hash)
+      super(Object)
+      @hash = hash
+    end
+  end
+end

data/lib/kalculator/validator.rb

@@ -0,0 +1,240 @@
+##
+#Author: Benjamin Walter Newhall 12/17/19, github: bennewhall
+#Explanation: A class that will either return the ending type of an ast, or throw an error with metadata information about error position
+#Usage: v = Validator.new(typesource)       (typesource is a TypeSources object)
+#       v.validate(ast)                     (ast is the ast returned by parsing a line)(this will either return a type or throw an Error as described in the errors.rb file)
+##
+class Kalculator
+  class Validator
+    def initialize(type_source)
+      @type_source = type_source
+      #e stores built in function type data
+      #last index is ALWAYS the return type, and types before that are types of children from left to right
+      e = { "contains" => [Collection.new(Object), Object, Bool],
+        "count" => [List.new(Object), Number],
+        "date" => [String.new, Time],
+        "max"=> [Number,Number,Number],
+        "min" => [Number,Number,Number],
+        "sum" => [List.new(Number), Number] #this only accepts number Lists
+      }
+      @environment = e.merge(type_source.toHash)
+    end
+
+    def validate(ast)
+      send(ast.first, *ast)
+
+    end
+
+    def access(_,identifier,object, metadata)
+      objectType = validate(object)
+      if((objectType.is_a?(MappedObject)))
+        if(objectType.hash.key?(identifier))
+          attribute =objectType.hash[identifier]
+          if(attribute.is_a?(Pointer))
+            attribute = @environment[attribute.p] #if the attribute is a pointer find an add
+          end
+          if(attribute.is_a?(Kalculator::AnonymousPointer))
+            attribute = attribute.p
+          end
+          return attribute
+        end
+        raise UndefinedVariableError.new(metadata), "object #{objectType} doesn't have type attribute #{identifier}"
+      end
+      raise TypeError.new(metadata), "trying to access something that isn't an object"
+    end
+
+    def +(_, left, right, metadata)
+      leftType = validate(left)
+      if((leftType==validate(right)) and leftType <=Number)
+        return leftType
+      end
+    raise TypeError.new(metadata), "not operating on two of the same Number types"
+    end
+
+    def -(_, left, right, metadata)
+      leftType = validate(left)
+      if((leftType==validate(right)) and leftType <=Number)
+        return leftType
+      end
+    raise TypeError.new(metadata), "not operating on two of the same Number types"
+    end
+
+    def *(_, left, right, metadata)
+      leftType = validate(left)
+      if((leftType==validate(right)) and leftType <=Number)
+        return leftType
+      end
+    raise TypeError.new(metadata), "not operating on two of the same Number types"
+    end
+
+    def /(_, left, right, metadata)
+      leftType = validate(left)
+      if((leftType==validate(right)) and leftType <=Number)
+        return leftType
+      end
+    raise TypeError.new(metadata), "not operating on two of the same Number types"
+    end
+
+    def >(_, left, right, metadata)
+      leftType = validate(left)
+      if((leftType==validate(right)) and leftType<= Comparable)
+        return Bool
+      end
+    raise TypeError.new(metadata), "not comparing two of the same comparable types"
+    end
+
+    def >=(_, left, right, metadata)
+      leftType = validate(left)
+      if((leftType==validate(right)) and leftType<= Comparable)
+        return Bool
+      end
+    raise TypeError.new(metadata), "not comparing two of the same comparable types"
+    end
+
+    def <(_, left, right, metadata)
+      leftType = validate(left)
+      if((leftType==validate(right)) and leftType<= Comparable)
+        return Bool
+      end
+    raise TypeError.new(metadata), "not comparing two of the same types"
+    end
+
+    def <=(_, left, right, metadata)
+      leftType = validate(left)
+      if((leftType==validate(right)) and leftType<= Comparable)
+        return Bool
+      end
+    raise TypeError.new(metadata), "not comparing two of the same comparable types"
+    end
+
+    def ==(_, left, right, metadata)
+      leftType = validate(left)
+      if(leftType==validate(right))
+        return Bool
+      end
+    raise TypeError.new(metadata), "not comparing two of the same comparable types"
+    end
+
+    def !=(_, left, right, metadata)
+      leftType = validate(left)
+      if(leftType==validate(right))
+        return Bool
+      end
+    raise TypeError.new(metadata), "not comparing two of the same comparable types"
+    end
+
+    def and(_, left, right, metadata)
+      if(validate(left)<=Bool and validate(right)<=Bool)
+        return Bool
+      end
+    raise TypeError.new(metadata), "not comparing (AND) two BOOL types"
+    end
+
+    def or(_, left, right, metadata)
+      if(validate(left)<=Bool and validate(right)<=Bool)
+        return Bool
+      end
+    raise TypeError.new(metadata), "not comparing (OR) two BOOL types"
+    end
+
+    def boolean(_, boolean, type, metadata)
+      return Bool
+    end
+
+    def exists(_, variable, metadata)
+        return Bool
+    end
+
+    def fn_call(_, fn_name, expressions, metadata) #compare individually to make sure it is a subclass or class
+      ex =expressions.map{|expression| validate(expression) }
+      raise UndefinedVariableError.new(metadata), "undefined variable #{fn_name}" unless @environment.key?(fn_name)
+      argumentMatch = ex.zip(@environment[fn_name]).all? do |(arg_type, expected_type)|
+        begin
+          arg_type <= expected_type
+        rescue
+          begin
+            expected_type >= arg_type
+          rescue
+            false
+          end
+        end
+      end
+      if(argumentMatch) # make sure each element is related to corresponding element in the funcion params
+        if(fn_name == "max" or fn_name == "min") #add functions here where output type depends on input type and all types must be exact same ie. max(Percent,Percent) => Percent max(Number,Percent)=> Error max(Number,Number)=>Number
+          #check all expressions are same
+          cmptype = ex[0]
+          if( ex.all?{|t| t == cmptype})
+            return cmptype
+          end
+          raise TypeError.new(metadata), "specialized function type error"
+        end
+        #add other specialized functions here
+        if(fn_name == "contains") #generic function in the format List<E>, E => ReturnType
+          if(ex[0].generic_type?(ex[1]))
+            return @environment[fn_name][@environment[fn_name].size - 1]
+          end
+          raise TypeError.new(metadata), "generic function type error"
+        end
+        return @environment[fn_name][@environment[fn_name].size - 1]
+      end
+      raise TypeError.new(metadata), "function type error"
+    end
+
+    def if(_, condition, true_clause, false_clause, metadata)
+      conditionType = validate(condition)
+      if(conditionType <= Object and validate(true_clause)==validate(false_clause))
+        return validate(true_clause)
+      end
+    raise TypeError.new(metadata), "if statement type error"
+    end
+
+    def list(_, expressions, metadata)
+      ex =expressions.map{|expression| validate(expression) }
+
+      cmptype = ex[0]
+      if( ex.all?{|t| t == cmptype})
+        return List.new(cmptype)
+      end
+    raise TypeError.new(metadata), "list type error"
+
+    end
+
+    def not(_, expression, metadata)
+      if(validate(expression) ==Bool)
+        return Bool
+
+      end
+      raise TypeError.new(metadata), "NOT expression type error"
+    end
+
+    def null(_, _, type, metadata)
+      return type
+    end
+
+    def number(_, number, type, metadata)
+      return type
+    end
+
+    def percent(_, percent, type, metadata)
+      return type
+    end
+
+    def string(_, string, type, metadata)
+      return type
+    end
+
+    def variable(_, name, metadata)
+
+      raise UndefinedVariableError.new(metadata), "undefined variable #{name}" unless @environment.key?(name)
+      variable_type = @environment[name]
+      if(variable_type.is_a?(Pointer))
+        variable_type = @environment[variable_type.p] #if the variable you are accessing is a pointer, then return the type of the variable it is pointing to
+      end
+      if(variable_type.is_a?(Kalculator::AnonymousPointer))
+        variable_type = variable_type.p
+      end
+      return variable_type
+    end
+
+  end
+end

data/lib/kalculator/version.rb

@@ -1,3 +1,3 @@
 class Kalculator
-  VERSION = "0.6.4"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kalculator
 version: !ruby/object:Gem::Version
-  version: 0.6.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Michael Ries
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-16 00:00:00.000000000 Z
+date: 2019-12-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rltk
@@ -89,14 +89,18 @@ extra_rdoc_files: []
 files:
 - kalculator.gemspec
 - lib/kalculator.rb
+- lib/kalculator/built_in_functions.rb
 - lib/kalculator/data_sources.rb
 - lib/kalculator/errors.rb
 - lib/kalculator/evaluator.rb
 - lib/kalculator/formula.rb
 - lib/kalculator/lexer.rb
-- lib/kalculator/nested_lookup.rb
 - lib/kalculator/parser.rb
+- lib/kalculator/pointer.rb
 - lib/kalculator/transform.rb
+- lib/kalculator/type_sources.rb
+- lib/kalculator/types.rb
+- lib/kalculator/validator.rb
 - lib/kalculator/version.rb
 homepage: https://github.com/mmmries/kalculator
 licenses:
@@ -118,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.7.9
 signing_key: 
 specification_version: 4
 summary: A calculator that can safely and quickly interpret user-input

data/lib/kalculator/nested_lookup.rb

@@ -1,25 +0,0 @@
-class Kalculator
-  class NestedLookup
-    def initialize(data_source)
-      @data_source = data_source
-    end
-
-    def key?(name)
-      names = name.split(".")
-      source = @data_source
-      names.all? do |name|
-        break false unless source.key?(name)
-        source = source[name]
-        true
-      end
-    end
-
-    def [](name)
-      names = name.split(".")
-      names.inject(@data_source) do |source, name|
-        break nil unless source.key?(name)
-        source[name]
-      end
-    end
-  end
-end