code-ruby 1.1.1 → 1.2.1

data/lib/code/object/range.rb

@@ -3,32 +3,48 @@
 class Code
   class Object
     class Range < Object
-      attr_reader :left, :right, :options, :exclude_end
-
-      def initialize(*args, **_kargs, &)
-        @left = args.first.presence || Integer.new(0)
-        @right = args.second.presence || Integer.new(0)
-        @options = Dictionary.new(args.third.presence || {})
-        @exclude_end = Boolean.new(options.code_get(String.new(:exclude_end)))
-        @raw = ::Range.new(left, right, exclude_end?)
+      attr_reader :code_left, :code_right, :code_options, :code_exclude_end
+
+      def initialize(*args, **kargs, &)
+        if args.first.is_a?(Range)
+          @code_left = args.first.code_left
+          @code_right = args.first.code_right
+          @code_options = args.first.code_options
+          @code_exclude_end = args.first.code_exclude_end
+        else
+          @code_left =
+            (args.first.to_code.nothing? ? Integer.new(0) : args.first.to_code)
+
+          @code_right =
+            if args.second.to_code.nothing?
+              Integer.new(0)
+            else
+              args.second.to_code
+            end
+
+          @code_options = Dictionary.new(args.third.presence || kargs)
+          @code_exclude_end = Boolean.new(code_options.code_get(:exclude_end))
+        end
+
+        @raw = ::Range.new(code_left, code_right, exclude_end?)
       end
 
       def call(**args)
-        operator = args.fetch(:operator, nil)
-        arguments = args.fetch(:arguments, List.new)
+        code_operator = args.fetch(:operator, nil).to_code
+        code_arguments = args.fetch(:arguments, []).to_code
         globals = multi_fetch(args, *GLOBALS)
-        value = arguments.code_first
+        code_value = code_arguments.code_first
 
-        case operator.to_s
+        case code_operator.to_s
         when "all?"
           sig(args) { Function }
-          code_all?(value, **globals)
+          code_all?(code_value, **globals)
         when "any?"
           sig(args) { Function }
-          code_any?(value, **globals)
+          code_any?(code_value, **globals)
         when "each"
           sig(args) { Function }
-          code_each(value, **globals)
+          code_each(code_value, **globals)
         when "first"
           sig(args)
           code_first
@@ -37,13 +53,13 @@ class Code
           code_last
         when "map"
           sig(args) { Function }
-          code_map(value, **globals)
+          code_map(code_value, **globals)
         when "select"
           sig(args) { Function }
-          code_select(value, **globals)
+          code_select(code_value, **globals)
         when "step"
           sig(args) { Integer | Decimal }
-          code_step(value)
+          code_step(code_value)
         when "to_list"
           sig(args)
           code_to_list
@@ -53,12 +69,15 @@ class Code
       end
 
       def code_all?(argument, **globals)
+        code_argument = argument.to_code
+
         index = 0
+
         Boolean.new(
-          raw.all? do |element|
-            argument
+          raw.all? do |code_element|
+            code_argument
               .call(
-                arguments: List.new([element, Integer.new(index), self]),
+                arguments: List.new([code_element, Integer.new(index), self]),
                 **globals
               )
               .truthy?
@@ -68,12 +87,15 @@ class Code
       end
 
       def code_any?(argument, **globals)
+        code_argument = argument.to_code
+
         index = 0
+
         Boolean.new(
-          raw.any? do |element|
-            argument
+          raw.any? do |code_element|
+            code_argument
               .call(
-                arguments: List.new([element, Integer.new(index), self]),
+                arguments: List.new([code_element, Integer.new(index), self]),
                 **globals
               )
               .truthy?
@@ -83,12 +105,15 @@ class Code
       end
 
       def code_each(argument, **globals)
-        raw.each.with_index do |element, index|
-          argument.call(
-            arguments: List.new([element, Integer.new(index), self]),
+        code_argument = argument.to_code
+
+        raw.each.with_index do |code_element, index|
+          code_argument.call(
+            arguments: List.new([code_element, Integer.new(index), self]),
             **globals
           )
         end
+
         self
       end
 
@@ -101,10 +126,12 @@ class Code
       end
 
       def code_map(argument, **globals)
+        code_argument = argument.to_code
+
         List.new(
-          raw.map.with_index do |element, index|
-            argument.call(
-              arguments: List.new([element, Integer.new(index), self]),
+          raw.map.with_index do |code_element, index|
+            code_argument.call(
+              arguments: List.new([code_element, Integer.new(index), self]),
               **globals
             )
           end
@@ -112,10 +139,12 @@ class Code
       end
 
       def code_select(argument, **globals)
+        code_argument = argument.to_code
+
         List.new(
-          raw.select.with_index do |element, index|
-            argument.call(
-              arguments: List.new([element, Integer.new(index), self]),
+          raw.select.with_index do |code_element, index|
+            code_argument.call(
+              arguments: List.new([code_element, Integer.new(index), self]),
               **globals
             ).truthy?
           end
@@ -123,28 +152,31 @@ class Code
       end
 
       def exclude_end?
-        exclude_end.truthy?
+        code_exclude_end.truthy?
       end
 
       def code_step(argument)
-        list = List.new
-        element = left
-        list.code_append(element)
+        code_argument = argument.to_code
+
+        code_list = List.new
+        code_element = code_left
+        code_list.code_append(code_element)
+
+        code_element = code_element.code_plus(code_argument)
 
-        element = element.code_plus(argument)
         if exclude_end?
-          while element.code_inferior(right).truthy?
-            list.code_append(element)
-            element = element.code_plus(argument)
+          while code_element.code_inferior(code_right).truthy?
+            code_list.code_append(code_element)
+            code_element = code_element.code_plus(code_argument)
           end
         else
-          while element.code_inferior_or_equal(right).truthy?
-            list.code_append(element)
-            element = element.code_plus(argument)
+          while code_element.code_inferior_or_equal(code_right).truthy?
+            code_list.code_append(code_element)
+            code_element = code_element.code_plus(code_argument)
           end
         end
 
-        list
+        code_list
       end
 
       def code_to_list

data/lib/code/object/string.rb

@@ -10,27 +10,27 @@ class Code
       end
 
       def call(**args)
-        operator = args.fetch(:operator, nil)
-        arguments = args.fetch(:arguments, List.new)
+        code_operator = args.fetch(:operator, nil).to_code
+        code_arguments = args.fetch(:arguments, List.new).to_code
         globals = multi_fetch(args, *GLOBALS)
-        value = arguments.code_first
+        code_value = code_arguments.code_first
 
-        case operator.to_s
+        case code_operator.to_s
         when "&", "to_function"
           sig(args)
           code_to_function(**globals)
         when "*"
           sig(args) { Integer | Decimal }
-          code_multiplication(value)
+          code_multiplication(code_value)
         when "+"
           sig(args) { Object }
-          code_plus(value)
+          code_plus(code_value)
         when "downcase"
           sig(args)
           code_downcase
         when "include?"
           sig(args) { String }
-          code_include?(value)
+          code_include?(code_value)
         when "reverse"
           sig(args)
           code_reverse
@@ -44,45 +44,26 @@ class Code
       end
 
       def code_include?(value)
-        Boolean.new(raw.include?(value.raw))
+        code_value = value.to_code
+        Boolean.new(raw.include?(code_value.raw))
       end
 
       def code_multiplication(other)
-        String.new(raw * other.raw)
+        code_other = other.to_code
+        String.new(raw * code_other.raw)
       end
 
       def code_plus(other)
-        String.new(raw + other.to_s)
+        code_other = other.to_code
+        String.new(raw + code_other.to_s)
       end
 
       def code_reverse
         String.new(raw.reverse)
       end
 
-      def code_to_function(**globals)
-        Node::Code.new(
-          [
-            {
-              function: {
-                parameters: [{ name: "_" }],
-                body: [
-                  {
-                    left_operation: {
-                      first: {
-                        call: {
-                          name: "_"
-                        }
-                      },
-                      others: [
-                        { operator: ".", statement: { call: { name: raw } } }
-                      ]
-                    }
-                  }
-                ]
-              }
-            }
-          ]
-        ).evaluate(**globals)
+      def code_to_function(**_globals)
+        Function.new([{ name: "_" }], "_.#{raw}")
       end
     end
   end

data/lib/code/object/time.rb

@@ -7,16 +7,13 @@ class Code
 
       def initialize(*args, **_kargs, &)
         ::Time.zone ||= DEFAULT_ZONE
-        raw = args.first
-        raw = raw.raw if raw.is_an?(Object)
-        raw = raw.presence || ::Time.zone.now
-        @raw = ::Time.zone.parse(raw.to_s).presence || ::Time.zone.now
+        @raw = ::Time.zone.parse(args.first.to_s) || ::Time.zone.now
       end
 
       def self.call(**args)
-        operator = args.fetch(:operator, nil)
+        code_operator = args.fetch(:operator, nil).to_code
 
-        case operator.to_s
+        case code_operator.to_s
         when "now"
           sig(args)
           code_now
@@ -54,17 +51,17 @@ class Code
       end
 
       def call(**args)
-        operator = args.fetch(:operator, nil)
-        arguments = args.fetch(:arguments, List.new)
-        value = arguments.code_first
+        code_operator = args.fetch(:operator, nil).to_code
+        code_arguments = args.fetch(:arguments, []).to_code
+        code_value = code_arguments.code_first
 
-        case operator.to_s
+        case code_operator.to_s
         when "after?"
           sig(args) { Time.maybe }
-          code_after?(value)
+          code_after?(code_value)
         when "before?"
           sig(args) { Time.maybe }
-          code_before?(value)
+          code_before?(code_value)
         when "past?"
           sig(args)
           code_past?
@@ -80,13 +77,17 @@ class Code
       end
 
       def code_after?(other = nil)
-        other = Time.code_now if other.nil? || other.is_a?(Nothing)
-        Boolean.new(raw.after?(other.raw))
+        code_other = other.to_code
+        code_other = Time.code_now if code_other.nothing?
+
+        Boolean.new(raw.after?(code_other.raw))
       end
 
       def code_before?(other = nil)
-        other = Time.code_now if other.nil? || other.is_a?(Nothing)
-        Boolean.new(raw.before?(other.raw))
+        code_other = other.to_code
+        code_other = Time.code_now if code_other.nothing?
+
+        Boolean.new(raw.before?(code_other.raw))
       end
 
       def code_past?