tungsten-runtime 0.1.4 → 0.1.6

data/lib/tungsten/runtime/schema.rb

@@ -12,14 +12,20 @@ module Tungsten
     # before any network call, success bodies, page items and events after.
     #
     # Issues come structure first, then constraint violations, then unknown
-    # members. Types are strict (no coercion); string lengths count UTF-16
-    # code units. `pattern` is an ECMAScript expression run on Onigmo, Ruby's
+    # members. Types are strict (no coercion); string lengths count Unicode
+    # code points (a surrogate pair is one, a lone surrogate is one).
+    # `pattern` is an ECMAScript expression run on Onigmo, Ruby's
     # engine: `^` and `$` outside a character class are anchored to the
     # whole string (`\A`, `\z`) as in ECMAScript without the `m` flag; other
     # differences (Unicode property and case-folding details, `\d`, `\w` and
     # `\s` being ASCII-only in Ruby) are Onigmo's, and a pattern Onigmo
-    # cannot compile is not checked.
+    # cannot compile is not checked: the value is accepted and the pattern is
+    # reported (see `validate`).
     class Schema
+      # A pattern that could not be checked: the value was accepted without
+      # it. It never holds the value.
+      PatternNote = Data.define(:path, :pattern, :reason)
+
       DATE = "(?:(?:[0-9][0-9][2468][048]|[0-9][0-9][13579][26]|[0-9][0-9]0[48]|[02468][048]00" \
              "|[13579][26]00)-02-29|[0-9]{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12][0-9]|3[01])" \
              "|(?:0[469]|11)-(?:0[1-9]|[12][0-9]|30)|(?:02)-(?:0[1-9]|1[0-9]|2[0-8])))"
@@ -41,15 +47,22 @@ module Tungsten
 
       class << self
         # The compiled pattern of an ECMAScript source, or nil when Onigmo
-        # cannot compile it.
+        # cannot compile it (see `pattern_error`).
         def pattern(source)
-          @patterns_lock.synchronize do
-            return @patterns[source] if @patterns.key?(source)
+          compile(source)[0]
+        end
 
-            @patterns[source] = begin
-              Regexp.new(translate(source))
-            rescue RegexpError, ArgumentError
-              nil
+        # Why Onigmo cannot compile the source, or nil when it can.
+        def pattern_error(source)
+          compile(source)[1]
+        end
+
+        def compile(source)
+          @patterns_lock.synchronize do
+            @patterns[source] ||= begin
+              [Regexp.new(translate(source)), nil]
+            rescue RegexpError, ArgumentError => e
+              [nil, "it is not a regular expression this runtime can compile (Onigmo: #{e.message.sub(/: \/.*\z/m, '')})"]
             end
           end
         end
@@ -91,18 +104,21 @@ module Tungsten
         @defs = defs || {}
       end
 
-      # The issues of a value, none when it is valid.
-      def validate(value)
-        run(@schema, value)
+      # The issues of a value, none when it is valid. `notes`, when given (an
+      # Array), receives a PatternNote for each pattern that could not be
+      # checked (once per path and pattern); the value was accepted without
+      # it. Without `notes` the call is silent.
+      def validate(value, notes = nil)
+        run(@schema, value, notes)
       end
 
       # Whether the value is valid.
       def accepts?(value) = validate(value).empty?
 
-      def run(schema, value)
+      def run(schema, value, notes = nil)
         # Descriptors share validators across clients. Keep each validation's
         # issue lists on its own worker, including recursive union probes.
-        self.class.new(schema, @defs).send(:run_validation, schema, value)
+        self.class.new(schema, @defs).send(:run_validation, schema, value, notes)
       end
 
       # Whether `schema` admits `value`, in a fresh run (union variants).
@@ -112,7 +128,9 @@ module Tungsten
 
       private
 
-      def run_validation(schema, value)
+      def run_validation(schema, value, notes)
+        @notes = notes
+        @noted = {}
         @structure = []
         @constraints = []
         @unknown = []
@@ -282,12 +300,24 @@ module Tungsten
         value.is_a?(Float) && value == value.truncate && value.abs < Json::MAX_SAFE ? value.to_i.to_s : Json.number_text(value)
       end
 
+      def unchecked(path, source, reason)
+        return unless @notes
+        return if @noted.key?([path, source])
+
+        @noted[[path, source]] = true
+        @notes << PatternNote.new(path: path, pattern: source, reason: reason)
+      end
+
       def string_limits(schema, text, path)
-        n = Json.utf16_length(text)
+        n = Json.code_point_length(text)
         limit(path, "must have at least #{schema['min_length']} characters") if schema["min_length"] && n < schema["min_length"]
         limit(path, "must have at most #{schema['max_length']} characters") if schema["max_length"] && n > schema["max_length"]
-        if (source = schema["pattern"]) && (re = Schema.pattern(source)) && !re.match?(text)
-          limit(path, "must match the pattern /#{source}/")
+        if (source = schema["pattern"])
+          if (re = Schema.pattern(source))
+            limit(path, "must match the pattern /#{source}/") unless re.match?(text)
+          else
+            unchecked(path, source, Schema.pattern_error(source))
+          end
         end
         format = FORMATS[schema["format"]]
         limit(path, "must be a valid #{schema['format']}") if format && !format.match?(text)

data/lib/tungsten/runtime/serialize.rb

@@ -14,7 +14,7 @@ module Tungsten
       Encoded = Data.define(:empty, :bytes, :parts, :content_type, :display, :hashed)
       EMPTY = Encoded.new(empty: true, bytes: nil, parts: nil, content_type: nil, display: nil, hashed: nil)
 
-      # One multipart part: `kind` :text, :json or :file.
+      # One multipart part: `kind` :text, :json (a typed text part) or :file.
       Part = Data.define(:name, :kind, :text, :data, :filename, :content_type)
 
       module_function
@@ -141,8 +141,36 @@ module Tungsten
         end
       end
 
-      # name=value of a cookie parameter.
+      # RFC 6265 cookie-octets.
+      COOKIE_OCTET = /\A[\x21\x23-\x2B\x2D-\x3A\x3C-\x5B\x5D-\x7E]\z/
+
+      # A cookie style value as written; only characters a cookie cannot
+      # carry are percent-encoded.
+      def cookie_text(text) = text.to_s.each_char.map { |c| COOKIE_OCTET.match?(c) ? c : encode_component(c) }.join
+
+      # OpenAPI 3.2 cookie style: n=v, n=v1,v2 or exploded n=v1; n=v2 and
+      # k=v; k2=v2.
+      def cookie_style(p, value)
+        case value
+        when Array
+          items = value.reject(&:nil?).map { |v| cookie_text(scalar(v)) }
+          return items.map { |i| "#{p.wire}=#{i}" }.join("; ") if p.explode && !items.empty?
+
+          "#{p.wire}=#{items.join(',')}"
+        when Hash
+          pairs = value.reject { |_, v| v.nil? }.map { |k, v| [cookie_text(k), cookie_text(scalar(v))] }
+          return pairs.map { |k, v| "#{k}=#{v}" }.join("; ") if p.explode && !pairs.empty?
+
+          "#{p.wire}=#{pairs.flatten.join(',')}"
+        else "#{p.wire}=#{cookie_text(scalar(value))}"
+        end
+      end
+
+      # name=value of a cookie parameter (form style, values encoded; or
+      # cookie style).
       def cookie_param(p, value)
+        return cookie_style(p, value) if p.style == "cookie"
+
         case value
         when Array then "#{p.wire}=#{encoded_items(value).join(',')}"
         when Hash then "#{p.wire}=#{encoded_pairs(value).flatten.join(',')}"
@@ -212,7 +240,7 @@ module Tungsten
           text = pairs.map { |k, v| "#{encode_form_component(k)}=#{encode_form_component(v)}" }.join("&")
           Encoded.new(empty: false, bytes: text.b, parts: nil, content_type: media, display: redact.call(pairs.to_h),
                       hashed: text.b)
-        when "multipart" then multipart(value, redact)
+        when "multipart" then multipart(value, redact, desc.parts)
         when "bytes"
           bin = Json.binary_of(value)
           data =
@@ -242,7 +270,7 @@ module Tungsten
         end
       end
 
-      def multipart(value, redact)
+      def multipart(value, redact, declared_parts = {})
         unless value.is_a?(Hash)
           return SerializationError.new(parameter: "body", expected: "an object of multipart fields", value: value)
         end
@@ -254,10 +282,12 @@ module Tungsten
 
           list = item.is_a?(Array) ? item.reject(&:nil?) : [item]
           shown = []
+          declared = declared_parts[k.to_s]
+          declared_json = !declared.nil? && Classify.json_media?(declared.split(";", 2).first.to_s.strip.downcase)
           list.each do |x|
             bin = Json.binary_of(x)
             if !UNSET.equal?(bin)
-              content_type = bin.content_type || "application/octet-stream"
+              content_type = bin.content_type || declared || "application/octet-stream"
               unless valid_media_type?(content_type)
                 return SerializationError.new(parameter: "body", expected: "multipart file content types that are valid media types",
                                               value: value)
@@ -265,12 +295,17 @@ module Tungsten
 
               # Keep the checked header value stable until the body is sent.
               content_type = content_type.dup.freeze
-              shown << binary_display(bin.bytesize, bin.content_type)
+              shown << binary_display(bin.bytesize, bin.content_type || declared)
               parts << Part.new(name: k, kind: :file, text: nil, data: bin.data, filename: bin.filename || k,
                                 content_type: content_type)
             elsif x.is_a?(Hash)
-              parts << Part.new(name: k, kind: :json, text: Json.text(x), data: nil, filename: nil, content_type: nil)
+              parts << Part.new(name: k, kind: :json, text: Json.text(x), data: nil, filename: nil,
+                                content_type: declared_json ? declared : "application/json")
               shown << x
+            elsif declared
+              parts << Part.new(name: k, kind: :json, text: declared_json ? Json.text(x) : scalar(x), data: nil,
+                                filename: nil, content_type: declared)
+              shown << scalar(x)
             else
               parts << Part.new(name: k, kind: :text, text: scalar(x), data: nil, filename: nil, content_type: nil)
               shown << scalar(x)
@@ -295,7 +330,7 @@ module Tungsten
             out << "Content-Type: #{p.content_type}\r\n\r\n".b << p.data.b
           when :json
             out << %(Content-Disposition: form-data; name="#{quote.call(p.name)}"\r\n).b
-            out << "Content-Type: application/json\r\n\r\n".b << p.text.b
+            out << "Content-Type: #{p.content_type}\r\n\r\n".b << p.text.b
           else
             out << %(Content-Disposition: form-data; name="#{quote.call(p.name)}"\r\n\r\n).b << p.text.b
           end

data/lib/tungsten/runtime/stream.rb

@@ -278,7 +278,7 @@ module Tungsten
           return FailedStream.new(Runtime.diag(d.id, "VALIDATION_FAILED").param("opts").expected("call options")
                                          .remedy("Pass the call options as a Hash of idempotency_key, confirm, timeout_ms, verify and headers (#{e.message}).").err)
         end
-        EventStream.new(self, d, args, o, decode)
+        EventStream.new(self, d, args, with_call_deadline(o), decode)
       end
 
       # A stream that fails before it starts.
@@ -463,14 +463,14 @@ module Tungsten
           Err.new(error: Util.scrub_diagnostic(b.status(o.meta.status).request_id(o.meta.request_id).retrying("never")
                                                  .attempts(o.meta.attempts).build, o.secrets))
         end
-        value = Json.try_parse(ev.data)
+        value = op.stream["text"] ? ev.data : Json.try_parse(ev.data)
         if UNSET.equal?(value)
           return failure.call(Runtime.diag(op.id, "UNEXPECTED_RESPONSE").param("events[#{index}]")
                                      .received(Util.envelope_value(ev.data, false)).expected("JSON in the data of every event")
                                      .remedy("Event #{index} of the stream (event \"#{ev.event}\") does not carry JSON in its data.#{after_effect} Events before it were delivered."))
         end
         if @validate_responses != "off" && op.stream["event"]
-          issues = judge(op.stream["event"], value)
+          issues = judge(op.stream["event"], value, op.id, "events[#{index}]")
           unless issues.empty?
             issue = issues.first
             path_text = Runtime.issue_path(issue.path)

data/lib/tungsten/runtime/version.rb

@@ -4,6 +4,6 @@
 module Tungsten
   module Runtime
     # The runtime's version, sent as X-Tungsten-Runtime: tungsten-rb/<version>.
-    VERSION = "0.1.4"
+    VERSION = "0.1.6"
   end
 end

data/lib/tungsten/runtime.rb

@@ -41,6 +41,8 @@ require_relative "runtime/expr"
 require_relative "runtime/client_core"
 require_relative "runtime/auth"
 require_relative "runtime/oauth"
+require_relative "runtime/oauth_inputs"
+require_relative "runtime/oauth_sessions"
 require_relative "runtime/pages"
 require_relative "runtime/macros"
 require_relative "runtime/sse"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tungsten-runtime
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - Prince Boachie
@@ -47,6 +47,8 @@ files:
 - lib/tungsten/runtime/json.rb
 - lib/tungsten/runtime/macros.rb
 - lib/tungsten/runtime/oauth.rb
+- lib/tungsten/runtime/oauth_inputs.rb
+- lib/tungsten/runtime/oauth_sessions.rb
 - lib/tungsten/runtime/options.rb
 - lib/tungsten/runtime/pages.rb
 - lib/tungsten/runtime/schema.rb