code-ruby 0.13.1 → 0.14.0

data/lib/code/node/splat.rb

@@ -5,6 +5,7 @@ class Code
     class Splat < Node
       def initialize(parsed)
         return if parsed.blank?
+
         @operator = parsed.delete(:operator).presence
         @right = Node::Statement.new(parsed.delete(:right).presence)
       end

data/lib/code/node/square_bracket.rb

@@ -5,6 +5,7 @@ class Code
     class SquareBracket < Node
       def initialize(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) }

data/lib/code/node/string.rb

@@ -7,6 +7,7 @@ class Code
         class Code < Node
           def initialize(parsed)
             return if parsed.blank?
+
             @code = Node::Code.new(parsed.presence)
           end
 
@@ -18,6 +19,7 @@ class Code
         class Text < Node
           def initialize(parsed)
             return if parsed.blank?
+
             @text = parsed
           end
 
@@ -53,6 +55,7 @@ class Code
 
       def initialize(parsed)
         return if parsed.blank?
+
         @parts =
           (parsed.presence || []).map { |part| Node::String::Part.new(part) }
       end

data/lib/code/node/ternary.rb

@@ -5,11 +5,12 @@ class Code
     class Ternary < Node
       def initialize(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
+        return unless parsed.key?(:right)
+
+        @right = Node::Statement.new(parsed.delete(:right).presence)
       end
 
       def evaluate(**args)

data/lib/code/node/unary_minus.rb

@@ -5,6 +5,7 @@ class Code
     class UnaryMinus < Node
       def initialize(parsed)
         return if parsed.blank?
+
         @operator = parsed.delete(:operator).presence
         @right = Node::Statement.new(parsed.delete(:right).presence)
       end

data/lib/code/node/while.rb

@@ -9,10 +9,11 @@ class Code
 
       def initialize(parsed)
         return if parsed.blank?
+
         @operator = parsed.delete(:operator).presence
-        if parsed.key?(:statement)
-          @statement = Statement.new(parsed.delete(:statement))
-        end
+        @statement = Statement.new(parsed.delete(:statement)) if parsed.key?(
+          :statement
+        )
         @body = Code.new(parsed.delete(:body).presence)
       end
 

data/lib/code/object/boolean.rb

@@ -11,8 +11,8 @@ class Code
 
       def call(**args)
         operator = args.fetch(:operator, nil)
-        arguments = args.fetch(:arguments, [])
-        value = arguments.first&.value
+        arguments = args.fetch(:arguments, List.new)
+        value = arguments.code_first
 
         case operator.to_s
         when "&", "bitwise_and"

data/lib/code/object/context.rb

@@ -18,7 +18,7 @@ class Code
         elsif parent?
           parent.lookup!(identifier)
         else
-            raise Error::Undefined, "#{identifier} is not defined"
+          raise Error::Undefined, "#{identifier} is not defined"
         end
       end
 

data/lib/code/object/decimal.rb

@@ -9,14 +9,14 @@ class Code
         decimal = decimal.raw if decimal.is_an?(Object)
         exponent = exponent.raw if exponent.is_an?(Object)
         @raw = decimal.to_d * 10**exponent.to_d
-      rescue FloatDomainError => e
+      rescue FloatDomainError
         raise Error, "#{decimal.inspect} * 10**#{exponent.inspect} is invalid"
       end
 
       def call(**args)
         operator = args.fetch(:operator, nil)
-        arguments = args.fetch(:arguments, [])
-        value = arguments.first&.value
+        arguments = args.fetch(:arguments, List.new)
+        value = arguments.code_first
 
         case operator.to_s
         when "%", "modulo"
@@ -33,10 +33,10 @@ class Code
           code_power(value)
         when "+", "plus"
           sig(args) { Object.maybe }
-          value ? code_plus(value) : self
+          arguments.any? ? code_plus(value) : self
         when "-", "minus"
           sig(args) { (Integer | Decimal).maybe }
-          value ? code_minus(value) : code_unary_minus
+          arguments.any? ? code_minus(value) : code_unary_minus
         when "/", "division"
           sig(args) { Integer | Decimal }
           code_division(value)
@@ -152,7 +152,7 @@ class Code
       end
 
       def code_ceil(n = nil)
-        n ||= Integer.new(0)
+        n = Integer.new(0) if n.nil? || n.is_a?(Nothing)
         Decimal.new(raw.ceil(n.raw))
       end
 
@@ -177,7 +177,7 @@ class Code
       end
 
       def code_floor(n = nil)
-        n ||= Integer.new(0)
+        n = Integer.new(0) if n.nil? || n.is_a?(Nothing)
         Decimal.new(raw.floor(n.raw))
       end
 
@@ -234,7 +234,7 @@ class Code
       end
 
       def code_round(n = nil)
-        n ||= Integer.new(0)
+        n = Integer.new(0) if n.nil? || n.is_a?(Nothing)
         Decimal.new(raw.round(n.raw))
       end
 
@@ -279,7 +279,7 @@ class Code
       end
 
       def code_truncate(n = nil)
-        n ||= Integer.new(0)
+        n = Integer.new(0) if n.nil? || n.is_a?(Nothing)
         Decimal.new(raw.truncate(n.raw))
       end
 
@@ -294,18 +294,6 @@ class Code
       def code_zero?
         Boolean.new(raw.zero?)
       end
-
-      def whole?
-        whole == raw
-      end
-
-      def whole
-        raw.round
-      end
-
-      def as_json(...)
-        whole? ? whole.as_json(...) : super
-      end
     end
   end
 end

data/lib/code/object/dictionary.rb

@@ -3,19 +3,15 @@
 class Code
   class Object
     class Dictionary < ::Code::Object
-      def initialize(*args, **_kargs, &_block)
-        @raw = (args.first.presence || {})
-          .as_json
-          .to_h
-          .transform_keys { |key| Json.to_code(key) }
-          .transform_values { |value| Json.to_code(value) }
+      def initialize(*args, **kargs, &_block)
+        @raw = args.map(&:to_h).reduce({}, &:merge).merge(kargs)
       end
 
       def call(**args)
         operator = args.fetch(:operator, nil)
-        arguments = args.fetch(:arguments, [])
+        arguments = args.fetch(:arguments, List.new)
         globals = multi_fetch(args, *GLOBALS)
-        value = arguments.first&.value
+        value = arguments.code_first
 
         case operator.to_s
         when "<", "inferior"
@@ -50,7 +46,7 @@ class Code
           code_compact
         when "delete"
           sig(args) { Object.repeat(1) }
-          code_delete(*arguments.map(&:value), **globals)
+          code_delete(*arguments.raw, **globals)
         when "delete_if"
           sig(args) { Function | Class }
           code_delete_if(value, **globals)
@@ -59,7 +55,7 @@ class Code
           code_delete_unless(value, **globals)
         when "dig"
           sig(args) { Object.repeat(1) }
-          code_dig(*arguments.map(&:value))
+          code_dig(*arguments.raw)
         when "each"
           sig(args) { Function }
           code_each(value, **globals)
@@ -71,13 +67,13 @@ class Code
           code_empty?
         when "except"
           sig(args) { Object.repeat(1) }
-          code_except(*arguments.map(&:value))
+          code_except(*arguments.raw)
         when "fetch"
           sig(args) { Object.repeat(1) }
-          code_fetch(*arguments.map(&:value), **globals)
+          code_fetch(*arguments.raw, **globals)
         when "fetch_values"
           sig(args) { Object.repeat(1) }
-          code_fetch_values(*arguments.map(&:value))
+          code_fetch_values(*arguments.raw)
         when "five?"
           sig(args)
           code_five?
@@ -104,13 +100,13 @@ class Code
           code_keep_unless(value, **globals)
         when "key"
           sig(args) { [Object, Function.maybe] }
-          code_key(*arguments.map(&:value), **globals)
+          code_key(*arguments.raw, **globals)
         when "keys"
           sig(args)
           code_keys
         when "merge"
           sig(args) { [Dictionary.repeat, Function.maybe] }
-          code_merge(*arguments.map(&:value), **globals)
+          code_merge(*arguments.raw, **globals)
         when "nine?"
           sig(args)
           code_nine?
@@ -177,12 +173,7 @@ class Code
             raw.any? do |key, value|
               argument
                 .call(
-                  arguments: [
-                    Argument.new(key),
-                    Argument.new(value),
-                    Argument.new(self),
-                    Argument.new(Integer.new(index))
-                  ],
+                  arguments: List.new([key, value, self, Integer.new(index)]),
                   **globals
                 )
                 .truthy?
@@ -219,22 +210,16 @@ class Code
           )
 
         arguments = arguments[..-2] if default
+        first = arguments.first
 
         if arguments.one?
-          raw.delete(arguments.first) do
+          raw.delete(first) do
             if default
-              default.call(
-                arguments: [
-                  Argument.new(arguments.first),
-                  Argument.new(self),
-                  Argument.new(index)
-                ],
-                **globals
-              )
+              default.call(arguments: List.new([first, self, index]), **globals)
             else
               raise(
                 Code::Error::KeyNotFound,
-                "#{arguments.first.inspect} not found on #{inspect}"
+                "#{first.inspect} not found on #{inspect}"
               )
             end
           end
@@ -271,12 +256,7 @@ class Code
         else
           raw.delete_if.with_index do |(key, value), index|
             argument.call(
-              arguments: [
-                Argument.new(key),
-                Argument.new(value),
-                Argument.new(self),
-                Argument.new(Integer.new(index))
-              ],
+              arguments: List.new([key, value, self, Integer.new(index)]),
               **globals
             ).truthy?
           end
@@ -291,12 +271,7 @@ class Code
         else
           raw.delete_if.with_index do |(key, value), index|
             argument.call(
-              arguments: [
-                Argument.new(key),
-                Argument.new(value),
-                Argument.new(self),
-                Argument.new(Integer.new(index))
-              ],
+              arguments: List.new([key, value, self, Integer.new(index)]),
               **globals
             ).falsy?
           end
@@ -312,12 +287,7 @@ class Code
       def code_each(argument, **globals)
         raw.each.with_index do |(key, value), index|
           argument.call(
-            arguments: [
-              Argument.new(key),
-              Argument.new(value),
-              Argument.new(self),
-              Argument.new(Integer.new(index))
-            ],
+            arguments: List.new([key, value, self, Integer.new(index)]),
             **globals
           )
         end
@@ -337,7 +307,7 @@ class Code
         self.class.new(raw.except(*))
       end
 
-      def code_fetch(*arguments, index: Integer.new(0), **globals)
+      def code_fetch(*arguments, index: 0, **globals)
         default =
           (
             if arguments.last.is_a?(Function) && arguments.size > 1
@@ -346,45 +316,31 @@ class Code
           )
 
         arguments = arguments[..-2] if default
+        first = arguments.first || Nothing.new
 
         if arguments.one?
-          raw.fetch(arguments.first) do
+          raw.fetch(first) do
             if default
               default.call(
-                arguments: [
-                  Argument.new(arguments.first),
-                  Argument.new(self),
-                  Argument.new(index)
-                ],
+                arguments: List.new([first, Integer.new(index), self]),
                 **globals
               )
             else
               raise(
-                Code::Error::KeyNotFound,
-                "#{arguments.first.inspect} not found on #{inspect}"
+                Error::KeyNotFound,
+                "#{first.inspect} not found on #{inspect}"
               )
             end
           end
         else
-          self.class.new(
+          Dictionary.new(
             arguments
               .map
               .with_index do |argument, index|
                 if default
-                  [
-                    argument,
-                    code_fetch(
-                      argument,
-                      default,
-                      index: Integer.new(index),
-                      **globals
-                    )
-                  ]
+                  [argument, code_fetch(argument, default, index:, **globals)]
                 else
-                  [
-                    argument,
-                    code_fetch(argument, index: Integer.new(index), **globals)
-                  ]
+                  [argument, code_fetch(argument, index:, **globals)]
                 end
               end
               .to_h
@@ -401,7 +357,7 @@ class Code
       end
 
       def code_flatten(level = nil)
-        level ||= Integer.new(-1)
+        level = Integer.new(-1) if level.nil? || level.falsy?
         code_to_list.code_flatten(level)
       end
 
@@ -439,12 +395,7 @@ class Code
         else
           raw.keep_if.with_index do |(key, value), index|
             argument.call(
-              arguments: [
-                Argument.new(key),
-                Argument.new(value),
-                Argument.new(self),
-                Argument.new(Integer.new(index))
-              ],
+              arguments: List.new([key, value, Integer.new(index), self]),
               **globals
             ).truthy?
           end
@@ -459,12 +410,7 @@ class Code
         else
           raw.keep_if.with_index do |(key, value), index|
             argument.call(
-              arguments: [
-                Argument.new(key),
-                Argument.new(value),
-                Argument.new(self),
-                Argument.new(Integer.new(index))
-              ],
+              arguments: List.new([key, value, Integer.new(index), self]),
               **globals
             ).falsy?
           rescue Error::Next => e
@@ -478,10 +424,7 @@ class Code
       def code_key(value, function = nil, **globals)
         if function
           raw.key(value) ||
-            function.call(
-              arguments: [Argument.new(value), Argument.new(self)],
-              **globals
-            )
+            function.call(arguments: List.new([value, self]), **globals)
         else
           raw.key(value) || Nothing.new
         end
@@ -510,13 +453,10 @@ class Code
             if conflict
               conflict
                 .call(
-                  arguments: [
-                    Argument.new(key),
-                    Argument.new(old_value),
-                    Argument.new(new_value),
-                    Argument.new(self),
-                    Argument.new(Integer.new(index))
-                  ],
+                  arguments:
+                    List.new(
+                      [key, old_value, new_value, Integer.new(index), self]
+                    ),
                   **globals
                 )
                 .tap { index += 1 }
@@ -544,12 +484,7 @@ class Code
         else
           raw.select!.with_index do |(key, value), index|
             argument.call(
-              arguments: [
-                Argument.new(key),
-                Argument.new(value),
-                Argument.new(self),
-                Argument.new(Integer.new(index))
-              ],
+              arguments: List.new([key, value, Integer.new(index), self]),
               **globals
             ).truthy?
           rescue Error::Next => e
@@ -567,12 +502,7 @@ class Code
           self.class.new(
             raw.select.with_index do |(key, value), index|
               argument.call(
-                arguments: [
-                  Argument.new(key),
-                  Argument.new(value),
-                  Argument.new(self),
-                  Argument.new(Integer.new(index))
-                ],
+                arguments: List.new([key, value, Integer.new(index), self]),
                 **globals
               ).truthy?
             rescue Error::Next => e
@@ -623,15 +553,15 @@ class Code
         List.new(raw.to_a.map { |key_value| List.new(key_value) })
       end
 
+      def to_h
+        raw
+      end
+
       def code_transform_values(function, **globals)
         self.class.new(
           raw.transform_values.with_index do |value, index|
             function.call(
-              arguments: [
-                Argument.new(value),
-                Argument.new(self),
-                Argument.new(Integer.new(index))
-              ],
+              arguments: List.new([value, Integer.new(index), self]),
               **globals
             )
           rescue Error::Next => e

data/lib/code/object/function.rb

@@ -14,13 +14,13 @@ class Code
 
       def call(**args)
         operator = args.fetch(:operator, nil)
-        arguments = args.fetch(:arguments, [])
+        arguments = args.fetch(:arguments, List.new)
         globals = multi_fetch(args, *GLOBALS)
 
         case operator.to_s
         when "", "call"
           sig(args) { signature_for_call }
-          code_call(*arguments, **globals)
+          code_call(*arguments.raw, **globals)
         else
           super
         end
@@ -30,48 +30,38 @@ class Code
         context = Context.new({}, globals[:context])
 
         parameters.raw.each.with_index do |parameter, index|
-          if parameter.regular_splat?
-            context.code_set(
-              parameter.code_name,
-              List.new(arguments.select(&:regular?).map(&:value))
-            )
-          elsif parameter.keyword_splat?
-            context.code_set(
-              parameter.code_name,
-              Dictionary.new(
-                arguments.select(&:keyword?).map(&:name_value).to_h
-              )
-            )
-          elsif parameter.keyword?
-            argument =
+          argument =
+            if parameter.keyword?
               arguments
-                .detect { |argument| argument.name == parameter.code_name }
-                &.value
-            argument = parameter.evaluate(**globals) if argument.nil?
-            context.code_set(parameter.code_name, argument)
-          elsif parameter.regular?
-            argument = arguments[index]&.value
-            argument = parameter.evaluate(**globals) if argument.nil?
-            context.code_set(parameter.code_name, argument)
-          end
+                .detect do |dictionary|
+                  dictionary.code_has_value?(parameter.code_name)
+                end
+                &.code_get(parameter.code_name)
+            else
+              arguments[index]
+            end
+          argument = parameter.evaluate(**globals) if argument.nil?
+          context.code_set(parameter.code_name, argument)
         end
 
         body.evaluate(**globals, context:)
       end
 
       def signature_for_call
-        parameters.raw.inject([]) do |signature, parameter|
-          if parameter.keyword?
-            if signature.last.is_a?(::Hash)
-              signature.last.code_set(parameter.code_name, Object)
-              signature
+        parameters
+          .raw
+          .inject([]) do |signature, parameter|
+            if parameter.keyword?
+              if signature.last.is_a?(::Hash)
+                signature.last.code_set(parameter.code_name, Object)
+                signature
+              else
+                signature + [{ parameter.code_name => Object }]
+              end
             else
-              signature + [{ parameter.code_name => Object }]
+              signature + [Object]
             end
-          else
-            signature + [Object]
-          end
-        end + [Object.repeat]
+          end + [Object.repeat]
       end
     end
   end