code-ruby 1.1.1 → 1.2.1

data/lib/code/object/integer.rb

@@ -4,73 +4,78 @@ class Code
   class Object
     class Integer < Object
       def initialize(*args, **_kargs, &)
-        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)
+        @raw =
+          if args.first.class.in?(NUMBER_CLASSES)
+            if args.second.class.in?(NUMBER_CLASSES)
+              (args.first.to_s.to_d * (10**args.second.to_s.to_d)).to_i
+            else
+              args.first.to_s.to_i
+            end
+          else
+            0
+          end
       rescue FloatDomainError
-        raise Error, "#{decimal.inspect} * 10**#{exponent.inspect} is invalid"
+        @raw = 0
       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 "%", "modulo"
           sig(args) { Integer | Decimal }
-          code_modulo(value)
+          code_modulo(code_value)
         when "&", "bitwise_and"
           sig(args) { Integer | Decimal }
-          code_bitwise_and(value)
+          code_bitwise_and(code_value)
         when "*", "multiplication", "×"
           sig(args) { Integer | Decimal | String }
-          code_multiplication(value)
+          code_multiplication(code_value)
         when "**", "power"
           sig(args) { Integer | Decimal }
-          code_power(value)
+          code_power(code_value)
         when "+", "plus", "self"
           sig(args) { Object.maybe }
-          arguments.any? ? code_plus(value) : code_self
+          code_arguments.any? ? code_plus(code_value) : code_self
         when "-", "minus", "unary_minus"
           sig(args) { Integer | Decimal.maybe }
-          arguments.any? ? code_minus(value) : code_unary_minus
+          code_arguments.any? ? code_minus(code_value) : code_unary_minus
         when "/", "division", "÷"
           sig(args) { Integer | Decimal }
-          code_division(value)
+          code_division(code_value)
         when "<", "inferior"
           sig(args) { Integer | Decimal }
-          code_inferior(value)
+          code_inferior(code_value)
         when "<<", "left_shift"
           sig(args) { Integer | Decimal }
-          code_left_shift(value)
+          code_left_shift(code_value)
         when "<=", "inferior_or_equal"
           sig(args) { Integer | Decimal }
-          code_inferior_or_equal(value)
+          code_inferior_or_equal(code_value)
         when "<=>", "compare"
           sig(args) { Integer | Decimal }
-          code_compare(value)
+          code_compare(code_value)
         when ">", "superior"
           sig(args) { Integer | Decimal }
-          code_superior(value)
+          code_superior(code_value)
         when ">=", "superior_or_equal"
           sig(args) { Integer | Decimal }
-          code_superior_or_equal(value)
+          code_superior_or_equal(code_value)
         when ">>", "right_shift"
           sig(args) { Integer | Decimal }
-          code_right_shift(value)
+          code_right_shift(code_value)
         when "^", "bitwise_xor"
           sig(args) { Integer | Decimal }
-          code_bitwise_xor(value)
+          code_bitwise_xor(code_value)
         when "abs"
           sig(args)
           code_abs
         when "ceil"
           sig(args) { Integer.maybe }
-          code_ceil(value)
+          code_ceil(code_value)
         when "clone"
           sig(args)
           code_clone
@@ -79,10 +84,10 @@ class Code
           code_days
         when "decrement!"
           sig(args) { Integer.maybe }
-          code_decrement!(value)
+          code_decrement!(code_value)
         when "decrement"
           sig(args) { Integer.maybe }
-          code_decrement(value)
+          code_decrement(code_value)
         when "eight?"
           sig(args)
           code_eight?
@@ -94,7 +99,7 @@ class Code
           code_five?
         when "floor"
           sig(args) { Integer.maybe }
-          code_floor(value)
+          code_floor(code_value)
         when "four?"
           sig(args)
           code_four?
@@ -103,10 +108,10 @@ class Code
           code_hours
         when "increment!"
           sig(args) { Integer.maybe }
-          code_increment!(value)
+          code_increment!(code_value)
         when "increment"
           sig(args) { Integer.maybe }
-          code_increment(value)
+          code_increment(code_value)
         when "nine?"
           sig(args)
           code_nine?
@@ -118,7 +123,7 @@ class Code
           code_one?
         when "round"
           sig(args) { Integer.maybe }
-          code_round(value)
+          code_round(code_value)
         when "seven?"
           sig(args)
           code_seven?
@@ -136,10 +141,10 @@ class Code
           code_three?
         when "times"
           sig(args) { Function }
-          code_times(value, **globals)
+          code_times(code_value, **globals)
         when "truncate"
           sig(args) { Integer.maybe }
-          code_truncate(value)
+          code_truncate(code_value)
         when "two?"
           sig(args)
           code_two?
@@ -148,7 +153,7 @@ class Code
           code_zero?
         when "|", "bitwise_or"
           sig(args) { Integer | Decimal }
-          code_bitwise_or(value)
+          code_bitwise_or(code_value)
         else
           super
         end
@@ -159,20 +164,24 @@ class Code
       end
 
       def code_bitwise_and(other)
-        Integer.new(raw & other.raw.to_i)
+        code_other = other.to_code
+        Integer.new(raw & code_other.raw.to_i)
       end
 
       def code_bitwise_or(other)
-        Integer.new(raw | other.raw.to_i)
+        code_other = other.to_code
+        Integer.new(raw | code_other.raw.to_i)
       end
 
       def code_bitwise_xor(other)
-        Integer.new(raw ^ other.raw.to_i)
+        code_other = other.to_code
+        Integer.new(raw ^ code_other.raw.to_i)
       end
 
       def code_ceil(n = nil)
-        n = Integer.new(0) if n.nil? || n.is_a?(Nothing)
-        Integer.new(raw.ceil(n.raw))
+        code_n = n.to_code
+        code_n = Integer.new(0) if code_n.nothing?
+        Integer.new(raw.ceil(code_n.raw))
       end
 
       def code_clone
@@ -180,26 +189,30 @@ class Code
       end
 
       def code_compare(other)
-        Integer.new(raw <=> other.raw)
+        code_other = other.to_code
+        Integer.new(raw <=> code_other.raw)
       end
 
       def code_decrement!(n = nil)
-        n = Integer.new(1) if n.nil? || n.is_a?(Nothing)
-        @raw -= n.raw
+        code_n = n.to_code
+        code_n = Integer.new(1) if code_n.nothing?
+        @raw -= code_n.raw
         self
       end
 
       def code_decrement(n = nil)
-        n = Integer.new(1) if n.nil? || n.is_a?(Nothing)
-        Integer.new(raw - n.raw)
+        code_n = n.to_code
+        code_n = Integer.new(1) if code_n.nothing?
+        Integer.new(raw - code_n.raw)
       end
 
       def code_division(other)
-        Decimal.new(BigDecimal(raw) / other.raw)
+        code_other = other.to_code
+        Decimal.new(BigDecimal(raw) / code_other.raw)
       end
 
       def code_eight?
-        Boolean.new(raw == 8)
+        Boolean.new(raw.eight?)
       end
 
       def code_even?
@@ -207,69 +220,81 @@ class Code
       end
 
       def code_five?
-        Boolean.new(raw == 5)
+        Boolean.new(raw.five?)
       end
 
       def code_floor(n = nil)
-        n = Integer.new(0) if n.nil? || n.is_a?(Nothing)
-        Integer.new(raw.floor(n.raw))
+        code_n = n.to_code
+        code_n = Integer.new(0) if code_n.nothing?
+        Integer.new(raw.floor(code_n.raw))
       end
 
       def code_four?
-        Boolean.new(raw == 4)
+        Boolean.new(raw.four?)
       end
 
       def code_increment!(n = nil)
-        n = Integer.new(1) if n.nil? || n.is_a?(Nothing)
-        @raw += n.raw
+        code_n = n.to_code
+        code_n = Integer.new(1) if code_n.nothing?
+        @raw += code_n.raw
         self
       end
 
       def code_increment(n = nil)
-        n = Integer.new(1) if n.nil? || n.is_a?(Nothing)
-        Integer.new(raw + n.raw)
+        code_n = n.to_code
+        code_n = Integer.new(1) if code_n.nothing?
+        Integer.new(raw + code_n.raw)
       end
 
       def code_inferior(other)
-        Boolean.new(raw < other.raw)
+        code_other = other.to_code
+        Boolean.new(raw < code_other.raw)
       end
 
       def code_inferior_or_equal(other)
-        Boolean.new(raw <= other.raw)
+        code_other = other.to_code
+        Boolean.new(raw <= code_other.raw)
       end
 
       def code_left_shift(other)
-        Integer.new(raw << other.raw.to_i)
+        code_other = other.to_code
+        Integer.new(raw << code_other.raw.to_i)
       end
 
       def code_minus(other)
-        if other.is_a?(Integer)
-          Integer.new(raw - other.raw)
+        code_other = other.to_code
+
+        if code_other.is_a?(Integer)
+          Integer.new(raw - code_other.raw)
         else
-          Decimal.new(raw - other.raw)
+          Decimal.new(raw - code_other.raw)
         end
       end
 
       def code_modulo(other)
-        if other.is_a?(Integer)
-          Integer.new(raw % other.raw)
+        code_other = other.to_code
+
+        if code_other.is_a?(Integer)
+          Integer.new(raw % code_other.raw)
         else
-          Decimal.new(raw % other.raw)
+          Decimal.new(raw % code_other.raw)
         end
       end
 
       def code_multiplication(other)
-        if other.is_a?(Integer)
-          Integer.new(raw * other.raw)
-        elsif other.is_a?(Decimal)
-          Decimal.new(raw * other.raw)
+        code_other = other.to_code
+
+        if code_other.is_a?(Integer)
+          Integer.new(raw * code_other.raw)
+        elsif code_other.is_a?(Decimal)
+          Decimal.new(raw * code_other.raw)
         else
-          String.new(other.raw * raw)
+          String.new(code_other.raw * raw)
         end
       end
 
       def code_nine?
-        Boolean.new(raw == 9)
+        Boolean.new(raw.nine?)
       end
 
       def code_odd?
@@ -281,17 +306,21 @@ class Code
       end
 
       def code_plus(other)
-        if other.is_a?(Integer)
-          Integer.new(raw + other.raw)
-        elsif other.is_a?(Decimal)
-          Decimal.new(raw + other.raw)
+        code_other = other.to_code
+
+        if code_other.is_a?(Integer)
+          Integer.new(raw + code_other.raw)
+        elsif code_other.is_a?(Decimal)
+          Decimal.new(raw + code_other.raw)
         else
-          String.new(to_s + other.to_s)
+          String.new(to_s + code_other.to_s)
         end
       end
 
       def code_power(other)
-        if other.is_a?(Integer)
+        code_other = other.to_code
+
+        if code_other.is_a?(Integer)
           Integer.new(raw**other.raw)
         else
           Decimal.new(raw**other.raw)
@@ -299,20 +328,23 @@ class Code
       end
 
       def code_right_shift(other)
-        Integer.new(raw >> other.raw.to_i)
+        code_other = other.to_code
+        Integer.new(raw >> code_other.raw.to_i)
       end
 
       def code_round(n = nil)
-        n = Integer.new(0) if n.nil? || n.is_a?(Nothing)
-        Integer.new(raw.round(n.raw))
+        code_n = n.to_code
+        code_n = Integer.new(0) if code_n.nothing?
+
+        Integer.new(raw.round(code_n.raw))
       end
 
       def code_seven?
-        Boolean.new(raw == 7)
+        Boolean.new(raw.seven?)
       end
 
       def code_six?
-        Boolean.new(raw == 6)
+        Boolean.new(raw.six?)
       end
 
       def code_sqrt
@@ -320,19 +352,23 @@ class Code
       end
 
       def code_superior(other)
-        Boolean.new(raw > other.raw)
+        code_other = other.to_code
+
+        Boolean.new(raw > code_other.raw)
       end
 
       def code_superior_or_equal(other)
-        Boolean.new(raw >= other.raw)
+        code_other = other.to_code
+
+        Boolean.new(raw >= code_other.raw)
       end
 
       def code_ten?
-        Boolean.new(raw == 10)
+        Boolean.new(raw.ten?)
       end
 
       def code_three?
-        Boolean.new(raw == 3)
+        Boolean.new(raw.three?)
       end
 
       def code_to_decimal
@@ -344,8 +380,10 @@ class Code
       end
 
       def code_times(argument, **globals)
+        code_argument = argument.to_code
+
         raw.times do |element|
-          argument.call(
+          code_argument.call(
             arguments: List.new([Integer.new(element), self]),
             **globals
           )
@@ -355,12 +393,14 @@ class Code
       end
 
       def code_truncate(n = nil)
-        n = Integer.new(0) if n.nil? || n.is_a?(Nothing)
-        Integer.new(raw.truncate(n.raw))
+        code_n = n.to_code
+        code_n = Integer.new(0) if code_n.nothing?
+
+        Integer.new(raw.truncate(code_n.raw))
       end
 
       def code_two?
-        Boolean.new(raw == 2)
+        Boolean.new(raw.two?)
       end
 
       def code_unary_minus

data/lib/code/object/json.rb

@@ -3,31 +3,27 @@
 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
-              .transform_keys { |key| Json.to_code(key) }
-              .transform_values { |value| Json.to_code(value) }
-          )
-        elsif json.is_a?(::Array)
-          List.new(json.map { |element| Json.to_code(element) })
-        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) || json.is_a?(::FalseClass)
-          Boolean.new(json)
-        elsif json.is_a?(::NilClass)
-          Nothing.new(json)
+      def self.call(**args)
+        code_operator = args.fetch(:operator, nil).to_code
+        code_arguments = args.fetch(:arguments, []).to_code
+        code_value = code_arguments.code_first
+
+        case code_operator.to_s
+        when "parse"
+          sig(args) { String }
+          code_parse(code_value)
         else
-          raise Error, "#{json.inspect} not supported"
+          super
         end
       end
+
+      def self.code_parse(value)
+        code_value = value.to_code
+
+        ::JSON.parse(code_value.raw).to_code
+      rescue JSON::ParserError
+        Nothing.new
+      end
     end
   end
 end