code-ruby 0.4.0 → 0.5.1

data/lib/code/node/boolean.rb

@@ -1,20 +1,20 @@
 class Code
   class Node
     class Boolean < Node
-      TRUE = "true"
-      FALSE = "false"
+      TRUE_KEYWORD = "true"
+      FALSE_KEYWORD = "false"
 
-      def initialize(boolean)
-        @boolean = boolean
+      def initialize(parsed)
+        @boolean = parsed
       end
 
       def evaluate(**args)
-        if @boolean == TRUE
+        if @boolean == TRUE_KEYWORD
           ::Code::Object::Boolean.new(true)
-        elsif @boolean == FALSE
+        elsif @boolean == FALSE_KEYWORD
           ::Code::Object::Boolean.new(false)
         else
-          raise NotImplementedError, @boolean.inspect
+          raise NotImplementedError.new(@boolean)
         end
       end
     end

data/lib/code/node/call.rb

@@ -1,52 +1,46 @@
 class Code
   class Node
     class Call < Node
-      def initialize(call)
-        @left = ::Code::Node::Statement.new(call.fetch(:left))
+      class Block < Node
+        def initialize(parsed)
+          @parameters =
+            parsed
+              .delete(:parameters) { [] }
+              .map { |parameter| Node::FunctionParameter.new(parameter) }
 
-        @arguments = call.fetch(:arguments, [])
-        @arguments.map! { |argument| ::Code::Node::CallArgument.new(argument) }
+          @body = Node::Code.new(parsed.delete(:body))
 
-        if call.key?(:right)
-          @right =
-            call
-              .fetch(:right)
-              .map { |right| ::Code::Node::ChainedCall.new(right) }
+          super(parsed)
         end
 
-        if call.key?(:block)
-          @block = ::Code::Node::Block.new(call.fetch(:block))
+        def evaluate(**args)
+          ::Code::Object::Argument.new(
+            ::Code::Object::Function.new(parameters: @parameters, body: @body)
+          )
         end
       end
 
-      def evaluate(**args)
-        if @right
-          left = @left.evaluate(**args)
-
-          @right.reduce(left) do |acc, element|
-            element.evaluate(**args.merge(object: acc))
-          end
-        else
-          arguments =
-            @arguments.map do |argument|
-              ::Code::Object::Argument.new(
-                argument.evaluate(**args),
-                name: argument.name,
-                splat: argument.splat?,
-                keyword_splat: argument.keyword_splat?,
-                block: argument.block?,
-              )
-            end
-
-          if @block
-            arguments << ::Code::Object::Argument.new(
-              @block.evaluate(**args),
-              block: true,
-            )
-          end
-
-          @left.evaluate(**args.merge(arguments: arguments))
+      def initialize(parsed)
+        @name = parsed.delete(:name)
+        @arguments =
+          parsed
+            .delete(:arguments) { [] }
+            .map { |argument| Node::CallArgument.new(argument) }
+
+        if parsed.key?(:block)
+          @block = Node::Call::Block.new(parsed.delete(:block))
         end
+
+        super(parsed)
+      end
+
+      def evaluate(**args)
+        arguments = @arguments.map { |argument| argument.evaluate(**args) }
+        arguments << @block.evaluate(**args) if @block
+
+        name = ::Code::Object::String.new(@name)
+
+        args.fetch(:object).call(operator: name, arguments: arguments, **args)
       end
     end
   end

data/lib/code/node/call_argument.rb

@@ -1,36 +1,20 @@
 class Code
   class Node
     class CallArgument < Node
-      def initialize(argument)
-        if argument.key?(:regular)
-          @argument =
-            ::Code::Node::RegularCallArgument.new(argument.fetch(:regular))
-        elsif argument.key?(:keyword)
-          @argument =
-            ::Code::Node::KeywordCallArgument.new(argument.fetch(:keyword))
-        else
-          raise NotImplementedError.new(argument.inspect)
-        end
+      def initialize(parsed)
+        @value = Node::Code.new(parsed.delete(:value))
+        @name = parsed.delete(:name)
       end
 
       def evaluate(**args)
-        @argument.evaluate(**args)
-      end
-
-      def name
-        @argument.name
-      end
-
-      def block?
-        @argument.block?
-      end
-
-      def splat?
-        @argument.splat?
-      end
-
-      def keyword_splat?
-        @argument.keyword_splat?
+        if @name
+          ::Code::Object::Argument.new(
+            @value.evaluate(**args),
+            name: ::Code::Object::String.new(@name)
+          )
+        else
+          ::Code::Object::Argument.new(@value.evaluate(**args))
+        end
       end
     end
   end

data/lib/code/node/chained_call.rb

@@ -1,39 +1,22 @@
 class Code
   class Node
     class ChainedCall < Node
-      def initialize(chained_call)
-        @name = ::Code::Node::Name.new(chained_call.fetch(:name))
+      def initialize(parsed)
+        @first = Node::Statement.new(parsed.delete(:first))
+        @others =
+          parsed
+            .delete(:others)
+            .map { |operator| Node::Statement.new(operator) }
 
-        @arguments = chained_call.fetch(:arguments, [])
-        @arguments.map! { |argument| ::Code::Node::CallArgument.new(argument) }
-
-        if chained_call.key?(:block)
-          @block = ::Code::Node::Block.new(chained_call.fetch(:block))
-        end
+        super(parsed)
       end
 
       def evaluate(**args)
-        arguments =
-          @arguments.map do |argument|
-            ::Code::Object::Argument.new(
-              argument.evaluate(
-                **args.merge(object: ::Code::Object::Global.new),
-              ),
-              name: argument.name,
-              splat: argument.splat?,
-              keyword_splat: argument.keyword_splat?,
-              block: argument.block?,
-            )
-          end
+        first = @first.evaluate(**args)
 
-        if @block
-          arguments << ::Code::Object::Argument.new(
-            @block.evaluate(**args.merge(object: ::Code::Object::Global.new)),
-            block: true,
-          )
+        @others.reduce(first) do |acc, element|
+          element.evaluate(**args.merge(object: acc))
         end
-
-        @name.evaluate(**args.merge(arguments: arguments))
       end
     end
   end

data/lib/code/node/code.rb

@@ -1,18 +1,16 @@
 class Code
   class Node
     class Code < Node
-      def initialize(statements)
-        statements = [] if statements.to_s.blank?
-
-        @statements =
-          statements.map { |statement| ::Code::Node::Statement.new(statement) }
+      def initialize(parsed)
+        @statements = parsed.map { |statement| Node::Statement.new(statement) }
       end
 
       def evaluate(**args)
         last = ::Code::Object::Nothing.new
 
         @statements.each do |statement|
-          last = statement.evaluate(**args)
+          last =
+            statement.evaluate(**args.merge(object: ::Code::Object::Global.new))
         end
 
         last

data/lib/code/node/decimal.rb

@@ -0,0 +1,26 @@
+class Code
+  class Node
+    class Decimal < Node
+      def initialize(parsed)
+        @decimal = parsed.delete(:decimal)
+
+        if parsed.key?(:exponent)
+          @exponent = Node::Statement.new(parsed.delete(:exponent))
+        end
+
+        super(parsed)
+      end
+
+      def evaluate(**args)
+        if @exponent
+          ::Code::Object::Decimal.new(
+            @decimal,
+            exponent: @exponent.evaluate(**args)
+          )
+        else
+          ::Code::Object::Decimal.new(@decimal)
+        end
+      end
+    end
+  end
+end

data/lib/code/node/dictionnary.rb

@@ -1,20 +1,31 @@
 class Code
   class Node
     class Dictionnary < Node
-      def initialize(key_values)
-        if key_values.blank?
-          @key_values = []
-        else
-          @key_values =
-            key_values.map do |key_value|
-              ::Code::Node::DictionnaryKeyValue.new(key_value)
-            end
+      class KeyValue < Node
+        def initialize(parsed)
+          if parsed.key?(:statement)
+            @key = Node::Statement.new(parsed.delete(:statement))
+          elsif parsed.key?(:name)
+            @key = Node::String.new([{ text: parsed.delete(:name) }])
+          end
+
+          @value = Node::Code.new(parsed.delete(:value))
+        end
+
+        def evaluate(**args)
+          [@key.evaluate(**args), @value.evaluate(**args)]
         end
       end
 
+      def initialize(parsed)
+        parsed = [] if parsed == ""
+        @key_values =
+          parsed.map { |key_value| Node::Dictionnary::KeyValue.new(key_value) }
+      end
+
       def evaluate(**args)
         ::Code::Object::Dictionnary.new(
-          @key_values.map { |key_value| key_value.evaluate(**args) }.to_h,
+          @key_values.map { |key_value| key_value.evaluate(**args) }.to_h
         )
       end
     end

data/lib/code/node/equal.rb

@@ -1,35 +1,33 @@
 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))
+      def initialize(parsed)
+        @operator = parsed.delete(:operator)
+        @left = parsed.delete(:left)
+        @right = Node::Statement.new(parsed.delete(:right))
+        super(parsed)
       end
 
       def evaluate(**args)
         right = @right.evaluate(**args)
+        left = ::Code::Object::String.new(@left)
         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
+        if @operator == ""
           context[left] = right
-        end
-      end
-
-      private
+        else
+          if context[left].nil?
+            raise ::Code::Error::Undefined.new("#{left} is not defined")
+          end
 
-      def operator
-        @operator.to_s[0...-1].to_sym.presence
-      end
+          context[left] = context.fetch(left).call(
+            operator: @operator,
+            arguments: [::Code::Object::Argument.new(right)],
+            **args
+          )
+        end
 
-      def left
-        ::Code::Object::String.new(@left.to_s)
+        args[:context][left]
       end
     end
   end

data/lib/code/node/function.rb

@@ -1,16 +1,19 @@
 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
+      def initialize(parsed)
+        @parameters =
+          parsed
+            .delete(:parameters) { [] }
+            .map { |parameter| Node::FunctionParameter.new(parameter) }
+
+        @body = Node::Code.new(parsed.delete(:body))
+
+        super(parsed)
       end
 
       def evaluate(**args)
-        ::Code::Object::Function.new(arguments: @arguments, body: @body)
+        ::Code::Object::Function.new(parameters: @parameters, body: @body)
       end
     end
   end

data/lib/code/node/function_parameter.rb

@@ -0,0 +1,31 @@
+class Code
+  class Node
+    class FunctionParameter < Node
+      def initialize(parsed)
+        @name = parsed.delete(:name)
+        @keyword = !!parsed.delete(:keyword)
+        super(parsed)
+      end
+
+      def name
+        ::Code::Object::String.new(@name)
+      end
+
+      def regular?
+        !@keyword
+      end
+
+      def keyword?
+        !!@keyword
+      end
+
+      def regular_splat?
+        false
+      end
+
+      def keyword_splat?
+        false
+      end
+    end
+  end
+end

data/lib/code/node/if.rb

@@ -3,47 +3,51 @@ class Code
     class If < Node
       IF_KEYWORD = "if"
       UNLESS_KEYWORD = "unless"
+      ELSIF_KEYWORD = "elsif"
+      ELSE_KEYWORD = "else"
 
-      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
+      class Else < Node
+        attr_reader :operator, :statement, :body
 
-          @body = ::Code::Node::Code.new(else_parsed.fetch(:body))
-        end
+        def initialize(parsed)
+          @operator = parsed.delete(:operator)
+          @body = Node::Code.new(parsed.delete(:body))
 
-        attr_reader :operator, :body, :statement
+          if parsed.key?(:statement)
+            @statement = Node::Statement.new(parsed.delete(:statement))
+          end
+        end
       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) }
+      def initialize(parsed)
+        @first_operator = parsed.delete(:first_operator)
+        @first_statement = Node::Statement.new(parsed.delete(:first_statement))
+        @first_body = Node::Code.new(parsed.delete(:first_body))
+        @elses =
+          parsed.delete(:elses) { [] }.map { |elses| Node::If::Else.new(elses) }
+        super(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)
+        if @first_operator == IF_KEYWORD &&
+             @first_statement.evaluate(**args).truthy?
+          @first_body.evaluate(**args)
+        elsif @first_operator == UNLESS_KEYWORD &&
+              @first_statement.evaluate(**args).falsy?
+          @first_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)
+          @elses.each do |elses|
+            if elses.operator == ELSIF_KEYWORD &&
+                 elses.statement.evaluate(**args).truthy?
+              return elses.body.evaluate(**args)
+            elsif elses.operator == IF_KEYWORD &&
+                  elses.statement.evaluate(**args).truthy?
+              return elses.body.evaluate(**args)
+            elsif elses.operator == UNLESS_KEYWORD &&
+                  elses.statement.evaluate(**args).falsy?
+              return elses.body.evaluate(**args)
+            elsif elses.operator == ELSE_KEYWORD
+              return elses.body.evaluate(**args)
             end
           end
 

data/lib/code/node/if_modifier.rb

@@ -1,48 +1,47 @@
 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))
+      IF_KEYWORD = "if"
+      UNLESS_KEYWORD = "unless"
+      WHILE_KEYWORD = "while"
+      UNTIL_KEYWORD = "until"
+
+      def initialize(parsed)
+        @operator = parsed.delete(:operator)
+        @left = Node::Statement.new(parsed.delete(:left))
+        @right = Node::Statement.new(parsed.delete(:right))
+        super(parsed)
       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
+        if @operator == IF_KEYWORD
+          if @right.evaluate(**args).truthy?
+            @left.evaluate(**args)
+          else
+            ::Code::Object::Nothing.new
+          end
+        elsif @operator == UNLESS_KEYWORD
+          if @right.evaluate(**args).falsy?
+            @left.evaluate(**args)
+          else
+            ::Code::Object::Nothing.new
+          end
+        elsif @operator == WHILE_KEYWORD
+          last = ::Code::Object::Nothing.new
+
+          last = @left.evaluate(**args) while @right.evaluate(**args).truthy?
+
+          last
+        elsif @operator == UNTIL_KEYWORD
+          last = ::Code::Object::Nothing.new
+
+          last = @left.evaluate(**args) while @right.evaluate(**args).falsy?
+
+          last
         else
-          raise NotImplementedError.new(operator.inspect)
+          raise NotImplementedError.new(@operator)
         end
       end
-
-      private
-
-      def operator
-        @operator.to_sym
-      end
     end
   end
 end

data/lib/code/node/list.rb

@@ -1,17 +1,15 @@
 class Code
   class Node
     class List < Node
-      def initialize(codes)
-        if codes.to_s.blank?
-          @codes = []
-        else
-          @codes =
-            codes.map { |code| ::Code::Node::Code.new(code.fetch(:code)) }
-        end
+      def initialize(parsed)
+        parsed = [] if parsed == ""
+        @elements = parsed.map { |element| Node::Code.new(element) }
       end
 
       def evaluate(**args)
-        ::Code::Object::List.new(@codes.map { |code| code.evaluate(**args) })
+        ::Code::Object::List.new(
+          @elements.map { |element| element.evaluate(**args) }
+        )
       end
     end
   end

data/lib/code/node/negation.rb

@@ -1,33 +1,15 @@
 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))
+      def initialize(parsed)
+        @operator = parsed.delete(:operator)
+        @right = Node::Statement.new(parsed.delete(:right))
+        super(parsed)
       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
+        @right.evaluate(**args).call(operator: @operator, arguments: [], **args)
       end
-
-      private
-
-      attr_reader :operator
     end
   end
 end

data/lib/code/node/not.rb

@@ -0,0 +1,15 @@
+class Code
+  class Node
+    class Not < Node
+      def initialize(parsed)
+        @operator = parsed.delete(:operator)
+        @right = Node::Statement.new(parsed.delete(:right))
+        super(parsed)
+      end
+
+      def evaluate(**args)
+        @right.evaluate(**args).call(operator: @operator, arguments: [], **args)
+      end
+    end
+  end
+end