tina4ruby 3.13.30 → 3.13.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c71dd3827f3ae5125eb53a9fb77ebb9df940f02616163b93d3934b28561c902
-  data.tar.gz: 4269e49ecb160a17cd58f17ee10dce63d483fd3f411aab05642014dd64ef5e81
+  metadata.gz: 6140bb67a60387c462e70052c88bbde69ba3b669c0371380df401bd8f9a0b039
+  data.tar.gz: 7e0043ae026ed273a444f6185f289d0099458fc9ce605bfe4380c1fda9b6f672
 SHA512:
-  metadata.gz: c3c4db5b3fa3359a8c27ad62d89dce04c60953be4d9e9dc6f60343f34f5168e1bc86a8df0cb6c37d40a9559cec5e950737438a18573d473960151beccd0ddacf
-  data.tar.gz: af8d3b0c1847de387fac1bf7af34eca83bbbf287e57268f4e86d83610dd919d358f9e071e814653503bb599dbf545aa3f1547edbe13d529166904c0773b72151
+  metadata.gz: 83b74a98d73ebcfdd0f22a9335b09382d5e518d51f3443b5e29dafdddb892374e41c8b9cbbc0b4a3d354e3bd405996a376c2e93df1f996778a73d349561a2879
+  data.tar.gz: 4eadb6a043ec78b5058465b73e4f10f2bf8d91ed19f5e22e5a5a00e2f4b57de8f59fe321b89b5e1e6417dc2dd15ff9142bb36635eed1275f85b59148149498fd

data/lib/tina4/graphql.rb

@@ -1026,7 +1026,9 @@ module Tina4
 
       graphql = self
       Tina4.post path, auth: false do |request, response|
-        body = request.body
+        # handle_request expects the raw JSON text (it JSON.parses internally),
+        # so read body_raw — request.body now returns the PARSED payload.
+        body = request.body_raw
         result = graphql.handle_request(body, context: { request: request })
         response.json(result)
       end

data/lib/tina4/request.rb

@@ -35,6 +35,26 @@ module Tina4
     end
   end
 
+  # Per-file upload hash: indifferent access plus a lazily-materialised
+  # `content` field. The raw bytes are read from the tempfile only on first
+  # access to `content` (then rewound, so :tempfile streaming still works),
+  # so :tempfile-only handlers never buffer large uploads in memory.
+  class FileUpload < IndifferentHash
+    def [](key)
+      if key.to_s == "content" && !key?("content") && (tf = super("tempfile"))
+        self["content"] = begin
+          tf.rewind if tf.respond_to?(:rewind)
+          data = tf.read
+          tf.rewind if tf.respond_to?(:rewind)
+          data
+        rescue StandardError
+          nil
+        end
+      end
+      super(key)
+    end
+  end
+
   # Hash subclass for HTTP headers — string keys are case-insensitive.
   #
   # HTTP header field-names are case-insensitive per RFC 7230 §3.2. With
@@ -161,16 +181,25 @@ module Tina4
       @session ||= Tina4::Session.new(@env)
     end
 
-    # Raw body string
+    # Parsed body (JSON -> Hash, form-urlencoded -> Hash, multipart ->
+    # fields Hash, else the current fallback). This matches Python's
+    # `request.body`, PHP's, and Node's: `body` is the PARSED payload, not
+    # the raw bytes. For the raw string use `body_raw`.
     def body
-      @body_raw ||= read_body
+      @body_parsed ||= parse_body
     end
 
-    # Parsed body (JSON or form data)
-    def body_parsed
-      @body_parsed ||= parse_body
+    # Raw body string — the bytes exactly as the client sent them.
+    # (This is what `body` used to return before the cross-framework
+    # parity flip; SOAP/GraphQL and any consumer that needs the raw text
+    # reads this.)
+    def body_raw
+      @body_raw ||= read_body
     end
 
+    # Backwards-compatible alias of `body` — both return the parsed payload.
+    alias body_parsed body
+
     # Parsed query string as hash
     def query
       @query_hash ||= parse_query_to_hash(@query_string)
@@ -204,7 +233,7 @@ module Tina4
 
     def json_body
       @json_body ||= begin
-        JSON.parse(body)
+        JSON.parse(body_raw)
       rescue JSON::ParserError, TypeError
         {}
       end
@@ -273,7 +302,7 @@ module Tina4
       if @content_type.include?("application/json")
         json_body
       elsif @content_type.include?("application/x-www-form-urlencoded")
-        parse_query_to_hash(body)
+        parse_query_to_hash(body_raw)
       elsif @content_type.include?("multipart/form-data")
         # Extract form fields from Rack's parsed multipart data.
         # Files are handled separately by extract_files.
@@ -324,12 +353,19 @@ module Tina4
         if form_hash
           form_hash.each do |key, value|
             if value.is_a?(Hash) && value[:tempfile]
-              result[key] = {
-                filename: value[:filename],
-                type: value[:type],
-                tempfile: value[:tempfile],
-                size: value[:tempfile].size
-              }
+              tempfile = value[:tempfile]
+
+              # Indifferent-access per-file hash so file["content"],
+              # file[:content], file["filename"], file[:filename] all work.
+              # `content` (raw bytes, never base64) is materialised lazily on
+              # first access (see FileUpload) — :tempfile-only handlers never
+              # buffer large uploads in memory.
+              file = FileUpload.new
+              file[:filename] = value[:filename]
+              file[:type]     = value[:type]
+              file[:tempfile] = tempfile
+              file[:size]     = tempfile.size
+              result[key] = file
             end
           end
         end

data/lib/tina4/response.rb

@@ -285,9 +285,19 @@ module Tina4
       self
     end
 
-    # Stream response from a block for Server-Sent Events (SSE).
+    # Stream a response for Server-Sent Events (SSE) / chunked transfer.
     #
-    # Usage:
+    # Two equivalent call styles (cross-framework parity — Python/PHP/Node
+    # pass a generator positionally; Ruby additionally supports a block):
+    #
+    #   # 1. Positional generator (Enumerator, or anything responding to
+    #   #    #each or #call that yields string chunks):
+    #   gen = Enumerator.new do |y|
+    #     10.times { |i| y << "data: message #{i}\n\n" }
+    #   end
+    #   response.stream(gen)
+    #
+    #   # 2. Block form (unchanged):
     #   Tina4::Router.get "/events" do |request, response|
     #     response.stream do |out|
     #       10.times do |i|
@@ -297,16 +307,18 @@ module Tina4
     #     end
     #   end
     #
+    # @param generator [#each, #call, nil] Optional source of string chunks.
     # @param content_type [String] Content type (default: text/event-stream)
     # @yield [Enumerator::Yielder] Block receives a yielder to push chunks
     # @return [self]
-    def stream(content_type: "text/event-stream", &block)
+    def stream(generator = nil, content_type: "text/event-stream", &block)
       @status_code = @status_code || 200
       @headers["content-type"] = content_type
       @headers["cache-control"] = "no-cache"
       @headers["connection"] = "keep-alive"
       @headers["x-accel-buffering"] = "no"
       @_streaming = true
+      @_stream_generator = generator
       @_stream_block = block
       self
     end
@@ -330,9 +342,24 @@ module Tina4
       final_headers["set-cookie"] = @cookies.join("\n") if @cookies && !@cookies.empty?
 
       if @_streaming
-        # Streaming mode — return an Enumerator as the body
+        # Streaming mode — return an Enumerator as the Rack body. A positional
+        # generator wins over a block when both are somehow present.
+        gen = @_stream_generator
+        blk = @_stream_block
         body = Enumerator.new do |yielder|
-          @_stream_block.call(yielder)
+          if gen
+            if gen.respond_to?(:each)
+              # Enumerator / array / any Enumerable of string chunks
+              gen.each { |chunk| yielder << chunk }
+            elsif gen.respond_to?(:call)
+              # Callable that receives the yielder, like the block form
+              gen.call(yielder)
+            else
+              yielder << gen.to_s
+            end
+          elsif blk
+            blk.call(yielder)
+          end
         end
         return [@status_code, final_headers, body]
       end

data/lib/tina4/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tina4
-  VERSION = "3.13.30"
+  VERSION = "3.13.31"
 end

data/lib/tina4/wsdl.rb

@@ -116,9 +116,18 @@ module Tina4
     def handle
       return generate_wsdl if @request.nil?
 
+      # SOAP bodies are raw XML, so read the raw bytes. On a real
+      # Tina4::Request use body_raw (request.body now returns the PARSED
+      # payload); test stubs that only expose `body` fall back to it.
+      raw_body = if @request.respond_to?(:body_raw)
+                   @request.body_raw
+                 elsif @request.respond_to?(:body)
+                   @request.body
+                 end
+
       method = if @request.respond_to?(:method)
                  @request.method.to_s.upcase
-               elsif @request.respond_to?(:body) && @request.body && !@request.body.to_s.empty?
+               elsif raw_body && !raw_body.to_s.empty?
                  "POST"
                else
                  "GET"
@@ -131,11 +140,7 @@ module Tina4
         return generate_wsdl
       end
 
-      body = if @request.respond_to?(:body)
-               @request.body.is_a?(String) ? @request.body : @request.body.to_s
-             else
-               ""
-             end
+      body = raw_body.is_a?(String) ? raw_body : raw_body.to_s
 
       process_soap(body)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.13.30
+  version: 3.13.31
 platform: ruby
 authors:
 - Tina4 Team
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-16 00:00:00.000000000 Z
+date: 2026-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack