keisan 0.2.1 → 0.3.0

data/lib/keisan/functions/default_registry.rb

@@ -14,7 +14,6 @@ module Keisan
 
       def self.register_defaults!(registry)
         register_builtin_math!(registry)
-        register_branch_methods!(registry)
         register_array_methods!(registry)
         register_random_methods!(registry)
       end
@@ -30,10 +29,6 @@ module Keisan
         end
       end
 
-      def self.register_branch_methods!(registry)
-        registry.register!(:if, Proc.new {|bool, a, b=nil| bool ? a : b })
-      end
-
       def self.register_array_methods!(registry)
         %i(min max size).each do |method|
           registry.register!(method, Proc.new {|a| a.send(method)})

data/lib/keisan/functions/registry.rb

@@ -18,6 +18,13 @@ module Keisan
         raise Keisan::Exceptions::UndefinedFunctionError.new name
       end
 
+      def has?(name)
+        !!self[name]
+      rescue Keisan::Exceptions::UndefinedFunctionError
+        false
+      end
+
+      # For checking if locally defined
       def has_name?(name)
         @hash.has_key?(name)
       end

data/lib/keisan/parser.rb

@@ -73,12 +73,35 @@ module Keisan
         # Here it is a postfix Indexing (access elements by index)
         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
           add_operator_to_components!(token)
         end
 
+      elsif @components[-1].is_a?(Parsing::Dot)
+        # Expect a word
+        case token.type
+        when :word
+          @components[-1] = Parsing::DotWord.new(token.string)
+        else
+          raise Keisan::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
+          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
+          add_indexing_to_components!(token)
+        else
+          raise Keisan::Exceptions::ParseError.new("Expected arguments to dot operator, received #{token.string}")
+        end
       else
         raise Keisan::Exceptions::ParseError.new("Token cannot be parsed, #{token.string}")
       end
@@ -120,15 +143,7 @@ module Keisan
         when :round
           @components << Keisan::Parsing::RoundGroup.new(token.sub_tokens)
         when :square
-          @components << if token.sub_tokens.empty?
-                           Parsing::List.new([])
-                         else
-                           Parsing::List.new(
-                             token.sub_tokens.split {|sub_token| sub_token.is_a?(Keisan::Tokens::Comma)}.map do |sub_tokens|
-                               Parsing::Argument.new(sub_tokens)
-                             end
-                           )
-                         end
+          @components << Parsing::List.new(arguments_from_group(token))
         else
           raise Keisan::Exceptions::ParseError.new("Unhandled group type #{token.group_type}")
         end
@@ -150,6 +165,8 @@ module Keisan
         @components << Keisan::Parsing::Divide.new
       when :**
         @components << Keisan::Parsing::Exponent.new
+      when :%
+        @components << Keisan::Parsing::Modulo.new
       # Bitwise
       when :"&"
         @components << Keisan::Parsing::BitwiseAnd.new
@@ -162,6 +179,10 @@ module Keisan
       when :"~~"
         @components << Keisan::Parsing::BitwiseNotNot.new
       # Logical
+      when :"=="
+        @components << Keisan::Parsing::LogicalEqual.new
+      when :"!="
+        @components << Keisan::Parsing::LogicalNotEqual.new
       when :"&&"
         @components << Keisan::Parsing::LogicalAnd.new
       when :"||"
@@ -184,30 +205,22 @@ module Keisan
     end
 
     def add_function_to_components!(token)
-      # Have a function actually, not a variable
-      if token.sub_tokens.empty?
-        @components[-1] = Parsing::Function.new(@components[-1].name, [])
-      else
-        @components[-1] = Parsing::Function.new(
-          @components[-1].name,
-          token.sub_tokens.split {|sub_token| sub_token.is_a?(Keisan::Tokens::Comma)}.map do |sub_tokens|
-            Parsing::Argument.new(sub_tokens)
-          end
-        )
-      end
+      @components[-1] = Parsing::Function.new(@components[-1].name, arguments_from_group(token))
     end
 
     def add_indexing_to_components!(token)
       # Have an indexing
-      @components << if token.sub_tokens.empty?
-                       Parsing::Indexing.new([])
-                     else
-                       Parsing::Indexing.new(
-                         token.sub_tokens.split {|sub_token| sub_token.is_a?(Keisan::Tokens::Comma)}.map do |sub_tokens|
-                           Parsing::Argument.new(sub_tokens)
-                         end
-                       )
-                     end
+      @components << Parsing::Indexing.new(arguments_from_group(token))
+    end
+
+    def arguments_from_group(token)
+      if token.sub_tokens.empty?
+        []
+      else
+        token.sub_tokens.split {|sub_token| sub_token.is_a?(Keisan::Tokens::Comma)}.map do |sub_tokens|
+          Parsing::Argument.new(sub_tokens)
+        end
+      end
     end
   end
 end

data/lib/keisan/parsing/dot.rb

@@ -0,0 +1,6 @@
+module Keisan
+  module Parsing
+    class Dot < Component
+    end
+  end
+end

data/lib/keisan/parsing/dot_operator.rb

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

data/lib/keisan/parsing/dot_word.rb

@@ -0,0 +1,14 @@
+module Keisan
+  module Parsing
+    class DotWord < Component
+      attr_reader :name
+      def initialize(name)
+        @name = name
+      end
+
+      def arguments
+        []
+      end
+    end
+  end
+end

data/lib/keisan/parsing/logical_equal.rb

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

data/lib/keisan/parsing/logical_not_equal.rb

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

data/lib/keisan/parsing/modulo.rb

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

data/lib/keisan/tokenizer.rb

@@ -10,7 +10,8 @@ module Keisan
       Tokens::ArithmeticOperator,
       Tokens::LogicalOperator,
       Tokens::BitwiseOperator,
-      Tokens::Comma
+      Tokens::Comma,
+      Tokens::Dot
     ]
 
     TOKEN_REGEX = Regexp::new(

data/lib/keisan/tokens/arithmetic_operator.rb

@@ -4,8 +4,9 @@ module Keisan
       EXPONENT = /(?:\*\*)/
       TIMES = /(?:\*)/
       DIVIDE = /(?:\/)/
+      MODULO = /(?:\%)/
       PLUS_OR_MINUS = /(?:[\+\-]+)/
-      REGEX = /(#{EXPONENT}|#{TIMES}|#{DIVIDE}|#{PLUS_OR_MINUS})/
+      REGEX = /(#{EXPONENT}|#{TIMES}|#{DIVIDE}|#{MODULO}|#{PLUS_OR_MINUS})/
 
       def self.regex
         REGEX
@@ -20,6 +21,8 @@ module Keisan
           :*
         when DIVIDE
           :/
+        when MODULO
+          :%
         when PLUS_OR_MINUS
           string.count("-").even? ? :+ : :-
         end

data/lib/keisan/tokens/dot.rb

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

data/lib/keisan/tokens/logical_operator.rb

@@ -7,9 +7,11 @@ module Keisan
       GREATER_THAN = /(?:\>)/
       AND = /(?:\&\&)/
       OR = /(?:\|\|)/
+      EQUAL = /(?:\=\=)/
+      NOT_EQUAL = /(?:\!\=)/
       NOT = /(?:\!+)/
 
-      REGEX = /(#{LESS_THAN_OR_EQUAL_TO}|#{GREATER_THAN_OR_EQUAL_TO}|#{LESS_THAN}|#{GREATER_THAN}|#{AND}|#{OR}|#{NOT})/
+      REGEX = /(#{LESS_THAN_OR_EQUAL_TO}|#{GREATER_THAN_OR_EQUAL_TO}|#{LESS_THAN}|#{GREATER_THAN}|#{AND}|#{OR}|#{EQUAL}|#{NOT_EQUAL}|#{NOT})/
 
       def self.regex
         REGEX
@@ -29,6 +31,10 @@ module Keisan
           :"&&"
         when OR
           :"||"
+        when EQUAL
+          :"=="
+        when NOT_EQUAL
+          :"!="
         when NOT
           string.count("!").even? ? :"!!" : :"!"
         end

data/lib/keisan/variables/registry.rb

@@ -18,6 +18,13 @@ module Keisan
         raise Keisan::Exceptions::UndefinedVariableError.new name
       end
 
+      def has?(name)
+        !!self[name]
+      rescue Keisan::Exceptions::UndefinedVariableError
+        false
+      end
+
+      # For checking if locally defined
       def has_name?(name)
         @hash.has_key?(name)
       end

data/lib/keisan/version.rb

@@ -1,3 +1,3 @@
 module Keisan
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: keisan
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Christopher Locke
@@ -125,18 +125,22 @@ files:
 - lib/keisan/ast/list.rb
 - lib/keisan/ast/literal.rb
 - lib/keisan/ast/logical_and.rb
+- lib/keisan/ast/logical_equal.rb
 - lib/keisan/ast/logical_greater_than.rb
 - lib/keisan/ast/logical_greater_than_or_equal_to.rb
 - lib/keisan/ast/logical_less_than.rb
 - lib/keisan/ast/logical_less_than_or_equal_to.rb
+- lib/keisan/ast/logical_not_equal.rb
 - lib/keisan/ast/logical_operator.rb
 - lib/keisan/ast/logical_or.rb
+- lib/keisan/ast/modulo.rb
 - lib/keisan/ast/node.rb
 - lib/keisan/ast/null.rb
 - lib/keisan/ast/number.rb
 - lib/keisan/ast/operator.rb
 - lib/keisan/ast/parent.rb
 - lib/keisan/ast/plus.rb
+- lib/keisan/ast/priorities.rb
 - lib/keisan/ast/string.rb
 - lib/keisan/ast/times.rb
 - lib/keisan/ast/unary_bitwise_not.rb
@@ -149,6 +153,7 @@ files:
 - lib/keisan/ast/variable.rb
 - lib/keisan/calculator.rb
 - lib/keisan/context.rb
+- lib/keisan/evaluator.rb
 - lib/keisan/exceptions.rb
 - lib/keisan/function.rb
 - lib/keisan/functions/default_registry.rb
@@ -167,6 +172,9 @@ files:
 - lib/keisan/parsing/boolean.rb
 - lib/keisan/parsing/component.rb
 - lib/keisan/parsing/divide.rb
+- lib/keisan/parsing/dot.rb
+- lib/keisan/parsing/dot_operator.rb
+- lib/keisan/parsing/dot_word.rb
 - lib/keisan/parsing/element.rb
 - lib/keisan/parsing/exponent.rb
 - lib/keisan/parsing/function.rb
@@ -174,15 +182,18 @@ files:
 - lib/keisan/parsing/indexing.rb
 - lib/keisan/parsing/list.rb
 - lib/keisan/parsing/logical_and.rb
+- lib/keisan/parsing/logical_equal.rb
 - lib/keisan/parsing/logical_greater_than.rb
 - lib/keisan/parsing/logical_greater_than_or_equal_to.rb
 - lib/keisan/parsing/logical_less_than.rb
 - lib/keisan/parsing/logical_less_than_or_equal_to.rb
 - lib/keisan/parsing/logical_not.rb
+- lib/keisan/parsing/logical_not_equal.rb
 - lib/keisan/parsing/logical_not_not.rb
 - lib/keisan/parsing/logical_operator.rb
 - lib/keisan/parsing/logical_or.rb
 - lib/keisan/parsing/minus.rb
+- lib/keisan/parsing/modulo.rb
 - lib/keisan/parsing/null.rb
 - lib/keisan/parsing/number.rb
 - lib/keisan/parsing/operator.rb
@@ -201,6 +212,7 @@ files:
 - lib/keisan/tokens/bitwise_operator.rb
 - lib/keisan/tokens/boolean.rb
 - lib/keisan/tokens/comma.rb
+- lib/keisan/tokens/dot.rb
 - lib/keisan/tokens/group.rb
 - lib/keisan/tokens/logical_operator.rb
 - lib/keisan/tokens/null.rb
@@ -231,7 +243,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: An equation parser and evaluator