code-ruby 0.2.4

data/lib/code/node/boolean.rb

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

data/lib/code/node/call.rb

@@ -0,0 +1,52 @@
+class Code
+  class Node
+    class Call < Node
+      def initialize(call)
+        @left = ::Code::Node::Statement.new(call.fetch(:left))
+
+        @arguments = call.fetch(:arguments, [])
+        @arguments.map! { |argument| ::Code::Node::CallArgument.new(argument) }
+
+        if call.key?(:right)
+          @right =
+            call
+              .fetch(:right)
+              .map { |right| ::Code::Node::ChainedCall.new(right) }
+        end
+
+        if call.key?(:block)
+          @block = ::Code::Node::Block.new(call.fetch(:block))
+        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))
+        end
+      end
+    end
+  end
+end

data/lib/code/node/call_argument.rb

@@ -0,0 +1,37 @@
+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
+      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?
+      end
+    end
+  end
+end

data/lib/code/node/chained_call.rb

@@ -0,0 +1,38 @@
+class Code
+  class Node
+    class ChainedCall < Node
+      def initialize(chained_call)
+        @name = ::Code::Node::Name.new(chained_call.fetch(:name))
+
+        @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
+      end
+
+      def evaluate(**args)
+        arguments =
+          @arguments.map do |argument|
+            ::Code::Object::Argument.new(
+              argument.evaluate(**args.merge(object: nil)),
+              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.merge(object: nil)),
+            block: true,
+          )
+        end
+
+        @name.evaluate(**args.merge(arguments: arguments))
+      end
+    end
+  end
+end

data/lib/code/node/code.rb

@@ -0,0 +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) }
+      end
+
+      def evaluate(**args)
+        @statements.map { |statement| statement.evaluate(**args) }.last
+      end
+    end
+  end
+end

data/lib/code/node/defined.rb

@@ -0,0 +1,19 @@
+class Code
+  class Node
+    class Defined < Node
+      def initialize(defined)
+        @name = defined.fetch(:name)
+      end
+
+      def evaluate(**args)
+        ::Code::Object::Boolean.new(args.fetch(:context).key?(name))
+      end
+
+      private
+
+      def name
+        ::Code::Object::String.new(@name.to_s)
+      end
+    end
+  end
+end

data/lib/code/node/dictionnary.rb

@@ -0,0 +1,22 @@
+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
+        end
+      end
+
+      def evaluate(**args)
+        ::Code::Object::Dictionnary.new(
+          @key_values.map { |key_value| key_value.evaluate(**args) }.to_h,
+        )
+      end
+    end
+  end
+end

data/lib/code/node/dictionnary_key_value.rb

@@ -0,0 +1,23 @@
+class Code
+  class Node
+    class DictionnaryKeyValue < Node
+      def initialize(key_value)
+        @key = key_value.fetch(:key)
+
+        if @key.is_a?(Array)
+          @key = ::Code::Node::Code.new(@key)
+        elsif @key.key?(:name)
+          @key = ::Code::Node::String.new(@key[:name])
+        else
+          @key = ::Code::Node::Statement.new(@key)
+        end
+
+        @value = ::Code::Node::Code.new(key_value.fetch(:value))
+      end
+
+      def evaluate(**args)
+        [@key.evaluate(**args), @value.evaluate(**args)]
+      end
+    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

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

data/lib/code/node/name.rb

@@ -0,0 +1,50 @@
+class Code
+  class Node
+    class Name < Node
+      def initialize(name)
+        @name = name
+      end
+
+      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
+
+      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

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

data/lib/code/node/number.rb

@@ -0,0 +1,23 @@
+class Code
+  class Node
+    class Number < Node
+      def initialize(number)
+        if number.key?(:base_2)
+          @number = ::Code::Node::Base2Number.new(number[:base_2])
+        elsif number.key?(:base_8)
+          @number = ::Code::Node::Base8Number.new(number[:base_8])
+        elsif number.key?(:base_10)
+          @number = ::Code::Node::Base10Number.new(number[:base_10])
+        elsif number.key?(:base_16)
+          @number = ::Code::Node::Base16Number.new(number[:base_16])
+        else
+          raise NotImplementedErorr.new(number.inspect)
+        end
+      end
+
+      def evaluate(**args)
+        @number.evaluate(**args)
+      end
+    end
+  end
+end