code-ruby 1.2.7 → 1.4.0

data/lib/code/concerns/shared.rb

@@ -0,0 +1,423 @@
+# frozen_string_literal: true
+
+class Code
+  module Concerns
+    module Shared
+      attr_reader :raw
+
+      def 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 "new"
+          sig(args) { Object.repeat }
+          code_new(*code_arguments.raw)
+        when "!", "not"
+          sig(args)
+          code_exclamation_point
+        when "!=", "different"
+          sig(args) { Object }
+          code_different(code_value)
+        when "&&", "and"
+          sig(args) { Object }
+          code_and(code_value)
+        when "+", "self"
+          sig(args)
+          code_self
+        when "..", "inclusive_range"
+          sig(args) { Object }
+          code_inclusive_range(code_value)
+        when "...", "exclusive_range"
+          sig(args) { Object }
+          code_exclusive_range(code_value)
+        when "==", "equal"
+          sig(args) { Object }
+          code_equal_equal(code_value)
+        when "===", "strict_equal"
+          sig(args) { Object }
+          code_equal_equal_equal(code_value)
+        when "falsy?"
+          sig(args)
+          code_falsy?
+        when "truthy?"
+          sig(args)
+          code_truthy?
+        when "||", "or"
+          sig(args) { Object }
+          code_or(code_value)
+        when "to_boolean"
+          sig(args)
+          code_to_boolean
+        when "to_class"
+          sig(args)
+          code_to_class
+        when "to_date"
+          sig(args)
+          code_to_date
+        when "to_decimal"
+          sig(args)
+          code_to_decimal
+        when "to_dictionary"
+          sig(args)
+          code_to_dictionary
+        when "to_duration"
+          sig(args)
+          code_to_duration
+        when "to_integer"
+          sig(args)
+          code_to_integer
+        when "to_list"
+          sig(args)
+          code_to_list
+        when "to_nothing"
+          sig(args)
+          code_to_nothing
+        when "to_range"
+          sig(args)
+          code_to_range
+        when "to_string"
+          sig(args)
+          code_to_string
+        when "to_time"
+          sig(args)
+          code_to_time
+        when "as_json"
+          sig(args)
+          code_as_json
+        when "duplicate"
+          sig(args)
+          code_duplicate
+        when "deep_duplicate"
+          sig(args)
+          code_deep_duplicate
+        when "to_parameter"
+          sig(args)
+          code_to_parameter
+        when "to_json"
+          sig(args) { { pretty: Object::Boolean.maybe } }
+
+          if code_arguments.any?
+            code_to_json(pretty: code_value.code_get(:pretty))
+          else
+            code_to_json
+          end
+        when "name"
+          sig(args)
+          code_name
+        when /=$/
+          sig(args) { Object }
+
+          if code_operator.to_s == "="
+            code_context = args.fetch(:context)
+            code_context.code_set(self, code_value)
+          else
+            code_context = args.fetch(:context).code_lookup!(self)
+            code_context.code_set(
+              self,
+              code_context.code_fetch(self).call(
+                **args,
+                operator: code_operator.to_s.chop,
+                arguments: Object::List.new([code_value])
+              )
+            )
+          end
+
+          code_context.code_fetch(self)
+        else
+          raise(
+            Error,
+            "#{code_operator.inspect} not defined on #{code_inspect}:#{code_name}"
+          )
+        end
+      end
+
+      def <=>(other)
+        code_other = other.to_code
+
+        [raw, self.class] <=> [code_other.raw, code_other.class]
+      end
+
+      def ==(other)
+        code_other = other.to_code
+
+        [raw, self.class] == [code_other.raw, code_other.class]
+      end
+
+      def eql?(other)
+        code_other = other.to_code
+
+        [raw, self.class].eql?([code_other.raw, code_other.class])
+      end
+
+      def code_and(other)
+        code_other = other.to_code
+
+        truthy? ? code_other : self
+      end
+
+      def code_different(other)
+        code_other = other.to_code
+
+        Object::Boolean.new(self != code_other)
+      end
+
+      def code_equal_equal(other)
+        code_other = other.to_code
+
+        Object::Boolean.new(self == code_other)
+      end
+
+      def code_exclamation_point
+        Object::Boolean.new(falsy?)
+      end
+
+      def code_exclusive_range(value)
+        code_value = value.to_code
+
+        Object::Range.new(self, code_value, exclude_end: true)
+      end
+
+      def code_inclusive_range(value)
+        code_value = value.to_code
+
+        Object::Range.new(self, code_value, exclude_end: false)
+      end
+
+      def code_or(other)
+        code_other = other.to_code
+
+        truthy? ? self : code_other
+      end
+
+      def code_self
+        self
+      end
+
+      def code_equal_equal_equal(other)
+        code_other = other.to_code
+
+        Object::Boolean.new(self === code_other)
+      end
+
+      def falsy?
+        !truthy?
+      end
+
+      def hash
+        [self.class, raw].hash
+      end
+
+      def multi_fetch(hash, *keys)
+        keys.to_h { |key| [key, hash.fetch(key)] }
+      end
+
+      def sig(args, &)
+        Type::Sig.sig(args, object: self, &)
+
+        Object::Nothing.new
+      end
+
+      def truthy?
+        true
+      end
+
+      def to_json(...)
+        as_json(...).to_json(...)
+      end
+
+      def as_json(...)
+        raw.as_json(...)
+      end
+
+      def code_to_json(pretty: nil)
+        if Object::Boolean.new(pretty).truthy?
+          Object::String.new(::JSON.pretty_generate(self))
+        else
+          Object::String.new(to_json)
+        end
+      end
+
+      def code_as_json
+        as_json.to_code
+      end
+
+      def to_code
+        self
+      end
+
+      def succ
+        self.class.new(raw.succ)
+      end
+
+      def code_duplicate
+        self.class.new(self)
+      end
+
+      def code_deep_duplicate
+        self.class.new(self)
+      end
+
+      def self.code_fetch(...)
+        Object::Nothing.new
+      end
+
+      def self.code_set(...)
+        Object::Nothing.new
+      end
+
+      def self.code_get(...)
+        Object::Nothing.new
+      end
+
+      def code_fetch(...)
+        Object::Nothing.new
+      end
+
+      def code_set(...)
+        Object::Nothing.new
+      end
+
+      def code_get(...)
+        Object::Nothing.new
+      end
+
+      def code_to_parameter
+        code_to_string.code_parameterize
+      end
+
+      def code_falsy?
+        Object::Boolean.new(falsy?)
+      end
+
+      def code_truthy?
+        Object::Boolean.new(truthy?)
+      end
+
+      def code_to_boolean
+        Object::Boolean.new(self)
+      end
+
+      def code_to_class
+        Object::Class.new(self)
+      end
+
+      def code_to_date
+        Object::Date.new(self)
+      end
+
+      def code_to_decimal
+        Object::Decimal.new(self)
+      end
+
+      def code_to_dictionary
+        Object::Dictionary.new(self)
+      end
+
+      def code_to_duration
+        Object::Duration.new(self)
+      end
+
+      def code_to_integer
+        Object::Integer.new(self)
+      end
+
+      def code_to_list
+        Object::List.new(self)
+      end
+
+      def code_to_nothing
+        Object::Nothing.new(self)
+      end
+
+      def code_to_range
+        Object::Range.new(self)
+      end
+
+      def code_to_string
+        Object::String.new(self)
+      end
+
+      def code_to_time
+        Object::Time.new(self)
+      end
+
+      def to_s
+        code_to_string.raw
+      end
+
+      def inspect
+        code_inspect.raw
+      end
+
+      def nothing?
+        false
+      end
+
+      def code_falsy?
+        Object::Boolean.new(falsy?)
+      end
+
+      def code_truthy?
+        Object::Boolean.new(truthy?)
+      end
+
+      def code_to_boolean
+        Object::Boolean.new(self)
+      end
+
+      def code_to_class
+        Object::Class.new(self)
+      end
+
+      def code_to_date
+        Object::Date.new(self)
+      end
+
+      def code_to_decimal
+        Object::Decimal.new(self)
+      end
+
+      def code_to_dictionary
+        Object::Dictionary.new(self)
+      end
+
+      def code_to_duration
+        Object::Duration.new(self)
+      end
+
+      def code_to_integer
+        Object::Integer.new(self)
+      end
+
+      def code_to_list
+        Object::List.new(self)
+      end
+
+      def code_to_nothing
+        Object::Nothing.new(self)
+      end
+
+      def code_to_range
+        Object::Range.new(self)
+      end
+
+      def code_to_string
+        Object::String.new(self)
+      end
+
+      def code_to_time
+        Object::Time.new(self)
+      end
+
+      def code_inspect
+        code_to_string
+      end
+
+      def code_name
+        Object::String.new(name.to_s.split("::")[2..].join("::"))
+      end
+    end
+  end
+end

data/lib/code/concerns.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Code
+  module Concerns
+  end
+end

data/lib/code/object/code.rb

@@ -12,6 +12,12 @@ class Code
           end
       end
 
+      def self.code_evaluate(*args, **globals)
+        code_args = args.to_code
+
+        new(*code_args.raw).code_evaluate(**globals)
+      end
+
       def code_evaluate(...)
         raw.evaluate(...)
       end

data/lib/code/object/dictionary.rb

@@ -659,6 +659,12 @@ class Code
       def code_values
         List.new(raw.values)
       end
+
+      def code_deep_duplicate
+        Dictionary.new(
+          raw.dup.to_h { |key, value| [key, value].map(&:code_deep_duplicate) }
+        )
+      end
     end
   end
 end

data/lib/code/object/global.rb

@@ -7,8 +7,10 @@ class Code
         code_operator = args.fetch(:operator, nil).to_code
         code_arguments = args.fetch(:arguments, []).to_code
         output = args.fetch(:output)
+        input = args.fetch(:input)
         code_context = args.fetch(:context).to_code
         code_value = code_arguments.code_first
+        globals = multi_fetch(args, *GLOBALS)
 
         case code_operator.to_s
         when "Boolean"
@@ -145,7 +147,7 @@ class Code
           code_arguments.any? ? Json.new(*code_arguments.raw) : Class.new(Json)
         when "evaluate"
           sig(args) { Object }
-          Code.evaluate(code_value.to_s)
+          Code.code_evaluate(code_value.code_to_string, **globals)
         when "p"
           sig(args) { Object.repeat }
           output.puts(*code_arguments.raw.map(&:inspect))
@@ -154,6 +156,9 @@ class Code
           sig(args) { Object.repeat }
           output.print(*code_arguments.raw)
           Nothing.new
+        when "read"
+          sig(args) { Object.repeat }
+          input.gets.to_code
         when "puts"
           sig(args) { Object.repeat }
           output.puts(*code_arguments.raw)

data/lib/code/object/list.rb

@@ -436,12 +436,29 @@ class Code
         raw.inject(&:code_plus) || Nothing.new
       end
 
+      def code_deep_duplicate
+        List.new(raw.dup.map(&:code_deep_duplicate))
+      end
+
       def code_get(argument)
         code_argument = argument.to_code
 
         raw[code_argument] || Nothing.new
       end
 
+      def code_set(key, value)
+        code_key = key.to_code.code_to_integer
+        code_value = value.to_code
+        raw[code_key.raw] = code_value
+        code_value
+      end
+
+      def code_fetch(key)
+        code_key = key.to_code.code_to_integer
+
+        raw.fetch(code_key.raw, Nothing.new)
+      end
+
       def any?
         code_any?.truthy?
       end

data/lib/code/object/nothing.rb

@@ -14,6 +14,14 @@ class Code
       def nothing?
         true
       end
+
+      def code_to_string
+        String.new
+      end
+
+      def code_inspect
+        String.new("nothing")
+      end
     end
   end
 end

data/lib/code/object/string.rb

@@ -4,9 +4,18 @@ class Code
   class Object
     class String < Object
       def initialize(*args, **_kargs, &)
-        raw = args.first || Nothing.new
-        raw = raw.raw if raw.is_a?(Object)
-        @raw = raw.to_s
+        @raw =
+          if args.first.is_an?(Class)
+            args.first.raw.name
+          elsif args.first.is_an?(Object)
+            args.first.raw.to_s
+          elsif args.first.is_a?(::Class)
+            args.first.name
+          elsif args.first
+            args.first.to_s
+          else
+            ""
+          end
       end
 
       def call(**args)
@@ -37,6 +46,9 @@ class Code
         when "reverse"
           sig(args)
           code_reverse
+        when "parameterize"
+          sig(args)
+          code_parameterize
         else
           super
         end
@@ -69,6 +81,14 @@ class Code
         Function.new([{ name: "_" }], "_.#{raw}")
       end
 
+      def code_inspect
+        String.new(raw.inspect)
+      end
+
+      def code_parameterize
+        String.new(raw.parameterize)
+      end
+
       def code_first(n = nil)
         code_n = n.to_code
         code_n = Integer.new(1) if code_n.nothing?