code-ruby 1.1.1 → 1.2.1

data/lib/code/object/code.rb

@@ -4,11 +4,15 @@ class Code
   class Object
     class Code < Object
       def initialize(*args, **_kargs, &)
-        raw = args.first.presence || Nothing.new
-        @raw = raw.is_a?(Node) ? raw : Node::Code.new(::Code.parse(raw.to_s))
+        @raw =
+          if args.first.is_a?(Node)
+            args.first
+          else
+            Node::Code.new(::Code.parse(args.first.to_s))
+          end
       end
 
-      def evaluate(...)
+      def code_evaluate(...)
         raw.evaluate(...)
       end
     end

data/lib/code/object/context.rb

@@ -6,19 +6,19 @@ class Code
       attr_reader :parent
 
       def initialize(*args, **_kargs, &)
-        raw = args.first || Dictionary.new
-        raw = raw.raw if raw.is_a?(Object)
-        @raw = raw.to_h
-        @parent = Context.new(args.second) if args.second
+        super(args.first)
+        @parent = args.second if args.second.is_a?(Dictionary)
       end
 
-      def lookup!(identifier)
-        if code_has_key?(identifier).truthy?
+      def code_lookup!(identifier)
+        code_identifier = identifier.to_code
+
+        if code_has_key?(code_identifier).truthy?
           self
         elsif parent?
-          parent.lookup!(identifier)
+          parent.code_lookup!(code_identifier)
         else
-          raise Error::Undefined, "#{identifier} is not defined"
+          raise Error, "#{code_identifier} is not defined"
         end
       end
 

data/lib/code/object/date.rb

@@ -4,16 +4,15 @@ class Code
   class Object
     class Date < Object
       def initialize(*args, **_kargs, &)
-        raw = args.map(&:to_s).join("-").presence || ::Date.current.to_s
-        @raw = ::Date.parse(raw)
+        @raw = ::Date.parse(args.map(&:to_s).join("-"))
       rescue ::Date::Error
-        raise Error, "#{raw.inspect} is an invalid date"
+        @raw = ::Date.current
       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 "tomorrow"
           sig(args)
           code_tomorrow
@@ -59,12 +58,27 @@ class Code
       end
 
       def 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 "hour"
           sig(args)
           code_hour
+        when "hours"
+          sig(args)
+          code_hours
+        when "minute"
+          sig(args)
+          code_minute
+        when "minutes"
+          sig(args)
+          code_minutes
+        when "second"
+          sig(args)
+          code_second
+        when "seconds"
+          sig(args)
+          code_seconds
         else
           super
         end
@@ -73,6 +87,26 @@ class Code
       def code_hour
         Integer.new(0)
       end
+
+      def code_hours
+        Integer.new(0)
+      end
+
+      def code_minute
+        Integer.new(0)
+      end
+
+      def code_minutes
+        Integer.new(0)
+      end
+
+      def code_second
+        Integer.new(0)
+      end
+
+      def code_seconds
+        Integer.new(0)
+      end
     end
   end
 end

data/lib/code/object/decimal.rb

@@ -4,72 +4,77 @@ class Code
   class Object
     class Decimal < Object
       def initialize(*args, **_kargs, &)
-        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)
+        @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)
+            else
+              args.first.to_s.to_d
+            end
+          else
+            0.to_d
+          end
       rescue FloatDomainError
-        raise Error, "#{decimal.inspect} * 10**#{exponent.inspect} is invalid"
+        @raw = 0.to_d
       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 "%", "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 }
-          code_multiplication(value)
+          code_multiplication(code_value)
         when "**", "power"
           sig(args) { Integer | Decimal }
-          code_power(value)
+          code_power(code_value)
         when "+", "plus"
           sig(args) { Object.maybe }
-          arguments.any? ? code_plus(value) : self
+          code_arguments.any? ? code_plus(code_value) : self
         when "-", "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
@@ -81,7 +86,7 @@ class Code
           code_five?
         when "floor"
           sig(args) { Integer.maybe }
-          code_floor(value)
+          code_floor(code_value)
         when "four?"
           sig(args)
           code_four?
@@ -93,7 +98,7 @@ class Code
           code_one?
         when "round"
           sig(args) { Integer.maybe }
-          code_round(value)
+          code_round(code_value)
         when "seven?"
           sig(args)
           code_seven?
@@ -120,7 +125,7 @@ class Code
           code_to_string
         when "truncate"
           sig(args) { Integer.maybe }
-          code_truncate(value)
+          code_truncate(code_value)
         when "two?"
           sig(args)
           code_two?
@@ -129,7 +134,7 @@ class Code
           code_zero?
         when "|", "bitwise_or"
           sig(args) { Integer | Decimal }
-          code_bitwise_or(value)
+          code_bitwise_or(code_value)
         else
           super
         end
@@ -140,20 +145,28 @@ class Code
       end
 
       def code_bitwise_and(other)
-        Integer.new(raw.to_i & other.raw.to_i)
+        code_other = other.to_code
+
+        Integer.new(raw.to_i & code_other.raw.to_i)
       end
 
       def code_bitwise_or(other)
-        Integer.new(raw.to_i | other.raw.to_i)
+        code_other = other.to_code
+
+        Integer.new(raw.to_i | code_other.raw.to_i)
       end
 
       def code_bitwise_xor(other)
-        Integer.new(raw.to_i ^ other.raw.to_i)
+        code_other = other.to_code
+
+        Integer.new(raw.to_i ^ code_other.raw.to_i)
       end
 
       def code_ceil(n = nil)
-        n = Integer.new(0) if n.nil? || n.is_a?(Nothing)
-        Decimal.new(raw.ceil(n.raw))
+        code_n = n.to_code
+        code_n = Integer.new(0) if code_n.nothing?
+
+        Decimal.new(raw.ceil(code_n.raw))
       end
 
       def code_clone
@@ -161,11 +174,15 @@ 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_division(other)
-        Decimal.new(raw / other.raw)
+        code_other = other.to_code
+
+        Decimal.new(raw / code_other.raw)
       end
 
       def code_eight?
@@ -177,8 +194,10 @@ class Code
       end
 
       def code_floor(n = nil)
-        n = Integer.new(0) if n.nil? || n.is_a?(Nothing)
-        Decimal.new(raw.floor(n.raw))
+        code_n = n.to_code
+        code_n = Integer.new(0) if code_n.nothing?
+
+        Decimal.new(raw.floor(code_n.raw))
       end
 
       def code_four?
@@ -186,27 +205,39 @@ class Code
       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.to_i << other.raw.to_i)
+        code_other = other.to_code
+
+        Integer.new(raw.to_i << code_other.raw.to_i)
       end
 
       def code_minus(other)
-        Decimal.new(raw - other.raw)
+        code_other = other.to_code
+
+        Decimal.new(raw - code_other.raw)
       end
 
       def code_modulo(other)
-        Decimal.new(raw % other.raw)
+        code_other = other.to_code
+
+        Decimal.new(raw % code_other.raw)
       end
 
       def code_multiplication(other)
-        Decimal.new(raw * other.raw)
+        code_other = other.to_code
+
+        Decimal.new(raw * code_other.raw)
       end
 
       def code_nine?
@@ -218,24 +249,32 @@ class Code
       end
 
       def code_plus(other)
-        if other.is_an?(Integer) || other.is_a?(Decimal)
-          Decimal.new(raw + other.raw)
+        code_other = other.to_code
+
+        if code_other.is_an?(Integer) || 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)
-        Decimal.new(raw**other.raw)
+        code_other = other.to_code
+
+        Decimal.new(raw**code_other.raw)
       end
 
       def code_right_shift(other)
-        Integer.new(raw.to_i >> other.raw.to_i)
+        code_other = other.to_code
+
+        Integer.new(raw.to_i >> code_other.raw.to_i)
       end
 
       def code_round(n = nil)
-        n = Integer.new(0) if n.nil? || n.is_a?(Nothing)
-        Decimal.new(raw.round(n.raw))
+        code_n = n.to_code
+        code_n = Integer.new(0) if code_n.nothing?
+
+        Decimal.new(raw.round(code_n.raw))
       end
 
       def code_seven?
@@ -251,11 +290,15 @@ 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?
@@ -279,8 +322,10 @@ class Code
       end
 
       def code_truncate(n = nil)
-        n = Integer.new(0) if n.nil? || n.is_a?(Nothing)
-        Decimal.new(raw.truncate(n.raw))
+        code_n = n.to_code
+        code_n = Integer.new(0) if code_n.nothing?
+
+        Decimal.new(raw.truncate(code_n.raw))
       end
 
       def code_two?