template-ruby 0.1.0 → 0.2.2

data/lib/code/node/dictionnary.rb

@@ -1,16 +1,20 @@
 class Code
   class Node
-    class Dictionnary
+    class Dictionnary < Node
       def initialize(key_values)
-        @key_values =
-          key_values.map do |key_value|
-            ::Code::Node::DictionnaryKeyValue.new(key_value)
-          end
+        if key_values.blank?
+          @key_values = []
+        else
+          @key_values =
+            key_values.map do |key_value|
+              ::Code::Node::DictionnaryKeyValue.new(key_value)
+            end
+        end
       end
 
-      def evaluate(context)
+      def evaluate(**args)
         ::Code::Object::Dictionnary.new(
-          @key_values.map { |key_value| key_value.evaluate(context) }.to_h
+          @key_values.map { |key_value| key_value.evaluate(**args) }.to_h,
         )
       end
     end

data/lib/code/node/dictionnary_key_value.rb

@@ -1,6 +1,6 @@
 class Code
   class Node
-    class DictionnaryKeyValue
+    class DictionnaryKeyValue < Node
       def initialize(key_value)
         @key = key_value.fetch(:key)
 
@@ -15,8 +15,8 @@ class Code
         @value = ::Code::Node::Code.new(key_value.fetch(:value))
       end
 
-      def evaluate(context)
-        [@key.evaluate(context), @value.evaluate(context)]
+      def evaluate(**args)
+        [@key.evaluate(**args), @value.evaluate(**args)]
       end
     end
   end

data/lib/code/node/equal.rb

@@ -0,0 +1,36 @@
+class Code
+  class Node
+    class Equal < Node
+      def initialize(equal)
+        @left = equal.fetch(:left).fetch(:name)
+        @operator = equal.fetch(:operator)
+        @right = ::Code::Node::Statement.new(equal.fetch(:right))
+      end
+
+      def evaluate(**args)
+        right = @right.evaluate(**args)
+        context = args.fetch(:context)
+
+        if operator
+          if context[left]
+            context[left] = simple_call(context[left], operator, right, **args)
+          else
+            raise ::Code::Error::UndefinedVariable.new("#{left} is undefined")
+          end
+        else
+          context[left] = right
+        end
+      end
+
+      private
+
+      def operator
+        @operator.to_s[0...-1].to_sym.presence
+      end
+
+      def left
+        ::Code::Object::String.new(@left.to_s)
+      end
+    end
+  end
+end

data/lib/code/node/function.rb

@@ -0,0 +1,17 @@
+class Code
+  class Node
+    class Function < Node
+      def initialize(function)
+        @body = ::Code::Node::Code.new(function.fetch(:body))
+        @arguments = function.fetch(:arguments, [])
+        @arguments.map! do |argument|
+          ::Code::Node::FunctionArgument.new(argument)
+        end
+      end
+
+      def evaluate(**args)
+        ::Code::Object::Function.new(arguments: @arguments, body: @body)
+      end
+    end
+  end
+end

data/lib/code/node/function_argument.rb

@@ -0,0 +1,45 @@
+class Code
+  class Node
+    class FunctionArgument < Node
+      def initialize(argument)
+        if argument.key?(:regular)
+          @argument =
+            ::Code::Node::RegularFunctionArgument.new(argument.fetch(:regular))
+        elsif argument.key?(:keyword)
+          @argument =
+            ::Code::Node::KeywordFunctionArgument.new(argument.fetch(:keyword))
+        else
+          raise NotImplementedError.new(argument.inspect)
+        end
+      end
+
+      def evaluate(**args)
+        @argument.evaluate(**args)
+      end
+
+      def splat?
+        @argument.splat?
+      end
+
+      def keyword_splat?
+        @argument.keyword_splat?
+      end
+
+      def name
+        @argument.name
+      end
+
+      def block?
+        @argument.block?
+      end
+
+      def regular?
+        @argument.is_a?(::Code::Node::RegularFunctionArgument)
+      end
+
+      def keyword?
+        @argument.is_a?(::Code::Node::KeywordFunctionArgument)
+      end
+    end
+  end
+end

data/lib/code/node/group.rb

@@ -0,0 +1,13 @@
+class Code
+  class Node
+    class Group < Node
+      def initialize(group)
+        @code = ::Code::Node::Code.new(group)
+      end
+
+      def evaluate(**args)
+        @code.evaluate(**args)
+      end
+    end
+  end
+end

data/lib/code/node/if.rb

@@ -0,0 +1,55 @@
+class Code
+  class Node
+    class If < Node
+      IF_KEYWORD = "if"
+      UNLESS_KEYWORD = "unless"
+
+      class Else
+        def initialize(else_parsed)
+          if else_parsed.key?(:operator)
+            @operator = else_parsed.fetch(:operator)
+            @statement =
+              ::Code::Node::Statement.new(else_parsed.fetch(:statement))
+          end
+
+          @body = ::Code::Node::Code.new(else_parsed.fetch(:body))
+        end
+
+        attr_reader :operator, :body, :statement
+      end
+
+      def initialize(if_parsed)
+        @if_operator = if_parsed.fetch(:if_operator)
+        @if_statement =
+          ::Code::Node::Statement.new(if_parsed.fetch(:if_statement))
+        @if_body = ::Code::Node::Code.new(if_parsed.fetch(:if_body))
+        @elses = if_parsed.fetch(:elses, [])
+        @elses.map! { |else_parsed| ::Code::Node::If::Else.new(else_parsed) }
+      end
+
+      def evaluate(**args)
+        if_object = @if_statement.evaluate(**args)
+
+        if @if_operator == IF_KEYWORD && if_object.truthy?
+          @if_body.evaluate(**args)
+        elsif @if_operator == UNLESS_KEYWORD && if_object.falsy?
+          @if_body.evaluate(**args)
+        else
+          @elses.each do |else_node|
+            if else_node.operator == IF_KEYWORD
+              else_object = else_node.statement.evaluate(**args)
+              return else_node.body.evaluate(**args) if else_object.truthy?
+            elsif else_node.operator == UNLESS_KEYWORD
+              else_object = else_node.statement.evaluate(**args)
+              return else_node.body.evaluate(**args) if else_object.falsy?
+            elsif else_node.operator.nil?
+              return else_node.body.evaluate(**args)
+            end
+          end
+
+          ::Code::Object::Nothing.new
+        end
+      end
+    end
+  end
+end

data/lib/code/node/if_modifier.rb

@@ -0,0 +1,48 @@
+class Code
+  class Node
+    class IfModifier < Node
+      IF_KEYWORD = :if
+      UNLESS_KEYWORD = :unless
+      WHILE_KEYWORD = :while
+      UNTIL_KEYWORD = :until
+
+      def initialize(if_modifier)
+        @left = ::Code::Node::Statement.new(if_modifier.fetch(:left))
+        @operator = if_modifier.fetch(:operator)
+        @right = ::Code::Node::Statement.new(if_modifier.fetch(:right))
+      end
+
+      def evaluate(**args)
+        if operator == IF_KEYWORD
+          right = @right.evaluate(**args)
+
+          right.truthy? ? @left.evaluate(**args) : ::Code::Object::Nothing.new
+        elsif operator == UNLESS_KEYWORD
+          right = @right.evaluate(**args)
+
+          right.truthy? ? ::Code::Object::Nothing.new : @left.evaluate(**args)
+        elsif operator == WHILE_KEYWORD
+          left = ::Code::Object::Nothing.new
+
+          left = @left.evaluate(**args) while @right.evaluate(**args).truthy?
+
+          left
+        elsif operator == UNTIL_KEYWORD
+          left = ::Code::Object::Nothing.new
+
+          left = @left.evaluate(**args) until @right.evaluate(**args).truthy?
+
+          left
+        else
+          raise NotImplementedError.new(operator.inspect)
+        end
+      end
+
+      private
+
+      def operator
+        @operator.to_sym
+      end
+    end
+  end
+end

data/lib/code/node/keyword_call_argument.rb

@@ -0,0 +1,30 @@
+class Code
+  class Node
+    class KeywordCallArgument < Node
+      def initialize(argument)
+        @name = argument.fetch(:name)
+        @value = ::Code::Node::Code.new(argument.fetch(:value))
+      end
+
+      def evaluate(**args)
+        @value.evaluate(**args)
+      end
+
+      def name
+        ::Code::Object::String.new(@name.to_s)
+      end
+
+      def block?
+        false
+      end
+
+      def splat?
+        false
+      end
+
+      def keyword_splat?
+        false
+      end
+    end
+  end
+end

data/lib/code/node/keyword_function_argument.rb

@@ -0,0 +1,33 @@
+class Code
+  class Node
+    class KeywordFunctionArgument < Node
+      def initialize(argument)
+        @name = argument.fetch(:name)
+
+        if argument.key?(:default)
+          @default = ::Code::Node::Code.new(argument.fetch(:default))
+        end
+      end
+
+      def evaluate(**args)
+        @default ? @default.evaluate(**args) : ::Code::Object::Nothing.new
+      end
+
+      def name
+        ::Code::Object::String.new(@name.to_s)
+      end
+
+      def splat?
+        false
+      end
+
+      def keyword_splat?
+        false
+      end
+
+      def block?
+        false
+      end
+    end
+  end
+end

data/lib/code/node/list.rb

@@ -1,12 +1,18 @@
 class Code
   class Node
-    class List
+    class List < Node
       def initialize(codes)
-        @codes = codes.map { |code| ::Code::Node::Code.new(code[:code]) }
+        @codes =
+          codes
+            .map do |code|
+              code.fetch(:code).presence &&
+                ::Code::Node::Code.new(code.fetch(:code))
+            end
+            .compact
       end
 
-      def evaluate(context)
-        ::Code::Object::List.new(@codes.map { |code| code.evaluate(context) })
+      def evaluate(**args)
+        ::Code::Object::List.new(@codes.map { |code| code.evaluate(**args) })
       end
     end
   end

data/lib/code/node/name.rb

@@ -1,17 +1,50 @@
 class Code
   class Node
-    class Name
+    class Name < Node
       def initialize(name)
         @name = name
       end
 
-      def evaluate(context)
-        context.fetch(::Code::Object::String.new(name.to_s))
+      def evaluate(**args)
+        context = args.fetch(:context)
+        arguments = args.fetch(:arguments, [])
+        object = args.fetch(:object, nil)
+        io = args.fetch(:io)
+
+        if object
+          object.call(
+            context: context,
+            operator: name,
+            arguments: arguments,
+            io: io,
+          )
+        elsif context.key?(name)
+          object = context[name]
+
+          if object.is_a?(::Code::Object::Function)
+            object.call(
+              context: context,
+              operator: nil,
+              arguments: arguments,
+              io: io,
+            )
+          else
+            object
+          end
+        elsif name == "puts"
+          arguments.each { |argument| io.puts argument.value }
+
+          ::Code::Object::Nothing.new
+        else
+          raise ::Code::Error::Undefined.new("#{name} undefined")
+        end
       end
 
       private
 
-      attr_reader :name
+      def name
+        ::Code::Object::String.new(@name.to_s)
+      end
     end
   end
 end

data/lib/code/node/negation.rb

@@ -0,0 +1,33 @@
+class Code
+  class Node
+    class Negation < Node
+      EXCLAMATION_POINT = "!"
+      PLUS = "+"
+
+      def initialize(negation)
+        @operator = negation.fetch(:operator)
+        @statement = ::Code::Node::Statement.new(negation.fetch(:statement))
+      end
+
+      def evaluate(**args)
+        object = @statement.evaluate(**args)
+
+        if operator == EXCLAMATION_POINT
+          if object.truthy?
+            ::Code::Object::Boolean.new(false)
+          else
+            ::Code::Object::Boolean.new(true)
+          end
+        elsif operator == PLUS
+          object
+        else
+          raise NotImplementedError.new(operator)
+        end
+      end
+
+      private
+
+      attr_reader :operator
+    end
+  end
+end

data/lib/code/node/not_keyword.rb

@@ -0,0 +1,13 @@
+class Code
+  class Node
+    class NotKeyword < Node
+      def initialize(not_keyword)
+        @statement = ::Code::Node::Statement.new(not_keyword)
+      end
+
+      def evaluate(**args)
+        ::Code::Object::Boolean.new(!@statement.evaluate(**args).truthy?)
+      end
+    end
+  end
+end

data/lib/code/node/nothing.rb

@@ -1,10 +1,10 @@
 class Code
   class Node
-    class Nothing
+    class Nothing < Node
       def initialize
       end
 
-      def evaluate(_context)
+      def evaluate(**args)
         ::Code::Object::Nothing.new
       end
     end

data/lib/code/node/number.rb

@@ -1,6 +1,6 @@
 class Code
   class Node
-    class Number
+    class Number < Node
       def initialize(number)
         if number.key?(:base_2)
           @number = ::Code::Node::Base2Number.new(number[:base_2])
@@ -15,8 +15,8 @@ class Code
         end
       end
 
-      def evaluate(context)
-        @number.evaluate(context)
+      def evaluate(**args)
+        @number.evaluate(**args)
       end
     end
   end

data/lib/code/node/operation.rb

@@ -0,0 +1,33 @@
+class Code
+  class Node
+    class Operation < Node
+      class Operation
+        attr_reader :operator, :statement
+
+        def initialize(operation)
+          @operator = operation.fetch(:operator).to_s
+          @statement = ::Code::Node::Statement.new(operation.fetch(:statement))
+        end
+      end
+
+      def initialize(operation)
+        @first = ::Code::Node::Statement.new(operation.fetch(:first))
+        @rest = operation.fetch(:rest)
+        @rest.map! do |operation|
+          ::Code::Node::Operation::Operation.new(operation)
+        end
+      end
+
+      def evaluate(**args)
+        object = @first.evaluate(**args)
+
+        @rest.each do |operation|
+          other = operation.statement.evaluate(**args)
+          object = simple_call(object, operation.operator, other, **args)
+        end
+
+        object
+      end
+    end
+  end
+end

data/lib/code/node/or_keyword.rb

@@ -0,0 +1,34 @@
+class Code
+  class Node
+    class OrKeyword < Node
+      OR_KEYWORD = "or"
+      AND_KEYWORD = "and"
+
+      def initialize(or_keyword)
+        @first = ::Code::Node::Statement.new(or_keyword.fetch(:first))
+        @rest = or_keyword.fetch(:rest)
+        @rest.map! do |operation|
+          ::Code::Node::Operation::Operation.new(operation)
+        end
+      end
+
+      def evaluate(**args)
+        object = @first.evaluate(**args)
+
+        @rest.each do |operation|
+          if operation.operator == OR_KEYWORD
+            return object if object.truthy?
+          elsif operation.operator == AND_KEYWORD
+            return object unless object.truthy?
+          else
+            raise NotImplementedError.new(operation.operator.inspect)
+          end
+
+          object = operation.statement.evaluate(**args)
+        end
+
+        object
+      end
+    end
+  end
+end

data/lib/code/node/power.rb

@@ -0,0 +1,16 @@
+class Code
+  class Node
+    class Power < Node
+      def initialize(power)
+        @left = ::Code::Node::Statement.new(power.fetch(:left))
+        @right = ::Code::Node::Statement.new(power.fetch(:right))
+      end
+
+      def evaluate(**args)
+        right = @right.evaluate(**args)
+        left = @left.evaluate(**args)
+        simple_call(left, :**, right, **args)
+      end
+    end
+  end
+end

data/lib/code/node/range.rb

@@ -0,0 +1,31 @@
+class Code
+  class Node
+    class Range < Node
+      INCLUSIVE_RANGE = ".."
+      EXCLUSIVE_RANGE = "..."
+
+      def initialize(range)
+        @left = ::Code::Node::Statement.new(range.fetch(:left))
+        @operator = range.fetch(:operator)
+        @right = ::Code::Node::Statement.new(range.fetch(:right))
+      end
+
+      def evaluate(**args)
+        left = @left.evaluate(**args)
+        right = @right.evaluate(**args)
+
+        if operator == INCLUSIVE_RANGE
+          ::Code::Object::Range.new(left, right, exclude_end: false)
+        elsif operator == EXCLUSIVE_RANGE
+          ::Code::Object::Range.new(left, right, exclude_end: true)
+        else
+          raise NotImplementedError.new(operator)
+        end
+      end
+
+      private
+
+      attr_reader :operator
+    end
+  end
+end

data/lib/code/node/regular_call_argument.rb

@@ -0,0 +1,34 @@
+class Code
+  class Node
+    class RegularCallArgument < Node
+      def initialize(argument)
+        @splat = argument.key?(:splat)
+        @keyword_splat = argument.key?(:keyword_splat)
+        @block = argument.key?(:block)
+        @value = ::Code::Node::Code.new(argument.fetch(:value))
+      end
+
+      def evaluate(**args)
+        object = @value.evaluate(**args)
+
+        block? ? simple_call(object, :to_function, **args) : object
+      end
+
+      def block?
+        @block
+      end
+
+      def splat?
+        @splat
+      end
+
+      def keyword_splat?
+        @keyword_splat
+      end
+
+      def name
+        nil
+      end
+    end
+  end
+end

data/lib/code/node/regular_function_argument.rb

@@ -0,0 +1,36 @@
+class Code
+  class Node
+    class RegularFunctionArgument < Node
+      def initialize(argument)
+        @block = argument.key?(:block)
+        @splat = argument.key?(:splat)
+        @keyword_splat = argument.key?(:keyword_splat)
+        @name = argument.fetch(:name)
+
+        if argument.key?(:default)
+          @default = ::Code::Node::Code.new(argument.fetch(:default))
+        end
+      end
+
+      def evaluate(**args)
+        @default ? @default.evaluate(**args) : ::Code::Object::Nothing.new
+      end
+
+      def name
+        ::Code::Object::String.new(@name.to_s)
+      end
+
+      def splat?
+        @splat
+      end
+
+      def keyword_splat?
+        @keyword_splat
+      end
+
+      def block?
+        @block
+      end
+    end
+  end
+end