code-ruby 0.11.0 → 0.12.0

data/lib/code/object/function.rb

@@ -2,12 +2,30 @@
 
 class Code
   class Object
-    class Function < ::Code::Object
+    class Function < Object
       attr_reader :parameters, :body
 
-      def initialize(parameters:, body:)
-        @parameters = parameters.presence || []
-        @body = body.presence || Node::Code.new
+      def initialize(*args, **_kargs, &_block)
+        parameters = args.first.presence || List.new
+        parameters = parameters.raw if parameters.is_an?(Object)
+        @parameters = List.new(parameters)
+        @parameters.raw.map! do |parameter|
+          if parameter.is_a?(Node::FunctionParameter)
+            Parameter.new(
+              Dictionary.new({
+                String.new(:name) => String.new(parameter.name),
+                String.new(:keyword) => Boolean.new(parameter.keyword?),
+                String.new(:regular_splat) => Boolean.new(parameter.regular_splat?),
+                String.new(:keyword_splat) => Boolean.new(parameter.keyword_splat?),
+                String.new(:default) => Code.new(parameter.default),
+              })
+            )
+          else
+            Parameter.new(parameter)
+          end
+        end
+        @body = Code.new(args.second.presence || Nothing.new)
+        super
       end
 
       def self.name
@@ -17,7 +35,7 @@ class Code
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
-        globals = multi_fetch(args, *::Code::GLOBALS)
+        globals = multi_fetch(args, *GLOBALS)
 
         case operator.to_s
         when "", "call"
@@ -29,27 +47,21 @@ class Code
       end
 
       def code_call(*arguments, **globals)
-        context = Context.new({}, parent: globals[:context])
+        context = Context.new({}, globals[:context])
 
-        parameters.each.with_index do |parameter, index|
-          if parameter.regular?
-            if parameter.regular_splat?
-              context.code_set(
-                parameter.name,
-                List.new(arguments.select(&:regular?).map(&:value))
-              )
-            elsif parameter.keyword_splat?
-              context.code_set(
-                parameter.name,
-                Dictionary.new(
-                  arguments.select(&:keyword?).map(&:name_value).to_h
-                )
+        parameters.raw.each.with_index do |parameter, index|
+          if parameter.regular_splat?
+            context.code_set(
+              parameter.name,
+              List.new(arguments.select(&:regular?).map(&:value))
+            )
+          elsif parameter.keyword_splat?
+            context.code_set(
+              parameter.name,
+              Dictionary.new(
+                arguments.select(&:keyword?).map(&:name_value).to_h
               )
-            else
-              argument = arguments[index]&.value
-              argument = parameter.evaluate(**globals) if argument.nil?
-              context.code_set(parameter.name, argument)
-            end
+            )
           elsif parameter.keyword?
             argument =
               arguments
@@ -57,6 +69,10 @@ class Code
                 &.value
             argument = parameter.evaluate(**globals) if argument.nil?
             context.code_set(parameter.name, argument)
+          elsif parameter.regular?
+            argument = arguments[index]&.value
+            argument = parameter.evaluate(**globals) if argument.nil?
+            context.code_set(parameter.name, argument)
           end
         end
 
@@ -68,10 +84,10 @@ class Code
       end
 
       def signature_for_call
-        parameters.inject([]) do |signature, parameter|
+        parameters.raw.inject([]) do |signature, parameter|
           if parameter.keyword?
             if signature.last.is_a?(::Hash)
-              signature.last[parameter.name] = Object
+              signature.last.code_set(parameter.name, Object)
               signature
             else
               signature + [{ parameter.name => Object }]

data/lib/code/object/global.rb

@@ -2,11 +2,15 @@
 
 class Code
   class Object
-    class Global < ::Code::Object
+    class Global < Object
       def self.name
         "Global"
       end
 
+      def initialize(...)
+        super
+      end
+
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
@@ -14,62 +18,78 @@ class Code
         context = args.fetch(:context)
         globals = multi_fetch(args, *GLOBALS)
         value = arguments.first&.value
+        values = arguments.map(&:value)
 
         case operator.to_s
         when "Boolean"
-          sig(args) { Object.maybe }
-          value ? value.code_to_boolean : Class.new(Boolean)
+          sig(args) { Object.repeat }
+          value ? Boolean.new(*values) : Class.new(Boolean)
         when "break"
-          sig(args) { Object.maybe }
+          sig(args) { Object.repeat }
           raise Error::Break, value || Nothing.new
         when "next"
-          sig(args) { Object.maybe }
+          sig(args) { Object.repeat }
           raise Error::Next, value || Nothing.new
         when "Class"
-          sig(args) { Object.maybe }
-          value ? value.code_to_class : Class.new(Class)
+          sig(args) { Object.repeat }
+          value ? Class.new(*values) : Class.new(Class)
         when "Date"
-          sig(args) { Object.maybe }
-          value ? value.code_to_date : Class.new(Date)
+          sig(args) { Object.repeat }
+          value ? Date.new(*values) : Class.new(Date)
         when "Decimal"
-          sig(args) { Object.maybe }
-          value ? value.code_to_decimal : Class.new(Decimal)
+          sig(args) { Object.repeat }
+          value ? Decimal.new(*values) : Class.new(Decimal)
         when "Dictionary"
-          sig(args) { Object.maybe }
-          value ? value.code_to_dictionnary : Class.new(Dictionary)
-        when "fetch"
-          sig(args) { [Object, Function.maybe] }
-          context.code_fetch(*arguments.map(&:value), **globals)
+          sig(args) { Object.repeat }
+          value ? Dictionary.new(*values) : Class.new(Dictionary)
+        when "Duration"
+          sig(args) { Object.repeat }
+          value ? Duration.new(*values) : Class.new(Duration)
         when "Function"
-          sig(args) { Object.maybe }
-          value ? value.code_to_function : Class.new(Function)
+          sig(args)
+          Class.new(Function)
         when "Integer"
-          sig(args) { Object.maybe }
-          value ? value.code_to_integer : Class.new(Integer)
+          sig(args) { Object.repeat }
+          value ? Integer.new(*values) : Class.new(Integer)
         when "List"
-          sig(args) { Object.maybe }
-          value ? value.code_to_list : Class.new(List)
+          sig(args) { Object.repeat }
+          value ? List.new(*values) : Class.new(List)
         when "Nothing"
-          sig(args) { Object.maybe }
-          value ? value.code_to_nothing : Class.new(Nothing)
-        when "Number"
-          sig(args) { Object.maybe }
-          value ? value.code_to_number : Class.new(Number)
+          sig(args) { Object.repeat }
+          value ? Nothing.new(*values) : Class.new(Nothing)
+        when "context"
+          sig(args)
+          context
         when "Object"
-          sig(args) { Object.maybe }
-          value ? value.code_to_object : Class.new(Object)
+          sig(args)
+          Class.new(Object)
         when "Range"
-          sig(args) { Object.maybe }
-          value ? value.code_to_range : Class.new(Range)
+          sig(args) { Object.repeat }
+          value ? Range.new(*values) : Class.new(Range)
         when "String"
-          sig(args) { Object.maybe }
-          value ? value.code_to_string : Class.new(String)
+          sig(args) { Object.repeat }
+          value ? String.new(*values) : Class.new(String)
         when "Time"
-          sig(args) { Object.maybe }
-          value ? value.code_to_time : Class.new(Time)
-        when "context"
-          sig(args) { String.maybe }
-          value ? context.code_get(value) || Nothing.new : context
+          sig(args) { Object.repeat }
+          value ? Time.new(*values) : Class.new(Time)
+        when "Context"
+          sig(args) { Object.repeat }
+          value ? Context.new(*values) : Class.new(Context)
+        when "Code"
+          sig(args) { Object.repeat }
+          value ? Code.new(*values) : Class.new(Code)
+        when "Argument"
+          sig(args) { Object.repeat }
+          value ? Argument.new(*values) : Class.new(Argument)
+        when "Parameter"
+          sig(args) { Object.repeat }
+          value ? Parameter.new(*values) : Class.new(Parameter)
+        when "Range"
+          sig(args) { Object.repeat }
+          value ? Range.new(*values) : Class.new(Range)
+        when "IdentifierList"
+          sig(args) { Object.repeat }
+          value ? IdentifierList.new(*values) : Class.new(IdentifierList)
         when "evaluate"
           sig(args) { Object }
           Code.evaluate(value.to_s)

data/lib/code/object/integer.rb

@@ -2,18 +2,15 @@
 
 class Code
   class Object
-    class Integer < Number
-      attr_reader :raw
-
-      def initialize(whole, exponent: nil)
-        whole = whole.raw if whole.is_a?(Integer)
-        @raw = whole.to_i
-        return unless exponent
-
-        exponent = exponent.raw if exponent.is_a?(Number)
-        @raw *= 10**exponent
+    class Integer < Object
+      def initialize(*args, **_kargs, &_block)
+        whole = args.first || 0
+        exponent = args.second || 0
+        whole = whole.raw if whole.is_an?(Object)
+        exponent = exponent.raw if exponent.is_an?(Object)
+        @raw = whole.to_i * 10**exponent
       rescue FloatDomainError => e
-        raise Error, e.message
+        raise Error, "#{decimal.inspect} * 10**#{exponent.inspect} is invalid"
       end
 
       def self.name
@@ -28,49 +25,49 @@ class Code
 
         case operator.to_s
         when "%", "modulo"
-          sig(args) { Number }
+          sig(args) { Integer | Decimal }
           code_modulo(value)
         when "&", "bitwise_and"
-          sig(args) { Number }
+          sig(args) { Integer | Decimal }
           code_bitwise_and(value)
         when "*", "multiplication", "×"
-          sig(args) { Number | String }
+          sig(args) { Integer | Decimal | String }
           code_multiplication(value)
         when "**", "power"
-          sig(args) { Number }
+          sig(args) { Integer | Decimal }
           code_power(value)
         when "+", "plus", "self"
           sig(args) { Object.maybe }
           value ? code_plus(value) : code_self
         when "-", "minus", "unary_minus"
-          sig(args) { Number.maybe }
+          sig(args) { Integer | Decimal.maybe }
           value ? code_minus(value) : code_unary_minus
         when "/", "division", "÷"
-          sig(args) { Number }
+          sig(args) { Integer | Decimal }
           code_division(value)
         when "<", "inferior"
-          sig(args) { Number }
+          sig(args) { Integer | Decimal }
           code_inferior(value)
         when "<<", "left_shift"
-          sig(args) { Number }
+          sig(args) { Integer | Decimal }
           code_left_shift(value)
         when "<=", "inferior_or_equal"
-          sig(args) { Number }
+          sig(args) { Integer | Decimal }
           code_inferior_or_equal(value)
         when "<=>", "compare"
-          sig(args) { Number }
+          sig(args) { Integer | Decimal }
           code_compare(value)
         when ">", "superior"
-          sig(args) { Number }
+          sig(args) { Integer | Decimal }
           code_superior(value)
         when ">=", "superior_or_equal"
-          sig(args) { Number }
+          sig(args) { Integer | Decimal }
           code_superior_or_equal(value)
         when ">>", "right_shift"
-          sig(args) { Number }
+          sig(args) { Integer | Decimal }
           code_right_shift(value)
         when "^", "bitwise_xor"
-          sig(args) { Number }
+          sig(args) { Integer | Decimal }
           code_bitwise_xor(value)
         when "abs"
           sig(args)
@@ -163,7 +160,7 @@ class Code
           sig(args)
           code_zero?
         when "|", "bitwise_or"
-          sig(args) { Number }
+          sig(args) { Integer | Decimal }
           code_bitwise_or(value)
         else
           super

data/lib/code/object/list.rb

@@ -2,12 +2,12 @@
 
 class Code
   class Object
-    class List < ::Code::Object
-      attr_reader :raw
-
-      def initialize(raw = [])
-        raw = raw.raw if raw.is_a?(List)
+    class List < Object
+      def initialize(*args, **_kargs, &_block)
+        raw = args.first || Nothing.new
+        raw = raw.raw if raw.is_an?(Object)
         @raw = raw.to_a
+        super
       end
 
       def self.name

data/lib/code/object/nothing.rb

@@ -2,10 +2,8 @@
 
 class Code
   class Object
-    class Nothing < ::Code::Object
-      attr_reader :raw
-
-      def initialize
+    class Nothing < Object
+      def initialize(*_args, **_kargs, &_block)
         @raw = nil
       end
 

data/lib/code/object/parameter.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class Code
+  class Object
+    class Parameter < Object
+      attr_reader :name, :keyword, :regular_splat, :keyword_splat, :default
+
+      def self.name
+        "Parameter"
+      end
+
+      def initialize(*args, **_kargs, &_block)
+        @raw = Dictionary.new(args.first.presence || {})
+        @name = String.new(@raw.code_get(String.new(:name)))
+        @keyword = Boolean.new(@raw.code_get(String.new(:keyword)))
+        @regular_splat = Boolean.new(@raw.code_get(String.new(:regular_splat)))
+        @keyword_splat = Boolean.new(@raw.code_get(String.new(:keyword_splat)))
+        @default = Code.new(@raw.code_get(String.new(:default)))
+        super
+      end
+
+      def evaluate(...)
+        default.evaluate(...)
+      end
+
+      def regular?
+        !keyword?
+      end
+
+      def keyword?
+        keyword.truthy?
+      end
+
+      def regular_splat?
+        regular_splat.truthy?
+      end
+
+      def keyword_splat?
+        keyword_splat.truthy?
+      end
+    end
+  end
+end

data/lib/code/object/range.rb

@@ -3,13 +3,15 @@
 class Code
   class Object
     class Range < Object
-      attr_reader :raw, :exclude_end, :left, :right
+      attr_reader :left, :right, :options, :exclude_end
 
-      def initialize(left, right, exclude_end: false)
-        @left = left
-        @right = right
-        @exclude_end = !exclude_end.nil?
-        @raw = ::Range.new(left, right, exclude_end)
+      def initialize(*args, **_kargs, &_block)
+        @left = args.first.presence || Integer.new(0)
+        @right = args.second.presence || Integer.new(0)
+        @options = Dictionary.new(args.third.presence || Dictionary.new)
+        @exclude_end = Boolean.new(@options.code_get(String.new(:exclude_end)))
+        @raw = ::Range.new(left, right, exclude_end?)
+        super
       end
 
       def self.name
@@ -45,7 +47,7 @@ class Code
           sig(args) { Function }
           code_select(value, **globals)
         when "step"
-          sig(args) { Number }
+          sig(args) { Integer | Decimal }
           code_step(value)
         when "to_list"
           sig(args)
@@ -102,6 +104,10 @@ class Code
         )
       end
 
+      def exclude_end?
+        exclude_end.truthy?
+      end
+
       def code_step(argument)
         list = List.new
         element = left
@@ -127,10 +133,6 @@ class Code
         List.new(raw.to_a)
       end
 
-      def exclude_end?
-        !!exclude_end
-      end
-
       def inspect
         to_s
       end

data/lib/code/object/string.rb

@@ -3,11 +3,11 @@
 class Code
   class Object
     class String < Object
-      attr_reader :raw
-
-      def initialize(string)
-        string = string.raw if string.is_a?(String)
-        @raw = string.to_s
+      def initialize(*args, **_kargs, &_block)
+        raw = args.first || Nothing.new
+        raw = raw.raw if raw.is_a?(Object)
+        @raw = raw.to_s
+        super
       end
 
       def self.name
@@ -25,7 +25,7 @@ class Code
           sig(args)
           code_to_function(**globals)
         when "*"
-          sig(args) { Number }
+          sig(args) { Integer | Decimal }
           code_multiplication(value)
         when "+"
           sig(args) { Object }
@@ -65,7 +65,7 @@ class Code
       end
 
       def code_to_function(**globals)
-        Code::Node::Code.new(
+        Node::Code.new(
           [
             {
               function: {

data/lib/code/object/time.rb

@@ -5,13 +5,12 @@ class Code
     class Time < Object
       DEFAULT_ZONE = "Etc/UTC"
 
-      attr_reader :raw
-
-      def initialize(time)
+      def initialize(*args, **_kargs, &_block)
         ::Time.zone ||= DEFAULT_ZONE
-        time = time.raw if time.is_a?(Time)
-        time = time.to_s if time.is_a?(::Time)
-        @raw = ::Time.zone.parse(time)
+        raw = args.first.presence || ::Time.zone.now
+        raw = raw.raw if raw.is_an?(Object)
+        @raw = ::Time.zone.parse(raw.to_s)
+        super
       end
 
       def self.name
@@ -28,6 +27,9 @@ class Code
         when "tomorrow"
           sig(args)
           code_tomorrow
+        when "yesterday"
+          sig(args)
+          code_yesterday
         else
           super
         end
@@ -35,12 +37,17 @@ class Code
 
       def self.code_tomorrow
         ::Time.zone ||= DEFAULT_ZONE
-        new(::Time.zone.tomorrow.beginning_of_day)
+        new(::Time.zone.tomorrow)
+      end
+
+      def self.code_yesterday
+        ::Time.zone ||= DEFAULT_ZONE
+        new(::Time.zone.yesterday)
       end
 
       def self.code_now
         ::Time.zone ||= DEFAULT_ZONE
-        new(::Time.zone.now.beginning_of_day)
+        new(::Time.zone.now)
       end
 
       def call(**args)