code-ruby 0.11.0 → 0.13.0

data/lib/code/object/decimal.rb

@@ -2,23 +2,15 @@
 
 class Code
   class Object
-    class Decimal < ::Code::Object::Number
-      attr_reader :raw
-
-      def initialize(decimal, exponent: nil)
-        decimal = decimal.raw if decimal.is_a?(Decimal)
-        @raw = BigDecimal(decimal)
-
-        return unless exponent
-        unless exponent.is_a?(Number)
-          raise ::Code::Error::TypeError, "exponent is not a number"
-        end
-
-        @raw *= 10**exponent.raw
-      end
-
-      def self.name
-        "Decimal"
+    class Decimal < Object
+      def initialize(*args, **_kargs, &_block)
+        decimal = args.first || "0"
+        exponent = args.second || "0"
+        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
+        raise Error, "#{decimal.inspect} * 10**#{exponent.inspect} is invalid"
       end
 
       def call(**args)
@@ -28,49 +20,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 }
+          sig(args) { Integer | Decimal }
           code_multiplication(value)
         when "**", "power"
-          sig(args) { Number }
+          sig(args) { Integer | Decimal }
           code_power(value)
         when "+", "plus"
           sig(args) { Object.maybe }
           value ? code_plus(value) : self
         when "-", "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)
@@ -136,7 +128,7 @@ class Code
           sig(args)
           code_zero?
         when "|", "bitwise_or"
-          sig(args) { Number }
+          sig(args) { Integer | Decimal }
           code_bitwise_or(value)
         else
           super
@@ -226,7 +218,7 @@ class Code
       end
 
       def code_plus(other)
-        if other.is_a?(Number)
+        if other.is_an?(Integer) || other.is_a?(Decimal)
           Decimal.new(raw + other.raw)
         else
           String.new(to_s + other.to_s)
@@ -303,16 +295,16 @@ class Code
         Boolean.new(raw.zero?)
       end
 
-      def inspect
-        to_s
+      def whole?
+        whole == raw
       end
 
-      def to_s
-        raw.to_s("F")
+      def whole
+        raw.round
       end
 
       def as_json(...)
-        raw.as_json(...)
+        whole? ? whole.as_json(...) : super
       end
     end
   end

data/lib/code/object/dictionary.rb

@@ -3,15 +3,12 @@
 class Code
   class Object
     class Dictionary < ::Code::Object
-      attr_reader :raw
-
-      def initialize(raw = {})
-        raw = raw.raw if raw.is_a?(Dictionary)
-        @raw = raw.to_h
-      end
-
-      def self.name
-        "Dictionary"
+      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) }
       end
 
       def call(**args)
@@ -654,18 +651,6 @@ class Code
       def code_zero?
         code_size.code_zero?
       end
-
-      def inspect
-        to_s
-      end
-
-      def to_s
-        "{#{raw.map { |key, value| "#{key.inspect} => #{value.inspect}" }.join(", ")}}"
-      end
-
-      def as_json(...)
-        raw.as_json(...)
-      end
     end
   end
 end

data/lib/code/object/duration.rb

@@ -3,15 +3,13 @@
 class Code
   class Object
     class Duration < Object
-      attr_reader :raw
-
-      def initialize(duration)
-        duration = duration.raw if duration.is_a?(Duration)
-        @raw = duration
-      end
-
-      def self.name
-        "Duration"
+      def initialize(*args, **_kargs, &_block)
+        raw = args.first || 0.seconds
+        raw = raw.raw if raw.is_an?(Object)
+        raw = raw.iso8601 if raw.is_an?(::ActiveSupport::Duration)
+        @raw = ::ActiveSupport::Duration.parse(raw.to_s)
+      rescue ::ActiveSupport::Duration::ISO8601Parser::ParsingError
+        raise Error, "#{raw.inspect} is not a valid duration"
       end
 
       def call(**args)
@@ -36,18 +34,6 @@ class Code
       def code_from_now
         Time.new(raw.from_now)
       end
-
-      def inspect
-        to_s
-      end
-
-      def to_s
-        raw.to_s
-      end
-
-      def as_json(...)
-        raw.as_json(...)
-      end
     end
   end
 end

data/lib/code/object/function.rb

@@ -2,22 +2,20 @@
 
 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
-      end
-
-      def self.name
-        "Function"
+      def initialize(*args, **_kargs, &_block)
+        @parameters = List.new(args.first.presence || [])
+        @parameters.raw.map! { |parameter| Parameter.new(parameter) }
+        @body = Code.new(args.second.presence || Nothing.new)
+        @raw = List.new(parameters, body)
       end
 
       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,66 +27,52 @@ 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.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
               )
-            else
-              argument = arguments[index]&.value
-              argument = parameter.evaluate(**globals) if argument.nil?
-              context.code_set(parameter.name, argument)
-            end
+            )
           elsif parameter.keyword?
             argument =
               arguments
-                .detect { |argument| argument.name == parameter.name }
+                .detect { |argument| argument.name == parameter.code_name }
                 &.value
             argument = parameter.evaluate(**globals) if argument.nil?
-            context.code_set(parameter.name, argument)
+            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
         end
 
         body.evaluate(**globals, context:)
       end
 
-      def inspect
-        "function"
-      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.code_name, Object)
               signature
             else
-              signature + [{ parameter.name => Object }]
+              signature + [{ parameter.code_name => Object }]
             end
           else
             signature + [Object]
           end
         end + [Object.repeat]
       end
-
-      def to_s
-        ""
-      end
-
-      def as_json(...)
-        raw.as_json(...)
-      end
     end
   end
 end

data/lib/code/object/global.rb

@@ -2,9 +2,9 @@
 
 class Code
   class Object
-    class Global < ::Code::Object
-      def self.name
-        "Global"
+    class Global < Object
+      def initialize(...)
+        super
       end
 
       def call(**args)
@@ -14,62 +14,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/identifier_list.rb

@@ -3,10 +3,6 @@
 class Code
   class Object
     class IdentifierList < List
-      def self.name
-        "IdentifierList"
-      end
-
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])

data/lib/code/object/integer.rb

@@ -2,22 +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
-      end
-
-      def self.name
-        "Integer"
+        raise Error, "#{decimal.inspect} * 10**#{exponent.inspect} is invalid"
       end
 
       def call(**args)
@@ -28,49 +21,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 +156,7 @@ class Code
           sig(args)
           code_zero?
         when "|", "bitwise_or"
-          sig(args) { Number }
+          sig(args) { Integer | Decimal }
           code_bitwise_or(value)
         else
           super
@@ -394,22 +387,6 @@ class Code
       def code_days
         Duration.new(raw.days)
       end
-
-      def inspect
-        to_s
-      end
-
-      def succ
-        Integer.new(raw + 1)
-      end
-
-      def to_s
-        raw.to_s
-      end
-
-      def as_json(...)
-        raw.as_json(...)
-      end
     end
   end
 end

data/lib/code/object/json.rb

@@ -0,0 +1,29 @@
+class Code
+  class Object
+    class Json < Object
+      def self.to_code(json)
+        if json.is_an?(Object)
+          json
+        elsif json.is_a?(::Hash)
+          Dictionary.new(json)
+        elsif json.is_a?(::Array)
+          List.new(json)
+        elsif json.is_a?(::String)
+          String.new(json)
+        elsif json.is_a?(::Float)
+          Decimal.new(json)
+        elsif json.is_an?(::Integer)
+          Integer.new(json)
+        elsif json.is_a?(::TrueClass)
+          Boolean.new(json)
+        elsif json.is_a?(::FalseClass)
+          Boolean.new(json)
+        elsif json.is_a?(::NilClass)
+          Nothing.new(json)
+        else
+          Nothing.new
+        end
+      end
+    end
+  end
+end

data/lib/code/object/list.rb

@@ -2,18 +2,13 @@
 
 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
       end
 
-      def self.name
-        "List"
-      end
-
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
@@ -234,18 +229,6 @@ class Code
       def code_sum
         raw.inject(&:code_plus) || Nothing.new
       end
-
-      def inspect
-        to_s
-      end
-
-      def to_s
-        "[#{raw.map(&:inspect).join(", ")}]"
-      end
-
-      def as_json(...)
-        raw.as_json(...)
-      end
     end
   end
 end