code-ruby 5.0.12 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 210faa246f2abe16f58a157a6713259359b3977d0ad84c5442b3bb0e8c97ec08
-  data.tar.gz: 7866c67b465097ee9a7af1280672b7ef7a7a84cfddcb75d4a27efc37be5a6200
+  metadata.gz: eec903cbdd5d6368b89062c2b714515f30296bc14da6c56955cfb56883d1c8ec
+  data.tar.gz: efff6f91bce16b5bd93295f694be06337a7edbbfd3c882108ffc0f4b1381be17
 SHA512:
-  metadata.gz: 9b8ef0e86c48ee64640c4e5240f66ee31f04b84a21eb1fd06f77b33d48c91124310d7a09c4f8dc1923f35ea815852e68fd2451b4b7402700c79c3168e8a3c43c
-  data.tar.gz: f9a9fc037f7bf34dbd7cc236f05b3f96b46b0e35cf9e76d302c6024a7f31e417b88ee5efa2412e422ae6eeee4f0e97af24b8cd0fee8b85a3d8a710567f6f4fde
+  metadata.gz: aaa741df2a2cedebe5db8b763cb0aaac30f5829175baa76a90b4207bbfdb31f2b3eb87cf397eb475ef50e881db24c054e199677f09928f56c359712d5ee83101
+  data.tar.gz: 59c8234dfb28efcb3672fbfb23673bfa5f3748edb92618fc0b5bda474ad700cca898da79f705ce750ac22b47539605544bb5c15d9e53287d872f97e77ffd5d32

data/VERSION

@@ -1 +1 @@
-5.0.12
+5.1.0

data/lib/code/object/global.rb

@@ -107,6 +107,25 @@ class Code
         years: ::ActiveSupport::Duration::SECONDS_PER_YEAR
       }.freeze
       FUNCTIONS = {
+        "fail" => {
+          name: "fail",
+          description: "raises an explicit evaluation error.",
+          examples: [
+            "fail(\"missing configuration\") rescue nothing",
+            "fail(\"invalid response\") rescue :failed",
+            "fail(\"unavailable\") rescue \"fallback\""
+          ]
+        },
+        "assert" => {
+          name: "assert",
+          description:
+            "raises the supplied error unless the condition is truthy.",
+          examples: [
+            "assert(true, \"required\")",
+            "assert(1 == 1, \"unexpected\")",
+            "assert(false, \"required\") rescue nothing"
+          ]
+        },
         "Base64" => {
           name: "Base64",
           description:
@@ -493,6 +512,12 @@ class Code
         end
 
         case code_operator.to_s
+        when "fail"
+          sig(args) { String }
+          code_fail(code_value)
+        when "assert"
+          sig(args) { [Object, String] }
+          code_assert(code_value, code_arguments.code_second)
         when "Boolean"
           sig(args) { Object.repeat }
           if code_arguments.any?
@@ -800,6 +825,16 @@ class Code
         ::Kernel.sleep(duration)
         Nothing.new
       end
+
+      def code_fail(message)
+        raise ::Code::Error, message.to_s
+      end
+
+      def code_assert(value, message)
+        raise ::Code::Error, message.to_s unless value.to_code.truthy?
+
+        value.to_code
+      end
     end
   end
 end

data/lib/code/object/http.rb

@@ -94,7 +94,8 @@ class Code
         },
         "fetch" => {
           name: "fetch",
-          description: "sends an http request using the given method name.",
+          description:
+            "sends an http request with optional json, redirects, max_retries, retry_delays, retry_unsafe and max_bytes controls.",
           examples: [
             "Http.fetch(:get, \"http://httpbin.org/status/200\").success?",
             "Http.fetch(:post, \"http://httpbin.org/status/200\", body: :hello).request.body",
@@ -121,7 +122,13 @@ class Code
           timeout: (Integer | Decimal).maybe,
           open_timeout: (Integer | Decimal).maybe,
           read_timeout: (Integer | Decimal).maybe,
-          write_timeout: (Integer | Decimal).maybe
+          write_timeout: (Integer | Decimal).maybe,
+          redirects: Integer.maybe,
+          max_retries: Integer.maybe,
+          retry_delays: List.maybe,
+          retry_unsafe: Boolean.maybe,
+          max_bytes: Integer.maybe,
+          json: Object.maybe
         }
       ].freeze
 
@@ -273,16 +280,106 @@ class Code
         code_fetch("patch", ...)
       end
 
-      def self.code_fetch(*arguments, redirects: 10)
+      def self.code_fetch(*arguments, redirects: nil)
+        options = arguments.third.to_code
+        options = Dictionary.new if options.nothing?
+        delays = options.code_get("retry_delays")
+        delays = delays.nothing? ? [] : delays.as_json
+        unless delays.size <= 5 &&
+                 delays.all? do |delay|
+                   delay.is_a?(::Numeric) && delay.finite? &&
+                     delay.between?(0, 60)
+                 end
+          raise ::Code::Error, "http: invalid retry delays"
+        end
+
+        safe = %w[get head options].include?(arguments.first.to_s.downcase)
+        safe ||= options.code_get("retry_unsafe").truthy?
+        safe ||=
+          (options.code_get("headers").as_json || {}).any? do |key, value|
+            key.downcase == "idempotency-key" && value.present?
+          end
+        delays = [] unless safe
+        attempt = 0
+        loop do
+          begin
+            response = code_request(*arguments, redirects: redirects)
+          rescue ::Code::Error => e
+            unless ["http timeout", "http error"].include?(e.message) &&
+                     attempt < delays.size
+              raise
+            end
+
+            sleep(delays[attempt])
+            attempt += 1
+            next
+          end
+          status = response.code_get("code").raw
+          unless [408, 429].include?(status) || status.between?(500, 599)
+            return response
+          end
+          return response if attempt >= delays.size
+
+          retry_after =
+            response.code_get("headers").code_get("retry-after").to_s
+          delay = delays[attempt]
+          if retry_after.match?(/\A\d+\z/)
+            delay = [delay, retry_after.to_i].max
+          elsif retry_after.present?
+            begin
+              delay = [delay, ::Time.httpdate(retry_after) - ::Time.now].max
+            rescue ::ArgumentError
+              delay = delays[attempt]
+            end
+          end
+          return response if delay > 60
+
+          sleep(delay)
+          attempt += 1
+        end
+      end
+
+      def self.code_request(*arguments, redirects: nil)
         verb = arguments.first.to_code.to_s.downcase
         original_url = arguments.second.to_code.to_s
         options = arguments.third.to_code
         options = Dictionary.new if options.nothing?
+        if redirects.nil?
+          redirects =
+            (
+              if options.code_get("redirects").nothing?
+                10
+              else
+                options.code_get("redirects").raw
+              end
+            )
+        end
+        max_retries =
+          (
+            if options.code_get("max_retries").nothing?
+              0
+            else
+              options.code_get("max_retries").raw
+            end
+          )
+        unless redirects.between?(0, 10) && max_retries.between?(0, 5)
+          raise ::Code::Error, "http: invalid request limits"
+        end
+
         username = options.code_get("username").to_s
         password = options.code_get("password").to_s
         body = options.code_get("body").to_s
         headers = sanitized_headers(options.code_get("headers").raw || {})
         data = options.code_get("data").raw || {}
+        if options.code_has_key?("json").truthy?
+          if options.code_get("body").something? ||
+               options.code_get("data").something?
+            raise ::Code::Error,
+                  "http: json cannot be combined with body or data"
+          end
+          body = ::JSON.generate(options.code_get("json").as_json)
+          headers["Content-Type"] = "application/json"
+        end
         timeout = options.code_get("timeout")
         open_timeout = options.code_get("open_timeout")
         read_timeout = options.code_get("read_timeout")
@@ -291,7 +388,7 @@ class Code
         query = query.to_a.flatten.map(&:to_s).each_slice(2).to_h.to_query
 
         url = original_url
-        url = "#{url}?#{query}" if query.present?
+        url = "#{url}#{url.include?("?") ? "&" : "?"}#{query}" if query.present?
 
         if username.present? || password.present?
           authorization = ::Base64.strict_encode64("#{username}:#{password}")
@@ -299,12 +396,19 @@ class Code
           validate_header_size!("Authorization", headers["Authorization"])
         end
 
+        max_bytes = options.code_get("max_bytes")
+        max_bytes = max_bytes.nothing? ? nil : max_bytes.raw
+        if max_bytes && !max_bytes.between?(1, 50.megabytes)
+          raise ::Code::Error, "http: invalid response size limit"
+        end
+
         uri = parse_uri(url)
         resolved_ip = ::Code::Network.validate_public_uri!(uri, service: "http")
 
         http = ::Net::HTTP.new(uri.hostname, uri.port, nil)
         http.ipaddr = resolved_ip
         http.use_ssl = true if uri.scheme == "https"
+        http.max_retries = max_retries
         default_timeout = http_timeout(timeout, DEFAULT_TIMEOUT)
         open_timeout_value = http_timeout(open_timeout, default_timeout)
         read_timeout_value = http_timeout(read_timeout, default_timeout)
@@ -346,6 +450,11 @@ class Code
               validate_response_headers!(http_response)
 
               http_response.read_body do |chunk|
+                if max_bytes &&
+                     response_body.bytesize + chunk.bytesize > max_bytes
+                  raise ::Code::Error, "http response is too large"
+                end
+
                 response_body << chunk
               end
             end
@@ -362,16 +471,25 @@ class Code
           new_uri = parse_uri(::URI.join(uri, location).to_s)
           ::Code::Network.validate_public_uri!(new_uri, service: "http")
 
-          if same_origin?(new_uri, uri)
-            code_fetch(
-              "get",
-              new_uri.to_s,
-              { username: username, password: password, headers: headers },
-              redirects: redirects - 1
-            )
-          else
-            code_fetch("get", new_uri.to_s, redirects: redirects - 1)
+          redirect_options = options.as_json.except("query")
+          redirect_method = [307, 308].include?(code) ? verb : "get"
+          unless same_origin?(new_uri, uri)
+            unless %w[get head].include?(redirect_method)
+              raise ::Code::Error,
+                    "http: cannot redirect request body to another origin"
+            end
+            redirect_options =
+              redirect_options.except("username", "password", "headers")
           end
+          if redirect_method == "get"
+            redirect_options = redirect_options.except("body", "data", "json")
+          end
+          code_request(
+            redirect_method,
+            new_uri.to_s,
+            redirect_options,
+            redirects: redirects - 1
+          )
         else
           status = STATUS_CODES.key(code) || :ok
           response_headers = response.each_header.to_h
@@ -379,7 +497,7 @@ class Code
             request.to_hash.transform_values { |values| List.new(values) }
           body = response_body.to_s
 
-          Dictionary.new(
+          HttpResponse.new(
             :code => code,
             :status => status,
             :body => body,

data/lib/code/object/http_response.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+class Code
+  class Object
+    class HttpResponse < Dictionary
+      CLASS_DOCUMENTATION = {
+        name: "HttpResponse",
+        description: "an HTTP response with JSON and retry status helpers.",
+        examples: %w[
+          Http.get("http://httpbin.org/status/200").code
+          Http.get("http://httpbin.org/status/204").success?
+          Http.get("http://httpbin.org/status/500").retryable?
+        ]
+      }.freeze
+      INSTANCE_FUNCTIONS = {
+        "json" => {
+          name: "json",
+          description: "parses the response body or returns nothing.",
+          examples: [
+            "Http.get(\"http://httpbin.org/status/200\").json",
+            "Http.get(\"http://httpbin.org/status/204\").json",
+            "Http.get(\"http://httpbin.org/status/500\").json"
+          ]
+        },
+        "json!" => {
+          name: "json!",
+          description: "parses the response body or raises on malformed JSON.",
+          examples: [
+            "Http.get(\"http://httpbin.org/status/200\").json! rescue nothing",
+            "Http.get(\"http://httpbin.org/status/204\").json! rescue nothing",
+            "Http.get(\"http://httpbin.org/status/500\").json! rescue nothing"
+          ]
+        },
+        "retryable?" => {
+          name: "retryable?",
+          description:
+            "reports request timeout rate limit and server error statuses.",
+          examples: [
+            "Http.get(\"http://httpbin.org/status/408\").retryable?",
+            "Http.get(\"http://httpbin.org/status/429\").retryable?",
+            "Http.get(\"http://httpbin.org/status/200\").retryable?"
+          ]
+        }
+      }.freeze
+
+      def self.function_documentation(scope)
+        scope == :instance ? INSTANCE_FUNCTIONS : {}
+      end
+
+      def call(**args)
+        case args.fetch(:operator, nil).to_s
+        when "json"
+          sig(args)
+          code_json
+        when "json!"
+          sig(args)
+          code_json!
+        when "retryable?"
+          sig(args)
+          code_retryable?
+        else
+          super
+        end
+      end
+
+      def code_json
+        Json.code_parse(code_get("body"))
+      end
+
+      def code_json!
+        Json.code_parse!(code_get("body"))
+      end
+
+      def code_retryable?
+        status = code_get("code").raw
+        ([408, 429].include?(status) || status.between?(500, 599)).to_code
+      end
+    end
+  end
+end

data/lib/code/object/json.rb

@@ -13,6 +13,16 @@ class Code
         ]
       }.freeze
       CLASS_FUNCTIONS = {
+        "parse!" => {
+          name: "parse!",
+          description:
+            "parses JSON and raises an evaluation error on invalid input.",
+          examples: [
+            'Json.parse!("[1]")',
+            'Json.parse!("true")',
+            'Json.parse!("bad") rescue nothing'
+          ]
+        },
         "parse" => {
           name: "parse",
           description:
@@ -47,6 +57,9 @@ class Code
         code_value = code_arguments.code_first
 
         case code_operator.to_s
+        when "parse!"
+          sig(args) { String }
+          code_parse!(code_value)
         when "parse"
           sig(args) { String }
           code_parse(code_value)
@@ -75,6 +88,12 @@ class Code
         Nothing.new
       end
 
+      def self.code_parse!(value)
+        ::JSON.parse(value.to_code.raw).to_code
+      rescue ::JSON::ParserError
+        raise ::Code::Error, "invalid JSON"
+      end
+
       def self.code_generate(value, pretty: nil)
         value.to_code.code_to_json(pretty: pretty)
       end

data/lib/code/object/string.rb

@@ -10,6 +10,16 @@ class Code
         examples: ["\"hello\"", ":hello.upcase", "\"a,b\".split(\",\")"]
       }.freeze
       INSTANCE_FUNCTIONS = {
+        "truncate" => {
+          name: "truncate",
+          description:
+            "shortens text to a character limit with an optional omission.",
+          examples: [
+            "\"abcdef\".truncate(5)",
+            "\"abcdef\".truncate(5, omission: \"…\")",
+            "\"abc\".truncate(5)"
+          ]
+        },
         "&" => {
           name: "&",
           description: "returns a function that calls the named selector.",
@@ -593,6 +603,9 @@ class Code
         code_value = code_arguments.code_first
 
         case code_operator.to_s
+        when "truncate"
+          sig(args) { [Integer, { omission: String.maybe }] }
+          code_truncate(code_arguments.code_first, code_arguments.code_second)
         when "&", "to_function"
           sig(args)
           code_to_function(**globals)
@@ -1183,9 +1196,11 @@ class Code
         code_value = value.to_code
 
         List.new(
-          raw.scan(code_value.raw).map do |match|
-            match.is_a?(::Array) ? List.new(match) : String.new(match)
-          end
+          raw
+            .scan(code_value.raw)
+            .map do |match|
+              match.is_a?(::Array) ? List.new(match) : String.new(match)
+            end
         )
       end
 
@@ -1205,6 +1220,17 @@ class Code
           .force_encoding(::Encoding::UTF_8)
           .encode(::Encoding::UTF_8, invalid: :replace, undef: :replace)
       end
+
+      def code_truncate(limit, options = nil)
+        limit = limit.to_code.raw
+        omission = options.to_code.code_get("omission")
+        omission = omission.nothing? ? "..." : omission.to_s
+        if limit < omission.length
+          raise ::Code::Error, "invalid truncation limit"
+        end
+
+        raw.truncate(limit, omission: omission).to_code
+      end
     end
   end
 end

data/lib/code/object/url.rb

@@ -14,6 +14,15 @@ class Code
         ]
       }.freeze
       CLASS_FUNCTIONS = {
+        "join" => {
+          name: "join",
+          description: "resolves a relative URL against a base URL.",
+          examples: [
+            "Url.join(\"https://example.com/a/b\", \"../c\")",
+            "Url.join(\"https://example.com/a\", \"/b\")",
+            "Url.join(\"https://example.com\", \"https://other.example.com\")"
+          ]
+        },
         "encode" => {
           name: "encode",
           description: "returns url-escaped text for a value.",
@@ -44,8 +53,75 @@ class Code
         }
       }.freeze
 
+      INSTANCE_FUNCTIONS = {
+        "scheme" => {
+          name: "scheme",
+          description: "returns the scheme URL component.",
+          examples: [
+            "Url.parse(\"https://example.com/path?q=1\").scheme",
+            "Url.parse(\"https://user:pass@example.com/#fragment\").scheme",
+            "Url.parse(\"/relative\").scheme"
+          ]
+        },
+        "host" => {
+          name: "host",
+          description: "returns the host URL component.",
+          examples: [
+            "Url.parse(\"https://example.com/path?q=1\").host",
+            "Url.parse(\"https://user:pass@example.com/#fragment\").host",
+            "Url.parse(\"/relative\").host"
+          ]
+        },
+        "path" => {
+          name: "path",
+          description: "returns the path URL component.",
+          examples: [
+            "Url.parse(\"https://example.com/path?q=1\").path",
+            "Url.parse(\"https://user:pass@example.com/#fragment\").path",
+            "Url.parse(\"/relative\").path"
+          ]
+        },
+        "query" => {
+          name: "query",
+          description: "returns the query URL component.",
+          examples: [
+            "Url.parse(\"https://example.com/path?q=1\").query",
+            "Url.parse(\"https://user:pass@example.com/#fragment\").query",
+            "Url.parse(\"/relative\").query"
+          ]
+        },
+        "fragment" => {
+          name: "fragment",
+          description: "returns the fragment URL component.",
+          examples: [
+            "Url.parse(\"https://example.com/path?q=1\").fragment",
+            "Url.parse(\"https://user:pass@example.com/#fragment\").fragment",
+            "Url.parse(\"/relative\").fragment"
+          ]
+        },
+        "user" => {
+          name: "user",
+          description: "returns the user URL component.",
+          examples: [
+            "Url.parse(\"https://example.com/path?q=1\").user",
+            "Url.parse(\"https://user:pass@example.com/#fragment\").user",
+            "Url.parse(\"/relative\").user"
+          ]
+        },
+        "password" => {
+          name: "password",
+          description: "returns the password URL component.",
+          examples: [
+            "Url.parse(\"https://example.com/path?q=1\").password",
+            "Url.parse(\"https://user:pass@example.com/#fragment\").password",
+            "Url.parse(\"/relative\").password"
+          ]
+        }
+      }.freeze
+
       def self.function_documentation(scope)
         return CLASS_FUNCTIONS if scope == :class
+        return INSTANCE_FUNCTIONS if scope == :instance
 
         {}
       end
@@ -61,6 +137,9 @@ class Code
         code_arguments = args.fetch(:arguments, []).to_code
 
         case code_operator.to_s
+        when "join"
+          sig(args) { [String, String] }
+          code_join(*code_arguments.raw)
         when "encode"
           sig(args) { Object.maybe }
           code_encode(*code_arguments.raw)
@@ -75,6 +154,41 @@ class Code
         end
       end
 
+      def self.code_join(base, relative)
+        ::URI.join(base.to_s, relative.to_s).to_s.to_code
+      rescue ::URI::InvalidURIError, ::URI::BadURIError
+        raise ::Code::Error, "invalid URL"
+      end
+
+      def call(**args)
+        operator = args.fetch(:operator, nil).to_s
+        case operator
+        when "scheme"
+          sig(args)
+          code_scheme
+        when "host"
+          sig(args)
+          code_host
+        when "path"
+          sig(args)
+          code_path
+        when "query"
+          sig(args)
+          code_query
+        when "fragment"
+          sig(args)
+          code_fragment
+        when "user"
+          sig(args)
+          code_user
+        when "password"
+          sig(args)
+          code_password
+        else
+          super
+        end
+      end
+
       def self.code_encode(string = nil)
         code_string = string.to_code
 
@@ -88,6 +202,34 @@ class Code
       def self.code_parse(string = nil)
         new(string)
       end
+
+      def code_scheme
+        raw.scheme.to_code
+      end
+
+      def code_host
+        raw.host.to_code
+      end
+
+      def code_path
+        raw.path.to_code
+      end
+
+      def code_query
+        raw.query.to_code
+      end
+
+      def code_fragment
+        raw.fragment.to_code
+      end
+
+      def code_user
+        raw.user.to_code
+      end
+
+      def code_password
+        raw.password.to_code
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: code-ruby
 version: !ruby/object:Gem::Version
-  version: 5.0.12
+  version: 5.1.0
 platform: ruby
 authors:
 - Dorian Marié
@@ -368,6 +368,7 @@ files:
 - lib/code/object/global.rb
 - lib/code/object/html.rb
 - lib/code/object/http.rb
+- lib/code/object/http_response.rb
 - lib/code/object/ics.rb
 - lib/code/object/identifier_list.rb
 - lib/code/object/integer.rb
@@ -410,7 +411,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.17
+rubygems_version: 4.0.10
 specification_version: 4
 summary: a programming language for the internet
 test_files: []