code-ruby 1.1.3 → 1.2.1

data/lib/code/object/duration.rb

@@ -4,18 +4,22 @@ class Code
   class Object
     class Duration < Object
       def initialize(*args, **_kargs, &)
-        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)
+        @raw =
+          if args.first.is_an?(::ActiveSupport::Duration)
+            args.first
+          elsif args.first.is_a?(Duration)
+            args.first.raw
+          else
+            ::ActiveSupport::Duration.parse(args.first.to_s)
+          end
       rescue ::ActiveSupport::Duration::ISO8601Parser::ParsingError
-        raise Error, "#{raw.inspect} is not a valid duration"
+        @raw = 0.seconds
       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 "ago"
           sig(args)
           code_ago

data/lib/code/object/function.rb

@@ -3,60 +3,73 @@
 class Code
   class Object
     class Function < Object
-      attr_reader :parameters, :body
+      attr_reader :code_parameters, :code_body
 
       def initialize(*args, **_kargs, &)
-        @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)
+        @code_parameters =
+          List
+            .new(args.first)
+            .raw
+            .map { |parameter| Parameter.new(parameter) }
+            .to_code
+
+        @code_body = Code.new(args.second.presence)
+
+        @raw = List.new([code_parameters, code_body])
       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, List.new).to_code
         globals = multi_fetch(args, *GLOBALS)
 
-        case operator.to_s
+        case code_operator.to_s
         when "", "call"
           sig(args) { signature_for_call }
-          code_call(*arguments.raw, **globals)
+          code_call(*code_arguments.raw, **globals)
         else
           super
         end
       end
 
       def code_call(*arguments, **globals)
-        context = Context.new({}, globals[:context])
+        code_arguments = arguments.to_code
+        code_context = Context.new({}, globals[:context])
 
-        parameters.raw.each.with_index do |parameter, index|
-          argument =
-            if parameter.keyword?
-              arguments
-                .detect do |dictionary|
-                  dictionary.code_has_value?(parameter.code_name)
+        code_parameters.raw.each.with_index do |code_parameter, index|
+          code_argument =
+            if code_parameter.keyword?
+              code_arguments
+                .raw
+                .select { |code_argument| code_argument.is_a?(Dictionary) }
+                .detect do |code_dictionary|
+                  code_dictionary.code_has_value?(parameter.code_name).truthy?
                 end
                 &.code_get(parameter.code_name)
             else
-              arguments[index]
+              code_arguments.raw[index].to_code
             end
-          argument = parameter.evaluate(**globals) if argument.nil?
-          context.code_set(parameter.code_name, argument)
+
+          if code_argument.nothing?
+            code_argument = code_parameter.code_evaluate(**globals)
+          end
+
+          code_context.code_set(code_parameter.code_name, code_argument)
         end
 
-        body.evaluate(**globals, context:)
+        code_body.code_evaluate(**globals, context: code_context)
       end
 
       def signature_for_call
-        parameters
+        code_parameters
           .raw
-          .inject([]) do |signature, parameter|
-            if parameter.keyword?
+          .inject([]) do |signature, code_parameter|
+            if code_parameter.keyword?
               if signature.last.is_a?(::Hash)
-                signature.last.code_set(parameter.code_name, Object)
+                signature.last[code_parameter.code_name] = Object
                 signature
               else
-                signature + [{ parameter.code_name => Object }]
+                signature + [{ code_parameter.code_name => Object }]
               end
             else
               signature + [Object]

data/lib/code/object/global.rb

@@ -3,117 +3,170 @@
 class Code
   class Object
     class Global < Object
-      def initialize(...)
-        @raw = "global"
-      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
         output = args.fetch(:output)
-        context = args.fetch(:context)
-        multi_fetch(args, *GLOBALS)
-        value = arguments.code_first
+        code_context = args.fetch(:context).to_code
+        code_value = code_arguments.code_first
 
-        case operator.to_s
+        case code_operator.to_s
         when "Boolean"
           sig(args) { Object.repeat }
-          arguments.any? ? Boolean.new(*arguments.raw) : Class.new(Boolean)
+          if code_arguments.any?
+            Boolean.new(*code_arguments.raw)
+          else
+            Class.new(Boolean)
+          end
         when "break"
           sig(args) { Object.repeat }
-          raise Error::Break, value || Nothing.new
+          raise Error::Break, code_value || Nothing.new
         when "next"
           sig(args) { Object.repeat }
-          raise Error::Next, value || Nothing.new
+          raise Error::Next, code_value || Nothing.new
         when "Class"
           sig(args) { Object.repeat }
-          arguments.any? ? Class.new(*arguments.raw) : Class.new(Class)
+          if code_arguments.any?
+            Class.new(*code_arguments.raw)
+          else
+            Class.new(Class)
+          end
         when "Date"
           sig(args) { Object.repeat }
-          arguments.any? ? Date.new(*arguments.raw) : Class.new(Date)
+          code_arguments.any? ? Date.new(*code_arguments.raw) : Class.new(Date)
         when "Decimal"
           sig(args) { Object.repeat }
-          arguments.any? ? Decimal.new(*arguments.raw) : Class.new(Decimal)
+          if code_arguments.any?
+            Decimal.new(*code_arguments.raw)
+          else
+            Class.new(Decimal)
+          end
         when "Dictionary"
           sig(args) { Object.repeat }
-          if arguments.any?
-            Dictionary.new(*arguments.raw)
+          if code_arguments.any?
+            Dictionary.new(*code_arguments.raw)
           else
             Class.new(Dictionary)
           end
         when "Duration"
           sig(args) { Object.repeat }
-          arguments.any? ? Duration.new(*arguments.raw) : Class.new(Duration)
+          if code_arguments.any?
+            Duration.new(*code_arguments.raw)
+          else
+            Class.new(Duration)
+          end
         when "Function"
           sig(args)
-          arguments.any? ? Function.new(*arguments.raw) : Class.new(Function)
+          if code_arguments.any?
+            Function.new(*code_arguments.raw)
+          else
+            Class.new(Function)
+          end
         when "Integer"
           sig(args) { Object.repeat }
-          arguments.any? ? Integer.new(*arguments.raw) : Class.new(Integer)
+          if code_arguments.any?
+            Integer.new(*code_arguments.raw)
+          else
+            Class.new(Integer)
+          end
         when "List"
           sig(args) { Object.repeat }
-          arguments.any? ? List.new(*arguments.raw) : Class.new(List)
+          code_arguments.any? ? List.new(*code_arguments.raw) : Class.new(List)
         when "Nothing"
           sig(args) { Object.repeat }
-          arguments.any? ? Nothing.new(*arguments.raw) : Class.new(Nothing)
+          if code_arguments.any?
+            Nothing.new(*code_arguments.raw)
+          else
+            Class.new(Nothing)
+          end
         when "context"
           sig(args)
           context
         when "Object"
           sig(args)
-          arguments.any? ? Object.new(*arguments.raw) : Class.new(Object)
+          if code_arguments.any?
+            Object.new(*code_arguments.raw)
+          else
+            Class.new(Object)
+          end
         when "Range"
           sig(args) { Object.repeat }
-          arguments.any? ? Range.new(*arguments.raw) : Class.new(Range)
+          if code_arguments.any?
+            Range.new(*code_arguments.raw)
+          else
+            Class.new(Range)
+          end
         when "String"
           sig(args) { Object.repeat }
-          arguments.any? ? String.new(*arguments.raw) : Class.new(String)
+          if code_arguments.any?
+            String.new(*code_arguments.raw)
+          else
+            Class.new(String)
+          end
         when "Time"
           sig(args) { Object.repeat }
-          arguments.any? ? Time.zone.local(*arguments.raw) : Class.new(Time)
+          if code_arguments.any?
+            Time.zone.local(*code_arguments.raw)
+          else
+            Class.new(Time)
+          end
         when "Context"
           sig(args) { Object.repeat }
-          arguments.any? ? Context.new(*arguments.raw) : Class.new(Context)
+          if code_arguments.any?
+            Context.new(*code_arguments.raw)
+          else
+            Class.new(Context)
+          end
         when "Code"
           sig(args) { Object.repeat }
-          arguments.any? ? Code.new(*arguments.raw) : Class.new(Code)
+          code_arguments.any? ? Code.new(*code_arguments.raw) : Class.new(Code)
         when "Parameter"
           sig(args) { Object.repeat }
-          arguments.any? ? Parameter.new(*arguments.raw) : Class.new(Parameter)
+          if code_arguments.any?
+            Parameter.new(*code_arguments.raw)
+          else
+            Class.new(Parameter)
+          end
         when "IdentifierList"
           sig(args) { Object.repeat }
-          if arguments.any?
-            IdentifierList.new(*arguments.raw)
+          if code_arguments.any?
+            IdentifierList.new(*code_arguments.raw)
           else
             Class.new(IdentifierList)
           end
         when "Html"
           sig(args) { Object.repeat }
-          arguments.any? ? Html.new(*arguments.raw) : Class.new(Html)
+          code_arguments.any? ? Html.new(*code_arguments.raw) : Class.new(Html)
+        when "Http"
+          sig(args) { Object.repeat }
+          code_arguments.any? ? Http.new(*code_arguments.raw) : Class.new(Http)
+        when "Json"
+          sig(args) { Object.repeat }
+          code_arguments.any? ? Json.new(*code_arguments.raw) : Class.new(Json)
         when "evaluate"
           sig(args) { Object }
-          Code.evaluate(value.to_s)
+          Code.evaluate(code_value.to_s)
         when "p"
           sig(args) { Object.repeat }
-          output.puts(*arguments.raw.map(&:inspect))
+          output.puts(*code_arguments.raw.map(&:inspect))
           Nothing.new
         when "print"
           sig(args) { Object.repeat }
-          output.print(*arguments.raw)
+          output.print(*code_arguments.raw)
           Nothing.new
         when "puts"
           sig(args) { Object.repeat }
-          output.puts(*arguments.raw)
+          output.puts(*code_arguments.raw)
           Nothing.new
         else
-          context = context.lookup!(operator)
-          result = context.code_fetch(operator)
+          code_context = code_context.code_lookup!(code_operator)
+          code_result = code_context.code_fetch(code_operator)
 
-          if result.is_a?(Function)
-            result.call(**args.merge(operator: nil))
+          if code_result.is_a?(Function)
+            code_result.call(**args, operator: nil)
           else
             sig(args)
-            result
+            code_result
           end
         end
       end

data/lib/code/object/html.rb

@@ -3,39 +3,37 @@
 class Code
   class Object
     class Html < Object
-      def initialize(*_args, **_kargs, &)
-        @raw = nil
-      end
-
       def self.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
 
-        case operator.to_s
+        case code_operator.to_s
         when "link_to"
           sig(args) { [Object.maybe, Object.maybe] }
-          code_link_to(*arguments.raw)
+          code_link_to(*code_arguments.raw)
         when "escape"
           sig(args) { Object.maybe }
-          code_escape(*arguments.raw)
+          code_escape(*code_arguments.raw)
         else
           super
         end
       end
 
       def self.code_link_to(text = nil, href = nil)
-        text ||= Nothing.new
-        href ||= Nothing.new
+        code_text = text.to_code
+        code_href = href.to_code
 
         String.new(<<~LINK.strip)
-          <a href="#{CGI.escapeHTML(href.raw.to_s)}">#{CGI.escapeHTML(text.raw.to_s)}</a>
+          <a
+            href="#{CGI.escapeHTML(code_href.to_s)}"
+          >#{CGI.escapeHTML(code_text.to_s)}</a>
         LINK
       end
 
       def self.code_escape(string = nil)
-        string ||= Nothing.new
+        code_string = string.to_code
 
-        String.new(CGI.escapeHTML(string.raw.to_s))
+        String.new(CGI.escapeHTML(string.to_s))
       end
     end
   end

data/lib/code/object/http.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+class Code
+  class Object
+    class Http < Object
+      SIG = [
+        String,
+        {
+          headers: Dictionary.maybe,
+          query: Dictionary.maybe,
+          body: String.maybe,
+          username: String.maybe,
+          password: String.maybe,
+          data: Dictionary.maybe,
+        }
+      ].freeze
+
+      STATUS_CODES = {
+        continue: 100,
+        switching_protocols: 101,
+        processing: 102,
+        early_hints: 103,
+        ok: 200,
+        created: 201,
+        accepted: 202,
+        non_authoritative_information: 203,
+        no_content: 204,
+        reset_content: 205,
+        partial_content: 206,
+        multi_status: 207,
+        already_reported: 208,
+        im_used: 226,
+        multiple_choices: 300,
+        moved_permanently: 301,
+        found: 302,
+        see_other: 303,
+        not_modified: 304,
+        use_proxy: 305,
+        reserved: 306,
+        temporary_redirect: 307,
+        permanent_redirect: 308,
+        bad_request: 400,
+        unauthorized: 401,
+        payment_required: 402,
+        forbidden: 403,
+        not_found: 404,
+        method_not_allowed: 405,
+        not_acceptable: 406,
+        proxy_authentication_required: 407,
+        request_timeout: 408,
+        conflict: 409,
+        gone: 410,
+        length_required: 411,
+        precondition_failed: 412,
+        request_entity_too_large: 413,
+        request_uri_too_long: 414,
+        unsupported_media_type: 415,
+        requested_range_not_satisfiable: 416,
+        expectation_failed: 417,
+        misdirected_request: 421,
+        unprocessable_entity: 422,
+        locked: 423,
+        failed_dependency: 424,
+        too_early: 425,
+        upgrade_required: 426,
+        precondition_required: 428,
+        too_many_requests: 429,
+        request_header_fields_too_large: 431,
+        unavailable_for_legal_reasons: 451,
+        internal_server_error: 500,
+        not_implemented: 501,
+        bad_gateway: 502,
+        service_unavailable: 503,
+        gateway_timeout: 504,
+        http_version_not_supported: 505,
+        variant_also_negotiates: 506,
+        insufficient_storage: 507,
+        loop_detected: 508,
+        bandwidth_limit_exceeded: 509,
+        not_extended: 510,
+        network_authentication_required: 511
+      }.freeze
+
+      def self.call(**args)
+        code_operator = args.fetch(:operator, nil).to_code
+        code_arguments = args.fetch(:arguments, []).to_code
+
+        case code_operator.to_s
+        when "get"
+          sig(args) { SIG }
+          code_get(*code_arguments.raw)
+        when "head"
+          sig(args) { SIG }
+          code_head(*code_arguments.raw)
+        when "post"
+          sig(args) { SIG }
+          code_post(*code_arguments.raw)
+        when "put"
+          sig(args) { SIG }
+          code_put(*code_arguments.raw)
+        when "delete"
+          sig(args) { SIG }
+          code_delete(*code_arguments.raw)
+        when "connect"
+          sig(args) { SIG }
+          code_connect(*code_arguments.raw)
+        when "options"
+          sig(args) { SIG }
+          code_options(*code_arguments.raw)
+        when "trace"
+          sig(args) { SIG }
+          code_trace(*code_arguments.raw)
+        when "patch"
+          sig(args) { SIG }
+          code_patch(*code_arguments.raw)
+        when "fetch"
+          sig(args) { [String] + SIG }
+          code_fetch(*code_arguments.raw)
+        else
+          super
+        end
+      end
+
+      def self.code_get(...)
+        code_fetch("get", ...)
+      end
+
+      def self.code_head(...)
+        code_fetch("head", ...)
+      end
+
+      def self.code_post(...)
+        code_fetch("post", ...)
+      end
+
+      def self.code_put(...)
+        code_fetch("put", ...)
+      end
+
+      def self.code_delete(...)
+        code_fetch("delete", ...)
+      end
+
+      def self.code_connect(...)
+        code_fetch("connect", ...)
+      end
+
+      def self.code_options(...)
+        code_fetch("options", ...)
+      end
+
+      def self.code_trace(...)
+        code_fetch("trace", ...)
+      end
+
+      def self.code_patch(...)
+        code_fetch("patch", ...)
+      end
+
+      def self.code_fetch(*arguments)
+        verb = arguments.first.to_code.to_s.downcase
+        url = arguments.second.to_code.to_s
+        options = arguments.third.to_code
+        options = Dictionary.new if options.nothing?
+        username = options.code_get("username").to_s
+        password = options.code_get("password").to_s
+        body = options.code_get("body").to_s
+        headers = options.code_get("headers").raw || {}
+        data = options.code_get("data").raw || {}
+        query = options.code_get("query").raw || {}
+        query = query.to_a.flatten.map(&:to_s).each_slice(2).to_h.to_query
+        url = "#{url}?#{query}" if query.present?
+        uri = ::URI.parse(url)
+        http = ::Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true if uri.scheme == "https"
+
+        if username.present? || password.present?
+          headers["Authorization"] =
+            "Basic #{::Base64.strict_encode64("#{username}:#{password}")}"
+        end
+
+        request_class =
+          case verb
+          when "get"
+            ::Net::HTTP::Get
+          when "head"
+            ::Net::HTTP::Head
+          when "post"
+            ::Net::HTTP::Post
+          when "put"
+            ::Net::HTTP::Put
+          when "delete"
+            ::Net::HTTP::Delete
+          when "connect"
+            ::Net::HTTP::Get
+          when "options"
+            ::Net::HTTP::Options
+          when "trace"
+            ::Net::HTTP::Trace
+          when "patch"
+            ::Net::HTTP::Patch
+          else
+            ::Net::HTTP::Get
+          end
+
+        request = request_class.new(uri)
+        headers.each { |key, value| request[key.to_s] = value.to_s }
+        request.body = body if body.present?
+        request.set_form_data(**data.as_json) if data.present?
+
+        response = http.request(request)
+        code = response.code.to_i
+        status = STATUS_CODES.key(code) || :ok
+
+        Dictionary.new(code: code, status: status, body: response.body)
+      end
+    end
+  end
+end

data/lib/code/object/identifier_list.rb

@@ -4,36 +4,36 @@ class Code
   class Object
     class IdentifierList < List
       def call(**args)
-        operator = args.fetch(:operator, nil)
-        arguments = args.fetch(:arguments, List.new)
-        context = args.fetch(:context)
-        value = arguments.code_first
+        code_operator = args.fetch(:operator, nil).to_code
+        code_arguments = args.fetch(:arguments, []).to_code
+        code_context = args.fetch(:context).to_code
+        code_value = code_arguments.code_first
 
-        case operator.to_s
+        case code_operator.to_s
         when /=$/
           sig(args) { Object }
 
-          context = context.lookup!(raw.first)
+          code_context = code_context.code_lookup!(raw.first)
 
-          context =
-            raw[..-2].reduce(context) do |context, identifier|
-              context.code_fetch(identifier)
+          code_context =
+            raw[..-2].reduce(code_context) do |code_context, code_identifier|
+              code_context.code_fetch(code_identifier)
             end
 
-          context.code_set(
+          code_context.code_set(
             raw.last,
-            if operator == "="
-              value
+            if code_operator.to_s == "="
+              code_value
             else
-              context.fetch(raw.last).call(
+              code_context.fetch(raw.last).call(
                 **args,
-                operator: operator.chop,
-                arguments: List.new([value])
+                operator: code_operator.to_s.chop,
+                arguments: [code_value]
               )
             end
           )
 
-          context.code_fetch(raw.last)
+          code_context.code_fetch(raw.last)
         else
           super
         end