code-ruby 0.10.4 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fb166c32bc6cf7c79dd6e1743329312c9a922efc1cfb111a00cc3d87cac9c41
-  data.tar.gz: 284f096cf17419c0688b36d000e77350580fb7f3ce7ad3ad221e6e1589e1ab4c
+  metadata.gz: 97ce31f3a36a57e14f607ded3383aa3c71866824c6e57541c70d48962c77b9ef
+  data.tar.gz: '0229023c391084763f03d2ffbfd82af81da2d996666719a49ad169d7740c4d6c'
 SHA512:
-  metadata.gz: 3d294d5f00bd9f474585eb25392122a355e4202b99a4d62045e5237880c7835d555b8cd43b07c3791d0471c98c32587a7491d05aab14fcbd50daf0cd2268c958
-  data.tar.gz: 38785eb41a2a7c28a421e8d0be54bd6cda5bf042503d9b31c2c3141a163877b68433141307520ab4cf666a5762f3c0f2b66d951ba03102374eec51a6531c500b
+  metadata.gz: 996b1594dbc1192dbad2b0c64d605d9eccff6d5622437ef5974464648e5f2cd2ee57aad50fce9279f8027f1378fc7c2652106265a2fc79bbe21b224210228c9d
+  data.tar.gz: ec405b4bc88648344f4860fb7350695aa447a5905e9a56e7230c771d5ea76e22515fe74ac0fc30771e27a9d67f4eda85b0d2475484d81a5d2c604c5a901913ae

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    code-ruby (0.10.3)
+    code-ruby (0.10.4)
       activesupport (~> 7)
       bigdecimal (~> 3)
       json (~> 2)

data/bin/console

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/code-ruby"
+
+binding.irb

data/lib/code/node/base_10.rb

@@ -4,26 +4,26 @@ class Code
   class Node
     class Base10 < Node
       def initialize(parsed)
-        @whole = parsed.delete(:whole)
+        return if parsed.blank?
+        @whole = parsed.delete(:whole).presence
 
         if parsed.key?(:exponent)
-          @exponent = Node::Statement.new(parsed.delete(:exponent))
+          @exponent = Node::Statement.new(parsed.delete(:exponent).presence)
         end
-
-        super(parsed)
       end
 
       def evaluate(**args)
-        if @exponent
+        if @exponent && @whole
           exponent = @exponent.evaluate(**args)
-
-          if exponent.is_a?(::Code::Object::Integer)
-            ::Code::Object::Integer.new(@whole.to_i, exponent:)
+          if exponent.is_a?(Object::Integer)
+            Object::Integer.new(@whole, exponent:)
           else
-            ::Code::Object::Decimal.new(@whole, exponent:)
+            Object::Decimal.new(@whole, exponent:)
           end
+        elsif @whole
+          Object::Integer.new(@whole.to_i)
         else
-          ::Code::Object::Integer.new(@whole.to_i)
+          Object::Nothing.new
         end
       end
     end

data/lib/code/node/base_16.rb

@@ -4,11 +4,16 @@ class Code
   class Node
     class Base16 < Node
       def initialize(parsed)
-        @base_16 = parsed
+        return if parsed.blank?
+        @base_16 = parsed.presence
       end
 
       def evaluate(**_args)
-        ::Code::Object::Integer.new(@base_16.to_i(16))
+        if @base_16
+          Object::Integer.new(@base_16.to_i(16))
+        else
+          Object::Nothing.new
+        end
       end
     end
   end

data/lib/code/node/base_2.rb

@@ -4,11 +4,16 @@ class Code
   class Node
     class Base2 < Node
       def initialize(parsed)
-        @base_2 = parsed
+        return if parsed.blank?
+        @base_2 = parsed.presence
       end
 
       def evaluate(**_args)
-        ::Code::Object::Integer.new(@base_2.to_i(2))
+        if @base_2
+          Object::Integer.new(@base_2.to_i(2))
+        else
+          Object::Nothing.new
+        end
       end
     end
   end

data/lib/code/node/base_8.rb

@@ -4,11 +4,16 @@ class Code
   class Node
     class Base8 < Node
       def initialize(parsed)
-        @base_8 = parsed
+        return if parsed.blank?
+        @base_8 = parsed.presence
       end
 
       def evaluate(**_args)
-        ::Code::Object::Integer.new(@base_8.to_i(8))
+        if @base_8
+          Object::Integer.new(@base_8.to_i(8))
+        else
+          Object::Nothing.new
+        end
       end
     end
   end

data/lib/code/node/boolean.rb

@@ -7,16 +7,17 @@ class Code
       FALSE_KEYWORD = "false"
 
       def initialize(parsed)
-        @boolean = parsed
+        return if parsed.blank?
+        @boolean = parsed.presence
       end
 
       def evaluate(**_args)
         if @boolean == TRUE_KEYWORD
-          ::Code::Object::Boolean.new(true)
+          Object::Boolean.new(true)
         elsif @boolean == FALSE_KEYWORD
-          ::Code::Object::Boolean.new(false)
+          Object::Boolean.new(false)
         else
-          raise NotImplementedError, @boolean
+          Object::Nothing.new
         end
       end
     end

data/lib/code/node/call.rb

@@ -5,14 +5,11 @@ class Code
     class Call < Node
       class Block < Node
         def initialize(parsed)
-          @parameters =
-            parsed
-              .delete(:parameters) { [] }
-              .map { |parameter| FunctionParameter.new(parameter) }
+          return if parsed.blank?
+          @parameters = parsed.delete(:parameters) { [] }.presence || []
+          @parameters.map! { |parameter| FunctionParameter.new(parameter) }
 
-          @body = Code.new(parsed.delete(:body))
-
-          super(parsed)
+          @body = Code.new(parsed.delete(:body).presence)
         end
 
         def evaluate(**_args)
@@ -23,21 +20,18 @@ class Code
       end
 
       def initialize(parsed)
-        @name = parsed.delete(:name)
-        @arguments =
-          parsed
-            .delete(:arguments) { [] }
-            .map { |argument| CallArgument.new(argument) }
-
-        @block = Call::Block.new(parsed.delete(:block)) if parsed.key?(:block)
+        return if parsed.blank?
+        @name = parsed.delete(:name).presence
+        @arguments = parsed.delete(:arguments).presence || []
+        @arguments.map! { |argument| CallArgument.new(argument) }
 
-        super(parsed)
+        @block = Call::Block.new(parsed.delete(:block).presence) if parsed.key?(:block)
       end
 
       def evaluate(**args)
         arguments = []
 
-        @arguments.each do |argument|
+        (@arguments || []).each do |argument|
           if argument.keyword?
             if arguments.last&.value.is_a?(Object::Dictionary)
               arguments.last.value.code_set(

data/lib/code/node/call_argument.rb

@@ -4,15 +4,19 @@ class Code
   class Node
     class CallArgument < Node
       def initialize(parsed)
-        @value = Node::Code.new(parsed.delete(:value))
-        @name = parsed.delete(:name)
+        return if parsed.blank?
+        @value = Node::Code.new(parsed.delete(:value).presence)
+        @name = parsed.delete(:name).presence
       end
 
       def evaluate(**args)
         if @name
-          Object::Argument.new(@value.evaluate(**args), name:)
+          Object::Argument.new(
+            @value&.evaluate(**args) || Object::Nothing.new,
+            name:
+          )
         else
-          Object::Argument.new(@value.evaluate(**args))
+          Object::Argument.new(@value&.evaluate(**args) || Object::Nothing.new)
         end
       end
 

data/lib/code/node/code.rb

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

data/lib/code/node/decimal.rb

@@ -4,23 +4,24 @@ class Code
   class Node
     class Decimal < Node
       def initialize(parsed)
-        @decimal = parsed.delete(:decimal)
+        return if parsed.blank?
+        @decimal = parsed.delete(:decimal).presence
 
         if parsed.key?(:exponent)
-          @exponent = Node::Statement.new(parsed.delete(:exponent))
+          @exponent = Statement.new(parsed.delete(:exponent).presence)
         end
-
-        super(parsed)
       end
 
       def evaluate(**args)
-        if @exponent
-          ::Code::Object::Decimal.new(
+        if @exponent && @decimal
+          Object::Decimal.new(
             @decimal,
             exponent: @exponent.evaluate(**args)
           )
+        elsif @decimal
+          Object::Decimal.new(@decimal)
         else
-          ::Code::Object::Decimal.new(@decimal)
+          Object::Nothing.new
         end
       end
     end

data/lib/code/node/dictionary.rb

@@ -5,17 +5,20 @@ class Code
     class Dictionary < Node
       class KeyValue < Node
         def initialize(parsed)
+          return if parsed.blank?
           if parsed.key?(:statement)
-            @key = Node::Statement.new(parsed.delete(:statement))
+            @key = Node::Statement.new(parsed.delete(:statement).presence)
           elsif parsed.key?(:name)
-            @key = Node::String.new([{ text: parsed.delete(:name) }])
+            @key = Node::String.new([{ text: parsed.delete(:name).presence }])
           end
 
-          @value = Node::Code.new(parsed.delete(:value)) if parsed[:value]
+          if parsed[:value].presence
+            @value = Node::Code.new(parsed.delete(:value).presence)
+          end
         end
 
         def evaluate(**args)
-          key = @key.evaluate(**args)
+          key = @key&.evaluate(**args) || Object::Nothing.new
 
           if @value
             value = @value.evaluate(**args)
@@ -27,14 +30,14 @@ class Code
       end
 
       def initialize(parsed)
-        parsed = [] if parsed == ""
-        @key_values =
-          parsed.map { |key_value| Node::Dictionary::KeyValue.new(key_value) }
+        return if parsed.blank?
+        @key_values = parsed.presence || []
+        @key_values.map! { |key_value| Node::Dictionary::KeyValue.new(key_value) }
       end
 
       def evaluate(**args)
         ::Code::Object::Dictionary.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/function.rb

@@ -4,15 +4,11 @@ class Code
   class Node
     class Function < Node
       def initialize(parsed)
-        @parameters = parsed.delete(:parameters) { [] }
-        @parameters = [] if @parameters.empty?
+        return if parsed.blank?
+        @parameters = parsed.delete(:parameters).presence || []
+        @parameters.map! { |parameter| Node::FunctionParameter.new(parameter) }
 
-        @parameters =
-          @parameters.map { |parameter| Node::FunctionParameter.new(parameter) }
-
-        @body = Node::Code.new(parsed.delete(:body))
-
-        super(parsed)
+        @body = Node::Code.new(parsed.delete(:body).presence)
       end
 
       def evaluate(**_args)

data/lib/code/node/function_parameter.rb

@@ -4,9 +4,9 @@ class Code
   class Node
     class FunctionParameter < Node
       def initialize(parsed)
-        @name = parsed.delete(:name)
-        @keyword = !parsed.delete(:keyword).nil?
-        super(parsed)
+        return if parsed.blank?
+        @name = parsed.delete(:name).presence
+        @keyword = parsed.delete(:keyword).present?
       end
 
       def name

data/lib/code/node/if.rb

@@ -12,22 +12,23 @@ class Code
         attr_reader :operator, :statement, :body
 
         def initialize(parsed)
-          @operator = parsed.delete(:operator)
-          @body = Node::Code.new(parsed.delete(:body))
+          return if parsed.blank?
+          @operator = parsed.delete(:operator).presence
+          @body = Node::Code.new(parsed.delete(:body).presence)
 
-          return unless parsed.key?(:statement)
-
-          @statement = Node::Statement.new(parsed.delete(:statement))
+          if parsed.key?(:statement)
+            @statement = Node::Statement.new(parsed.delete(:statement).presence)
+          end
         end
       end
 
       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)
+        return if parsed.blank?
+        @first_operator = parsed.delete(:first_operator).presence
+        @first_statement = Node::Statement.new(parsed.delete(:first_statement).presence)
+        @first_body = Node::Code.new(parsed.delete(:first_body).presence)
+        @elses = (parsed.delete(:elses).presence || [])
+        @elses.map! { |elses| Node::If::Else.new(elses) }
       end
 
       def evaluate(**args)
@@ -38,7 +39,7 @@ class Code
               @first_statement.evaluate(**args).falsy?
           @first_body.evaluate(**args)
         else
-          @elses.each do |elses|
+          (@elses || []).each do |elses|
             if elses.operator == ELSIF_KEYWORD &&
                  elses.statement.evaluate(**args).truthy?
               return elses.body.evaluate(**args)

data/lib/code/node/left_operation.rb

@@ -10,8 +10,9 @@ class Code
         attr_reader :operator, :statement
 
         def initialize(parsed)
-          @operator = parsed.delete(:operator)
-          @statement = Statement.new(parsed.delete(:statement))
+          return if parsed.blank?
+          @operator = parsed.delete(:operator).presence
+          @statement = Statement.new(parsed.delete(:statement).presence)
         end
 
         def call?
@@ -20,15 +21,14 @@ class Code
       end
 
       def initialize(parsed)
-        @first = Statement.new(parsed.delete(:first))
-        @others =
-          parsed.delete(:others).map { |operator| Operator.new(operator) }
-
-        super(parsed)
+        return if parsed.blank?
+        @first = Statement.new(parsed.delete(:first).presence)
+        @others = parsed.delete(:others).presence || []
+        @others.map! { |operator| Operator.new(operator) }
       end
 
       def evaluate(**args)
-        first = @first.evaluate(**args)
+        first = @first&.evaluate(**args) || Object::Nothing.new
 
         @others.reduce(first) do |left, right|
           if right.call?
@@ -46,11 +46,11 @@ class Code
       end
 
       def resolve(**args)
-        first = @first.resolve(**args)
+        first = @first&.resolve(**args) || Object::Nothing.new
 
         list = Object::IdentifierList.new([first])
 
-        @others.each do |other|
+        (@others || []).each do |other|
           list.code_append(
             other.statement.resolve(**args, object: list.code_last)
           )

data/lib/code/node/list.rb

@@ -4,13 +4,13 @@ class Code
   class Node
     class List < Node
       def initialize(parsed)
-        parsed = [] if parsed == ""
-        @elements = parsed.map { |element| Node::Code.new(element) }
+        return if parsed.blank?
+        @elements = (parsed.presence || []).map { |element| Node::Code.new(element) }
       end
 
       def evaluate(**args)
         ::Code::Object::List.new(
-          @elements.map { |element| element.evaluate(**args) }
+          (@elements || []).map { |element| element.evaluate(**args) }
         )
       end
     end

data/lib/code/node/negation.rb

@@ -4,13 +4,17 @@ class Code
   class Node
     class Negation < Node
       def initialize(parsed)
-        @operator = parsed.delete(:operator)
-        @right = Node::Statement.new(parsed.delete(:right))
-        super(parsed)
+        return if parsed.blank?
+        @operator = parsed.delete(:operator).presence
+        @right = Node::Statement.new(parsed.delete(:right).presence)
       end
 
       def evaluate(**args)
-        @right.evaluate(**args).call(operator: @operator, arguments: [], **args)
+        if @right
+          @right.evaluate(**args).call(operator: @operator, **args)
+        else
+          Object::Nothing.new
+        end
       end
     end
   end

data/lib/code/node/not.rb

@@ -4,13 +4,17 @@ class Code
   class Node
     class Not < Node
       def initialize(parsed)
-        @operator = parsed.delete(:operator)
-        @right = Node::Statement.new(parsed.delete(:right))
-        super(parsed)
+        return if parsed.blank?
+        @operator = parsed.delete(:operator).presence
+        @right = Node::Statement.new(parsed.delete(:right).presence)
       end
 
       def evaluate(**args)
-        @right.evaluate(**args).call(operator: @operator, arguments: [], **args)
+        if @right
+          @right.evaluate(**args).call(operator: @operator, **args)
+        else
+          Object::Nothing.new
+        end
       end
     end
   end

data/lib/code/node/nothing.rb

@@ -3,12 +3,13 @@
 class Code
   class Node
     class Nothing < Node
-      def initialize(nothing)
-        @nothing = nothing
+      def initialize(parsed)
+        return if parsed.blank?
+        @nothing = parsed.presence
       end
 
       def evaluate(**_args)
-        ::Code::Object::Nothing.new
+        Object::Nothing.new
       end
     end
   end

data/lib/code/node/number.rb

@@ -4,6 +4,8 @@ class Code
   class Node
     class Number < Node
       def initialize(parsed)
+        return if parsed.blank?
+
         if parsed.key?(:decimal)
           @statement = Node::Decimal.new(parsed.delete(:decimal))
         elsif parsed.key?(:base_16)
@@ -15,12 +17,10 @@ class Code
         elsif parsed.key?(:base_2)
           @statement = Node::Base2.new(parsed.delete(:base_2))
         end
-
-        super(parsed)
       end
 
       def evaluate(**args)
-        @statement.evaluate(**args)
+        @statement&.evaluate(**args) || Object::Nothing.new
       end
     end
   end

data/lib/code/node/right_operation.rb

@@ -6,23 +6,22 @@ class Code
       EQUAL = "="
 
       def initialize(parsed)
-        @left = Statement.new(parsed.delete(:left))
-        @operator = parsed.delete(:operator)
-        @right = Statement.new(parsed.delete(:right))
-
-        super(parsed)
+        return if parsed.blank?
+        @left = Statement.new(parsed.delete(:left).presence)
+        @operator = parsed.delete(:operator).presence
+        @right = Statement.new(parsed.delete(:right).presence)
       end
 
       def evaluate(**args)
         case @operator
         when "if"
-          if @right.evaluate(**args).truthy?
-            @left.evaluate(**args)
+          if (@right&.evaluate(**args) || Object::Nothing.new).truthy?
+            @left&.evaluate(**args) || Object::Nothing.new
           else
             Object::Nothing.new
           end
         when "unless"
-          if @right.evaluate(**args).truthy?
+          if (@right&.evaluate(**args) || Object::Nothing.new).truthy?
             Object::Nothing.new
           else
             @left.evaluate(**args)
@@ -30,24 +29,28 @@ class Code
         when "while"
           left = Object::Nothing.new
 
-          left = @left.evaluate(**args) while @right.evaluate(**args).truthy?
+          while (@right&.evaluate(**args) || Object::Nothing.new).truthy?
+            left = @left&.evaluate(**args) || Object::Nothing.new
+          end
 
           left
         when "until"
           left = Object::Nothing.new
 
-          left = @left.evaluate(**args) while @right.evaluate(**args).falsy?
+          while (@right&.evaluate(**args) || Object::Nothing.new).falsy?
+            left = @left&.evaluate(**args) || Object::Nothing.new
+          end
 
           left
         when "rescue"
           begin
-            @left.evaluate(**args)
+            @left&.evaluate(**args) || Object::Nothing.new
           rescue Error
-            @right.evaluate(**args)
+            @right&.evaluate(**args) || Object::Nothing.new
           end
         when /=$/
-          right = @right.evaluate(**args)
-          left = @left.resolve(**args)
+          right = @right&.evaluate(**args) || Object::Nothing.new
+          left = @left&.resolve(**args) || Object::Nothing.new
 
           left.call(
             operator: @operator,
@@ -55,8 +58,8 @@ class Code
             **args
           )
         else
-          right = @right.evaluate(**args)
-          left = @left.evaluate(**args)
+          right = @right&.evaluate(**args) || Object::Nothing.new
+          left = @left&.evaluate(**args) || Object::Nothing.new
 
           left.call(
             operator: @operator,

data/lib/code/node/splat.rb

@@ -4,13 +4,17 @@ class Code
   class Node
     class Splat < Node
       def initialize(parsed)
-        @operator = parsed.delete(:operator)
-        @right = Node::Statement.new(parsed.delete(:right))
-        super(parsed)
+        return if parsed.blank?
+        @operator = parsed.delete(:operator).presence
+        @right = Node::Statement.new(parsed.delete(:right).presence)
       end
 
       def evaluate(**args)
-        @right.evaluate(**args).call(operator: @operator, arguments: [], **args)
+        if @right
+          @right.evaluate(**args).call(operator: @operator, **args)
+        else
+          Object::Nothing.new
+        end
       end
     end
   end

data/lib/code/node/square_bracket.rb

@@ -4,29 +4,26 @@ class Code
   class Node
     class SquareBracket < Node
       def initialize(parsed)
-        @left = Node::Statement.new(parsed.delete(:left))
-        @statements =
-          parsed
-            .delete(:statements)
-            .map { |statement| Node::Statement.new(statement) }
-
-        super(parsed)
+        return if parsed.blank?
+        @left = Node::Statement.new(parsed.delete(:left).presence)
+        @statements = parsed.delete(:statements).presence || []
+        @statements.map! { |statement| Node::Statement.new(statement) }
       end
 
       def evaluate(**args)
-        left = @left.evaluate(**args)
+        left = @left&.evaluate(**args) || Object::Nothing.new
 
-        @statements.reduce(left) do |object, statement|
+        (@statements || []).reduce(left) do |object, statement|
           object.code_fetch(statement.evaluate(**args))
         end
       end
 
       def resolve(**args)
-        left = @left.resolve(**args)
+        left = @left&.resolve(**args) || Object::Nothing.new
 
         list = Object::IdentifierList.new([left])
 
-        @statements.each do |statement|
+        (@statements || []).each do |statement|
           list.code_append(statement.evaluate(**args))
         end
 

data/lib/code/node/statement.rb

@@ -4,6 +4,8 @@ class Code
   class Node
     class Statement < Node
       def initialize(parsed)
+        return if parsed.blank?
+
         if parsed.key?(:nothing)
           @statement = Node::Nothing.new(parsed.delete(:nothing))
         elsif parsed.key?(:boolean)
@@ -51,16 +53,14 @@ class Code
         elsif parsed.key?(:square_bracket)
           @statement = Node::SquareBracket.new(parsed.delete(:square_bracket))
         end
-
-        super(parsed)
       end
 
       def evaluate(**args)
-        @statement.evaluate(**args)
+        @statement&.evaluate(**args) || Object::Nothing.new
       end
 
       def resolve(**args)
-        @statement.resolve(**args)
+        @statement&.resolve(**args) || Object::Nothing.new
       end
     end
   end

data/lib/code/node/string.rb

@@ -6,22 +6,25 @@ class Code
       class Part < Node
         class Code < Node
           def initialize(parsed)
-            @code = Node::Code.new(parsed)
+            return if parsed.blank?
+            @code = Node::Code.new(parsed.presence)
           end
 
           def evaluate(**args)
-            @code.evaluate(**args)
+            @code&.evaluate(**args) || Object::Nothing.new
           end
         end
 
         class Text < Node
           def initialize(parsed)
+            return if parsed.blank?
             @text = parsed
           end
 
           def evaluate(**_args)
             ::Code::Object::String.new(
               @text
+                .to_s
                 .gsub('\n', "\n")
                 .gsub('\r', "\r")
                 .gsub('\t', "\t")
@@ -34,29 +37,28 @@ class Code
         end
 
         def initialize(parsed)
+          return if parsed.blank?
+
           if parsed.key?(:text)
-            @part = Node::String::Part::Text.new(parsed.delete(:text))
+            @part = Node::String::Part::Text.new(parsed.delete(:text).presence)
           elsif parsed.key?(:code)
-            @part = Node::String::Part::Code.new(parsed.delete(:code))
+            @part = Node::String::Part::Code.new(parsed.delete(:code).presence)
           end
-
-          super(parsed)
         end
 
         def evaluate(**args)
-          @part.evaluate(**args)
+          @part&.evaluate(**args) || Object::Nothing.new
         end
       end
 
       def initialize(parsed)
-        parsed = [] if parsed == ""
-
-        @parts = parsed.map { |part| Node::String::Part.new(part) }
+        return if parsed.blank?
+        @parts = (parsed.presence || []).map { |part| Node::String::Part.new(part) }
       end
 
       def evaluate(**args)
         ::Code::Object::String.new(
-          @parts.map { |part| part.evaluate(**args) }.map(&:to_s).join
+          (@parts || []).map { |part| part.evaluate(**args) }.map(&:to_s).join
         )
       end
     end

data/lib/code/node/ternary.rb

@@ -4,17 +4,17 @@ class Code
   class Node
     class Ternary < Node
       def initialize(parsed)
-        @left = Node::Statement.new(parsed.delete(:left))
-        @middle = Node::Statement.new(parsed.delete(:middle))
-        @right = Node::Statement.new(parsed.delete(:right)) if parsed.key?(
-          :right
-        )
-        super(parsed)
+        return if parsed.blank?
+        @left = Node::Statement.new(parsed.delete(:left).presence)
+        @middle = Node::Statement.new(parsed.delete(:middle).presence)
+        if parsed.key?(:right)
+          @right = Node::Statement.new(parsed.delete(:right).presence)
+        end
       end
 
       def evaluate(**args)
-        if @left.evaluate(**args).truthy?
-          @middle.evaluate(**args)
+        if (@left&.evaluate(**args) || Object::Nothing.new).truthy?
+          @middle&.evaluate(**args) || Object::Nothing.new
         elsif @right
           @right.evaluate(**args)
         else

data/lib/code/node/unary_minus.rb

@@ -4,13 +4,17 @@ class Code
   class Node
     class UnaryMinus < Node
       def initialize(parsed)
-        @operator = parsed.delete(:operator)
-        @right = Node::Statement.new(parsed.delete(:right))
-        super(parsed)
+        return if parsed.blank?
+        @operator = parsed.delete(:operator).presence
+        @right = Node::Statement.new(parsed.delete(:right).presence)
       end
 
       def evaluate(**args)
-        @right.evaluate(**args).call(operator: @operator, arguments: [], **args)
+        if @right
+          @right.evaluate(**args).call(operator: @operator, **args)
+        else
+          Object::Nothing.new
+        end
       end
     end
   end

data/lib/code/node/while.rb

@@ -8,12 +8,12 @@ class Code
       LOOP_KEYWORD = "loop"
 
       def initialize(parsed)
-        @operator = parsed.delete(:operator)
-        @statement = Statement.new(parsed.delete(:statement)) if parsed[
-          :statement
-        ]
-        @body = Code.new(parsed.delete(:body))
-        super(parsed)
+        return if parsed.blank?
+        @operator = parsed.delete(:operator).presence
+        if parsed.key?(:statement)
+          @statement = Statement.new(parsed.delete(:statement))
+        end
+        @body = Code.new(parsed.delete(:body).presence)
       end
 
       def evaluate(**args)
@@ -21,22 +21,24 @@ class Code
         when WHILE_KEYWORD
           last = Object::Nothing.new
 
-          last = @body.evaluate(**args) while @statement.evaluate(
-            **args
-          ).truthy?
+          while (@statement&.evaluate(**args) || Object::Nothing.new).truthy?
+            last = @body&.evaluate(**args) || Object::Nothing.new
+          end
 
           last
         when UNTIL_KEYWORD
           last = Object::Nothing.new
 
-          last = @body.evaluate(**args) while @statement.evaluate(**args).falsy?
+          while (@statement&.evaluate(**args) || Object::Nothing.new).falsy?
+            last = @body&.evaluate(**args) || Object::Nothing.new
+          end
 
           last
         when LOOP_KEYWORD
-          loop { @body.evaluate(**args) }
-          raise NotImplementedError
+          loop { @body&.evaluate(**args) || Object::Nothing.new }
+          Object::Nothing.new
         else
-          raise NotImplementedError, @operator
+          Object::Nothing.new
         end
       rescue Error::Break => e
         e.value || Object::Nothing.new

data/lib/code/node.rb

@@ -2,14 +2,8 @@
 
 class Code
   class Node
-    def initialize(parsed)
-      return if parsed.nil? || parsed.empty?
-
-      raise NotImplementedError, "#{self.class.name}: #{parsed.inspect}"
-    end
-
     def evaluate(**_args)
-      raise NotImplementedError, "#{self.class.name}#evaluate"
+      Object::Nothing.new
     end
 
     def resolve(...)

data/lib/code/object/function.rb

@@ -6,8 +6,8 @@ class Code
       attr_reader :parameters, :body
 
       def initialize(parameters:, body:)
-        @parameters = parameters
-        @body = body
+        @parameters = parameters.presence || []
+        @body = body.presence || Node::Code.new
       end
 
       def self.name
@@ -57,8 +57,6 @@ class Code
                 &.value
             argument = parameter.evaluate(**globals) if argument.nil?
             context.code_set(parameter.name, argument)
-          else
-            raise NotImplementedError
           end
         end
 

data/lib/code/object.rb

@@ -292,10 +292,6 @@ class Code
     end
 
     def hash
-      unless respond_to?(:raw)
-        raise NotImplementedError, "#{self.class.name}#hash"
-      end
-
       [self.class, raw].hash
     end
 
@@ -309,7 +305,7 @@ class Code
     end
 
     def to_s
-      raise NotImplementedError, "#{self.class.name}#to_s"
+      raw.to_s
     end
 
     def inspect
@@ -325,7 +321,7 @@ class Code
     end
 
     def as_json(...)
-      raise NotImplementedError, "#{self.class}#as_json"
+      raw.as_json
     end
   end
 end

data/lib/code/parser/code.rb

@@ -20,7 +20,7 @@ class Code
       end
 
       def root
-        present | whitespace?.aka(:whitespace).then { [] }
+        present | whitespace?
       end
     end
   end

data/lib/code/parser/left_operation.rb

@@ -4,7 +4,7 @@ class Code
   class Parser
     class LeftOperation < Language
       def statement
-        raise NotImplementedError
+        Statement
       end
 
       def whitespace
@@ -16,7 +16,7 @@ class Code
       end
 
       def operator
-        raise NotImplementedError
+        str("")
       end
 
       def right_statement

data/lib/code/parser/list.rb

@@ -32,8 +32,8 @@ class Code
       end
 
       def element
-        (whitespace? << code_present << (whitespace? << comma).maybe) |
-          (whitespace? << code << whitespace? << comma)
+        (whitespace? << code_present << (whitespace? << comma.ignore).maybe) |
+          (whitespace? << code << whitespace? << comma.ignore)
       end
 
       def root

data/lib/code/parser/right_operation.rb

@@ -4,7 +4,7 @@ class Code
   class Parser
     class RightOperation < Language
       def statement
-        raise NotImplementedError
+        Statement
       end
 
       def whitespace
@@ -16,7 +16,7 @@ class Code
       end
 
       def operator
-        raise NotImplementedError
+        str("")
       end
 
       def right_statement

data/lib/code/parser/whitespace.rb

@@ -37,14 +37,14 @@ class Code
       end
 
       def without_newline
-        (space | multi_line_comment).repeat(1)
+        (space | multi_line_comment).repeat(1).ignore
       end
 
       def root
         (
           space | newline | hash_comment | double_slash_comment |
             multi_line_comment
-        ).repeat(1) | any.absent
+        ).repeat(1).ignore | any.absent
       end
     end
   end

data/lib/code/type/sig.rb

@@ -40,11 +40,11 @@ class Code
       end
 
       def actual_arguments
-        args[:arguments].map(&:value)
+        args.fetch(:arguments, []).map(&:value)
       end
 
       def operator
-        args[:operator] || "call"
+        args.fetch(:operator, nil) || "call"
       end
 
       def function

data/lib/code/type.rb

@@ -3,11 +3,11 @@
 class Code
   class Type
     def name
-      raise NotImplementedError, "#{self.class}#name"
+      "Type"
     end
 
-    def valid?(argument)
-      raise NotImplementedError, "#{self.class}#valid?"
+    def valid?(_argument)
+      false
     end
 
     def valid_for?(expected:, actual:)

data/lib/code/version.rb

@@ -2,4 +2,4 @@
 
 require_relative "../code"
 
-Code::Version = Gem::Version.new("0.10.4")
+Code::Version = Gem::Version.new("0.11.0")

data/lib/code-ruby.rb

@@ -4,6 +4,7 @@ require "active_support"
 require "active_support/core_ext/date/conversions"
 require "active_support/core_ext/numeric/time"
 require "active_support/core_ext/object/json"
+require "active_support/core_ext/object/blank"
 require "bigdecimal"
 require "json"
 require "language-ruby"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: code-ruby
 version: !ruby/object:Gem::Version
-  version: 0.10.4
+  version: 0.11.0
 platform: ruby
 authors:
 - Dorian Marié
@@ -95,6 +95,7 @@ files:
 - Gemfile.lock
 - README.md
 - bin/code
+- bin/console
 - code-ruby.gemspec
 - lib/code-ruby.rb
 - lib/code.rb