code-ruby 0.5.6 → 0.6.1

data/lib/code/object/integer.rb

@@ -1,221 +1,404 @@
+# frozen_string_literal: true
+
 class Code
   class Object
-    class Integer < ::Code::Object::Number
+    class Integer < Number
       attr_reader :raw
 
       def initialize(whole, exponent: nil)
         @raw = whole.to_i
 
-        if exponent
-          if exponent.is_a?(::Code::Object::Number)
-            @raw = @raw * 10**exponent.raw
-          else
-            raise ::Code::Error::TypeError.new("exponent is not a number")
-          end
+        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
+        "Integer"
       end
 
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
-        globals = multi_fetch(args, *::Code::GLOBALS)
+        globals = multi_fetch(args, *GLOBALS)
         value = arguments.first&.value
 
-        if operator == "even?"
-          sig(arguments)
-          even?
-        elsif operator == "odd?"
-          sig(arguments)
-          odd?
-        elsif operator == "times"
-          sig(arguments) { ::Code::Object::Function }
-          times(value, **globals)
-        elsif operator == "*"
-          sig(arguments) { [[::Code::Object::Number, ::Code::Object::String]] }
-          multiplication(value)
-        elsif operator == "/"
-          sig(arguments) { ::Code::Object::Number }
-          division(value)
-        elsif operator == "+"
-          if value
-            sig(arguments) { ::Code::Object }
-            plus(value)
-          else
-            sig(arguments)
-            self
-          end
-        elsif operator == "%"
-          sig(arguments) { ::Code::Object::Number }
-          modulo(value)
-        elsif operator == "-"
-          if value
-            sig(arguments) { ::Code::Object::Number }
-            minus(value)
-          else
-            sig(arguments)
-            unary_minus
-          end
-        elsif operator == "**"
-          sig(arguments) { ::Code::Object::Number }
-          power(value)
-        elsif operator == "<"
-          sig(arguments) { ::Code::Object::Number }
-          inferior(value)
-        elsif operator == "<="
-          sig(arguments) { ::Code::Object::Number }
-          inferior_or_equal(value)
-        elsif operator == ">"
-          sig(arguments) { ::Code::Object::Number }
-          superior(value)
-        elsif operator == ">="
-          sig(arguments) { ::Code::Object::Number }
-          superior_or_equal(value)
-        elsif operator == "<<"
-          sig(arguments) { ::Code::Object::Number }
-          left_shift(value)
-        elsif operator == ">>"
-          sig(arguments) { ::Code::Object::Number }
-          right_shift(value)
-        elsif operator == "&"
-          sig(arguments) { ::Code::Object::Number }
-          bitwise_and(value)
-        elsif operator == "|"
-          sig(arguments) { ::Code::Object::Number }
-          bitwise_or(value)
-        elsif operator == "^"
-          sig(arguments) { ::Code::Object::Number }
-          bitwise_xor(value)
+        case operator.to_s
+        when "%", "modulo"
+          sig(args) { Number }
+          code_modulo(value)
+        when "&", "bitwise_and"
+          sig(args) { Number }
+          code_bitwise_and(value)
+        when "*", "multiplication"
+          sig(args) { Number | String }
+          code_multiplication(value)
+        when "**", "power"
+          sig(args) { Number }
+          code_power(value)
+        when "+", "plus"
+          sig(args) { Object.maybe }
+          value ? code_plus(value) : self
+        when "+", "plus", "self"
+          sig(args) { Object.maybe }
+          value ? code_plus(value) : code_self
+        when "-", "minus"
+          sig(args) { Number.maybe }
+          value ? code_minus(value) : code_unary_minus
+        when "-", "minus", "unary_minus"
+          sig(args) { Number.maybe }
+          value ? code_minus(value) : code_unary_minus
+        when "/", "division"
+          sig(args) { Number }
+          code_division(value)
+        when "<", "inferior"
+          sig(args) { Number }
+          code_inferior(value)
+        when "<<", "left_shift"
+          sig(args) { Number }
+          code_left_shift(value)
+        when "<=", "inferior_or_equal"
+          sig(args) { Number }
+          code_inferior_or_equal(value)
+        when "<=>", "compare"
+          sig(args) { Number }
+          code_compare(value)
+        when ">", "superior"
+          sig(args) { Number }
+          code_superior(value)
+        when ">=", "superior_or_equal"
+          sig(args) { Number }
+          code_superior_or_equal(value)
+        when ">>", "right_shift"
+          sig(args) { Number }
+          code_right_shift(value)
+        when "^", "bitwise_xor"
+          sig(args) { Number }
+          code_bitwise_xor(value)
+        when "abs"
+          sig(args)
+          code_abs
+        when "ceil"
+          sig(args) { Integer.maybe }
+          code_ceil(value)
+        when "clone"
+          sig(args)
+          code_clone
+        when "decrement!"
+          sig(args) { Integer.maybe }
+          code_decrement!(value)
+        when "decrement"
+          sig(args) { Integer.maybe }
+          code_decrement(value)
+        when "eight?"
+          sig(args)
+          code_eight?
+        when "even?"
+          sig(args)
+          code_even?
+        when "five?"
+          sig(args)
+          code_five?
+        when "floor"
+          sig(args) { Integer.maybe }
+          code_floor(value)
+        when "four?"
+          sig(args)
+          code_four?
+        when "increment!"
+          sig(args) { Integer.maybe }
+          code_increment!(value)
+        when "increment"
+          sig(args) { Integer.maybe }
+          code_increment(value)
+        when "nine?"
+          sig(args)
+          code_nine?
+        when "odd?"
+          sig(args)
+          code_odd?
+        when "one?"
+          sig(args)
+          code_one?
+        when "round"
+          sig(args) { Integer.maybe }
+          code_round(value)
+        when "seven?"
+          sig(args)
+          code_seven?
+        when "six?"
+          sig(args)
+          code_six?
+        when "sqrt"
+          sig(args)
+          code_sqrt
+        when "ten?"
+          sig(args)
+          code_ten?
+        when "three?"
+          sig(args)
+          code_three?
+        when "times"
+          sig(args) { Function }
+          code_times(value, **globals)
+        when "to_decimal"
+          sig(args)
+          code_to_decimal
+        when "to_integer"
+          sig(args)
+          code_to_integer
+        when "to_string"
+          sig(args)
+          code_to_string
+        when "truncate"
+          sig(args) { Integer.maybe }
+          code_truncate(value)
+        when "two?"
+          sig(args)
+          code_two?
+        when "zero?"
+          sig(args)
+          code_zero?
+        when "|", "bitwise_or"
+          sig(args) { Number }
+          code_bitwise_or(value)
         else
           super
         end
       end
 
-      def succ
-        ::Code::Object::Integer.new(raw + 1)
+      def code_abs
+        Decimal.new(raw.abs)
       end
 
-      def +(other)
-        ::Code::Object::Integer.new(raw + other.raw)
+      def code_bitwise_and(other)
+        Integer.new(raw & other.raw.to_i)
       end
 
-      def to_s
-        raw.to_s
+      def code_bitwise_or(other)
+        Integer.new(raw | other.raw.to_i)
       end
 
-      def inspect
-        to_s
+      def code_bitwise_xor(other)
+        Integer.new(raw ^ other.raw.to_i)
+      end
+
+      def code_ceil(n = nil)
+        n ||= Integer.new(0)
+        Integer.new(raw.ceil(n.raw))
+      end
+
+      def code_clone
+        Integer.new(raw)
+      end
+
+      def code_compare(other)
+        Integer.new(raw <=> other.raw)
+      end
+
+      def code_decrement!(n = nil)
+        n ||= Integer.new(1)
+        @raw -= n.raw
+        self
+      end
+
+      def code_decrement(n = nil)
+        n ||= Integer.new(1)
+        Integer.new(raw - n.raw)
+      end
+
+      def code_division(other)
+        Decimal.new(BigDecimal(raw) / other.raw)
+      end
+
+      def code_eight?
+        Boolean.new(raw == 8)
+      end
+
+      def code_even?
+        Boolean.new(raw.even?)
+      end
+
+      def code_five?
+        Boolean.new(raw == 5)
+      end
+
+      def code_floor(n = nil)
+        n ||= Integer.new(0)
+        Integer.new(raw.floor(n.raw))
+      end
+
+      def code_four?
+        Boolean.new(raw == 4)
+      end
+
+      def code_increment!(n = nil)
+        n ||= Integer.new(1)
+        @raw += n.raw
+        self
       end
 
-      private
+      def code_increment(n = nil)
+        n ||= Integer.new(1)
+        Integer.new(raw + n.raw)
+      end
+
+      def code_inferior(other)
+        Boolean.new(raw < other.raw)
+      end
 
-      def even?
-        ::Code::Object::Boolean.new(raw.even?)
+      def code_inferior_or_equal(other)
+        Boolean.new(raw <= other.raw)
       end
 
-      def odd?
-        ::Code::Object::Boolean.new(raw.odd?)
+      def code_left_shift(other)
+        Integer.new(raw << other.raw.to_i)
+      end
+
+      def code_minus(other)
+        if other.is_a?(Integer)
+          Integer.new(raw - other.raw)
+        else
+          Decimal.new(raw - other.raw)
+        end
       end
 
-      def multiplication(other)
-        if other.is_a?(::Code::Object::Integer)
-          ::Code::Object::Integer.new(raw * other.raw)
-        elsif other.is_a?(::Code::Object::Decimal)
-          ::Code::Object::Decimal.new(raw * other.raw)
+      def code_modulo(other)
+        if other.is_a?(Integer)
+          Integer.new(raw % other.raw)
         else
-          ::Code::Object::String.new(other.raw * raw)
+          Decimal.new(raw % other.raw)
         end
       end
 
-      def plus(other)
-        if other.is_a?(::Code::Object::Integer)
-          ::Code::Object::Integer.new(raw + other.raw)
-        elsif other.is_a?(::Code::Object::Decimal)
-          ::Code::Object::Decimal.new(raw + other.raw)
+      def code_multiplication(other)
+        if other.is_a?(Integer)
+          Integer.new(raw * other.raw)
+        elsif other.is_a?(Decimal)
+          Decimal.new(raw * other.raw)
         else
-          ::Code::Object::String.new(to_s + other.to_s)
+          String.new(other.raw * raw)
         end
       end
 
-      def division(other)
-        ::Code::Object::Decimal.new(BigDecimal(raw) / other.raw)
+      def code_nine?
+        Boolean.new(raw == 9)
       end
 
-      def modulo(other)
-        if other.is_a?(::Code::Object::Integer)
-          ::Code::Object::Integer.new(raw % other.raw)
+      def code_odd?
+        Boolean.new(raw.odd?)
+      end
+
+      def code_one?
+        Boolean.new(raw == 1)
+      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)
         else
-          ::Code::Object::Decimal.new(raw % other.raw)
+          String.new(to_s + other.to_s)
         end
       end
 
-      def minus(other)
-        if other.is_a?(::Code::Object::Integer)
-          ::Code::Object::Integer.new(raw - other.raw)
+      def code_power(other)
+        if other.is_a?(Integer)
+          Integer.new(raw**other.raw)
         else
-          ::Code::Object::Decimal.new(raw - other.raw)
+          Decimal.new(raw**other.raw)
         end
       end
 
-      def unary_minus
-        ::Code::Object::Integer.new(-raw)
+      def code_right_shift(other)
+        Integer.new(raw >> other.raw.to_i)
       end
 
-      def power(other)
-        if other.is_a?(::Code::Object::Integer)
-          ::Code::Object::Integer.new(raw**other.raw)
-        else
-          ::Code::Object::Decimal.new(raw**other.raw)
-        end
+      def code_round(n = nil)
+        n ||= Integer.new(0)
+        Integer.new(raw.round(n.raw))
       end
 
-      def inferior(other)
-        ::Code::Object::Boolean.new(raw < other.raw)
+      def code_seven?
+        Boolean.new(raw == 7)
       end
 
-      def inferior_or_equal(other)
-        ::Code::Object::Boolean.new(raw <= other.raw)
+      def code_six?
+        Boolean.new(raw == 6)
       end
 
-      def superior(other)
-        ::Code::Object::Boolean.new(raw > other.raw)
+      def code_sqrt
+        Decimal.new(Math.sqrt(raw).to_s)
       end
 
-      def superior_or_equal(other)
-        ::Code::Object::Boolean.new(raw >= other.raw)
+      def code_superior(other)
+        Boolean.new(raw > other.raw)
       end
 
-      def left_shift(other)
-        ::Code::Object::Integer.new(raw << other.raw.to_i)
+      def code_superior_or_equal(other)
+        Boolean.new(raw >= other.raw)
       end
 
-      def right_shift(other)
-        ::Code::Object::Integer.new(raw >> other.raw.to_i)
+      def code_ten?
+        Boolean.new(raw == 10)
       end
 
-      def bitwise_and(other)
-        ::Code::Object::Integer.new(raw & other.raw.to_i)
+      def code_three?
+        Boolean.new(raw == 3)
       end
 
-      def bitwise_or(other)
-        ::Code::Object::Integer.new(raw | other.raw.to_i)
+      def code_to_decimal
+        Decimal.new(raw)
       end
 
-      def bitwise_xor(other)
-        ::Code::Object::Integer.new(raw ^ other.raw.to_i)
+      def code_to_integer
+        Integer.new(raw)
       end
 
-      def times(argument, **globals)
+      def code_times(argument, **globals)
         raw.times do |element|
           argument.call(
-            arguments: [
-              ::Code::Object::Argument.new(::Code::Object::Integer.new(element))
-            ],
+            arguments: [Argument.new(Integer.new(element))],
             **globals
           )
         end
 
         self
       end
+
+      def code_truncate(n = nil)
+        n ||= Integer.new(0)
+        Integer.new(raw.truncate(n.raw))
+      end
+
+      def code_two?
+        Boolean.new(raw == 2)
+      end
+
+      def code_unary_minus
+        Integer.new(-raw)
+      end
+
+      def code_zero?
+        Boolean.new(raw.zero?)
+      end
+
+      def inspect
+        to_s
+      end
+
+      def succ
+        Integer.new(raw + 1)
+      end
+
+      def to_s
+        raw.to_s
+      end
     end
   end
 end