code-ruby 0.10.4 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fb166c32bc6cf7c79dd6e1743329312c9a922efc1cfb111a00cc3d87cac9c41
-  data.tar.gz: 284f096cf17419c0688b36d000e77350580fb7f3ce7ad3ad221e6e1589e1ab4c
+  metadata.gz: b04f0e4774e945bbf969c0159eaf23db99d9208faa98e4ae2ed575c1a363baf9
+  data.tar.gz: bf3de392fa1af6540d653d35248089d49b39da4addfd539e7594e0ac66c15def
 SHA512:
-  metadata.gz: 3d294d5f00bd9f474585eb25392122a355e4202b99a4d62045e5237880c7835d555b8cd43b07c3791d0471c98c32587a7491d05aab14fcbd50daf0cd2268c958
-  data.tar.gz: 38785eb41a2a7c28a421e8d0be54bd6cda5bf042503d9b31c2c3141a163877b68433141307520ab4cf666a5762f3c0f2b66d951ba03102374eec51a6531c500b
+  metadata.gz: 05a921e1f388872311df4f61df4dcf808cc1d4bdaccbf2bdbdd65cc58b5495edac205c003397c83254f257a9ad114b093f2470018dc12fc4d7998ae7e1feaa7d
+  data.tar.gz: f856f404a8bebf4d802d2d0ab427e091f5c556da3cd24c3f583a09bf646dedef086e31b933c8933f86868ec9b501d1594f8d7e5272bcdbf1a7dea9571e825cf6

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    code-ruby (0.10.3)
+    code-ruby (0.11.0)
       activesupport (~> 7)
       bigdecimal (~> 3)
       json (~> 2)
@@ -30,7 +30,7 @@ GEM
     i18n (1.14.1)
       concurrent-ruby (~> 1.0)
     json (2.7.1)
-    language-ruby (0.7.0)
+    language-ruby (0.8.0)
       zeitwerk (~> 2)
     minitest (5.22.2)
     mutex_m (0.2.0)

data/bin/code

@@ -42,6 +42,12 @@ argv =
         "Set timeout in seconds"
       ) { |timeout| options[:timeout] = timeout.to_f }
 
+      opts.on(
+        "-z TIME_ZONE",
+        "--time-zone TIME_ZONE",
+        "Set time zone"
+      ) { |time_zone| Time.zone = time_zone }
+
       opts.on("--profile", "Profile Ruby code") do |_timeout|
         require "ruby-prof"
         options[:profile] = true

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,12 @@ 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))
+        @base_16 ? Object::Integer.new(@base_16.to_i(16)) : Object::Nothing.new
       end
     end
   end

data/lib/code/node/base_2.rb

@@ -4,11 +4,12 @@ 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))
+        @base_2 ? Object::Integer.new(@base_2.to_i(2)) : Object::Nothing.new
       end
     end
   end

data/lib/code/node/base_8.rb

@@ -4,11 +4,12 @@ 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))
+        @base_8 ? Object::Integer.new(@base_8.to_i(8)) : Object::Nothing.new
       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,39 +5,33 @@ 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)
-          Object::Argument.new(
-            Object::Function.new(parameters: @parameters, body: @body)
-          )
+          Object::Argument.new(Object::Function.new(@parameters, @body))
         end
       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)
+        if parsed.key?(:block)
+          @block = Call::Block.new(parsed.delete(:block).presence)
+        end
       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,15 @@ 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,21 @@ 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(
-            @decimal,
-            exponent: @exponent.evaluate(**args)
-          )
+        if @exponent && @decimal
+          Object::Decimal.new(@decimal, @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,18 @@ 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! do |key_value|
+          Node::Dictionary::KeyValue.new(key_value)
+        end
       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,19 +4,15 @@ 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| FunctionParameter.new(parameter) }
 
-        @parameters =
-          @parameters.map { |parameter| Node::FunctionParameter.new(parameter) }
-
-        @body = Node::Code.new(parsed.delete(:body))
-
-        super(parsed)
+        @body = Code.new(parsed.delete(:body).presence)
       end
 
       def evaluate(**_args)
-        ::Code::Object::Function.new(parameters: @parameters, body: @body)
+        Object::Function.new(@parameters, @body)
       end
     end
   end

data/lib/code/node/function_parameter.rb

@@ -4,13 +4,13 @@ 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
-        ::Code::Object::String.new(@name)
+        Object::String.new(@name)
       end
 
       def regular?
@@ -28,6 +28,10 @@ class Code
       def keyword_splat?
         false
       end
+
+      def default
+        nil
+      end
     end
   end
 end

data/lib/code/node/if.rb

@@ -12,22 +12,24 @@ 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 +40,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,14 @@ 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