tina4ruby 3.13.32 → 3.13.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02b84dbb5f8e4d009306495921ab7849a28fd769d81d13019b311523d970a0e5
-  data.tar.gz: e1b298c7bd03444def8787941f87a7e6fd0adcb6be23efe810990c6005d27910
+  metadata.gz: 637cbcba6a20d87ba864c46ba1a993f839923e70139318c5b0f5096d206dd96f
+  data.tar.gz: '0960af3938c2a29b007934cc0e09e6988a701c7abd2af0894dbf0cc281af4a41'
 SHA512:
-  metadata.gz: 8bf774f6208956221c87bb2f546a04aab950a3cae5962dae94bbd430ee55463481886ba315a21f2680b017828d99df0c6e7a54fff331cff0e559b176da45c5a9
-  data.tar.gz: 5242a9295d6e70763ca68a377f2aa3dfd2ac8b37402b8660f439ea6bc6e0c5ddb1f278d277c2ff4ab8bf62b6d80f0ad316c8c07c099f07ecdee9040bea0ddfe5
+  metadata.gz: 888be7579dd11c54e73823a1d9fa471814d1839413a95713c665aa105cdfbcdfe1f5d85bfcc09f799cd3a099a8f259755896df8a42f896d0e1c2103640e0dfb1
+  data.tar.gz: 07c92f8524fd74d401a466aea1ce23d45a2e439fed77e11aa7b61086cc2cf438110542721b890e6163e3929f77f94df021bb54b091607ec435f4f5e3b109fa48

data/lib/tina4/job.rb

@@ -4,31 +4,41 @@ require "securerandom"
 
 module Tina4
   class Job
-    attr_reader :id, :topic, :payload, :created_at, :attempts, :priority, :available_at
-    attr_accessor :status
+    attr_reader :id, :topic, :payload, :created_at, :priority, :available_at
+    attr_accessor :status, :attempts, :error, :queue
 
-    def initialize(topic:, payload:, id: nil, priority: 0, available_at: nil, attempts: 0, queue: nil)
+    def initialize(topic:, payload:, id: nil, priority: 0, available_at: nil,
+                   attempts: 0, created_at: nil, error: nil, queue: nil)
       @id = id || SecureRandom.uuid
       @topic = topic
       @payload = payload
-      @created_at = Time.now
+      @created_at = created_at || Time.now
       @attempts = attempts
       @priority = priority
       @available_at = available_at
+      # Populated by fail()/reject() — why the job last died. Surfaces in
+      # dead_letters() so consumers can see the failure reason without
+      # trawling logs.
+      @error = error
       @status = :pending
       @queue = queue
     end
 
-    # Re-queue this message with incremented attempts.
-    # Uses the stored queue reference (set at construction time).
+    # Re-queue this message with optional delay. Always re-enqueues regardless
+    # of the retry limit — this is a manual override, distinct from the
+    # automatic fail() path. Increments attempts.
     def retry(delay_seconds: 0)
       q = @queue
       raise ArgumentError, "No queue reference — set at construction" unless q
 
-      @attempts += 1
-      @status = :pending
-      @available_at = delay_seconds > 0 ? Time.now + delay_seconds : nil
-      q.backend.enqueue(self)
+      if q.backend.respond_to?(:retry)
+        q.backend.retry(self, delay_seconds: delay_seconds)
+      else
+        @attempts += 1
+        @status = :pending
+        @available_at = delay_seconds > 0 ? Time.now + delay_seconds : nil
+        q.backend.enqueue(self)
+      end
       self
     end
 
@@ -41,10 +51,11 @@ module Tina4
         id: @id,
         topic: @topic,
         payload: @payload,
-        created_at: @created_at.iso8601,
+        created_at: @created_at.iso8601(6),
         attempts: @attempts,
         status: @status,
-        priority: @priority
+        priority: @priority,
+        error: @error
       }
       h[:available_at] = @available_at.iso8601 if @available_at
       h
@@ -58,23 +69,37 @@ module Tina4
       @attempts += 1
     end
 
-    # Mark this job as completed.
+    # Mark this job as completed. Terminal — the job is done and removed.
     def complete
       @status = :completed
+      @queue.backend.complete(self) if @queue && @queue.backend.respond_to?(:complete)
+      self
     end
 
-    # Mark this job as failed with a reason.
+    # Record a failed attempt.
+    #
+    # Increments +attempts+ and stores +reason+. If the job still has retries
+    # left (+attempts < max_retries+) it is automatically re-enqueued to the
+    # pending queue, so the next pop/consume picks it up again (after the
+    # queue's retry_backoff delay, if any). Once it has been attempted
+    # +max_retries+ times it is moved to the dead-letter store, where
+    # queue.dead_letters returns it. No manual retry_failed is required.
     def fail(reason = "")
-      @status = :failed
       @error = reason
-      @attempts += 1
+      if @queue && @queue.backend.respond_to?(:fail)
+        @queue.backend.fail(self, reason)
+        @status = @attempts >= @queue.max_retries ? :dead : :pending
+      else
+        # No backend reference — degrade to in-memory bookkeeping only.
+        @attempts += 1
+        @status = :failed
+      end
+      self
     end
 
     # Reject this job with a reason. Alias for fail().
     def reject(reason = "")
       fail(reason)
     end
-
-    attr_reader :error
   end
 end

data/lib/tina4/queue.rb

@@ -17,11 +17,14 @@ module Tina4
   #   # Or pass a backend instance directly (legacy)
   #   queue = Queue.new(topic: "tasks", backend: my_backend)
   class Queue
-    attr_reader :topic, :max_retries
+    attr_reader :topic, :max_retries, :retry_backoff
 
-    def initialize(topic:, backend: nil, max_retries: 3)
+    def initialize(topic:, backend: nil, max_retries: 3, retry_backoff: 0)
       @topic = topic
       @max_retries = max_retries
+      # Seconds to wait before a failed job is re-attempted (lite backend).
+      # Default 0 = retry on the very next pop/consume iteration.
+      @retry_backoff = retry_backoff
       @backend = resolve_backend_arg(backend)
     end
 
@@ -37,22 +40,25 @@ module Tina4
 
     # Pop the next available job. Returns Job or nil.
     def pop # -> Job|None
-      @backend.dequeue(@topic)
+      attach(@backend.dequeue(@topic))
     end
 
     # Pop up to count jobs at once. Returns a partial batch if fewer available.
     def pop_batch(count)
-      if @backend.respond_to?(:dequeue_batch)
-        @backend.dequeue_batch(@topic, count)
-      else
-        jobs = []
-        count.times do
-          job = @backend.dequeue(@topic)
-          break if job.nil?
-          jobs << job
+      jobs =
+        if @backend.respond_to?(:dequeue_batch)
+          @backend.dequeue_batch(@topic, count)
+        else
+          collected = []
+          count.times do
+            job = @backend.dequeue(@topic)
+            break if job.nil?
+            collected << job
+          end
+          collected
         end
-        jobs
-      end
+      jobs.each { |job| attach(job) }
+      jobs
     end
 
     # Clear all pending jobs from this queue's topic. Returns count removed.
@@ -157,7 +163,7 @@ module Tina4
           end
         else
           loop do
-            job = @backend.dequeue(topic)
+            job = attach(@backend.dequeue(topic))
             if job.nil?
               break if poll_interval <= 0
               sleep(poll_interval)
@@ -172,7 +178,7 @@ module Tina4
         Enumerator.new do |yielder|
           consumed = 0
           loop do
-            job = @backend.dequeue(topic)
+            job = attach(@backend.dequeue(topic))
             if job.nil?
               break if poll_interval <= 0
               sleep(poll_interval)
@@ -186,10 +192,12 @@ module Tina4
       end
     end
 
-    # Pop a specific job by ID from the queue.
-    def pop_by_id(id)
+    # Pop a specific job by ID from the queue. Searches the pending queue for
+    # the given topic (defaults to this queue's topic). Returns the matching
+    # Job (claimed/removed from the queue) or nil.
+    def pop_by_id(topic = nil, id)
       return nil unless @backend.respond_to?(:find_by_id)
-      @backend.find_by_id(@topic, id)
+      attach(@backend.find_by_id(topic || @topic, id))
     end
 
     # Get the number of messages by status.
@@ -259,12 +267,12 @@ module Tina4
     end
 
     # Resolve the default backend from env vars.
-    def self.resolve_backend(name = nil)
+    def self.resolve_backend(name = nil, max_retries: 3, retry_backoff: 0)
       chosen = name || ENV.fetch("TINA4_QUEUE_BACKEND", "file").downcase.strip
 
       case chosen.to_s
       when "lite", "file", "default"
-        Tina4::QueueBackends::LiteBackend.new
+        Tina4::QueueBackends::LiteBackend.new(max_retries: max_retries, retry_backoff: retry_backoff)
       when "rabbitmq"
         config = resolve_rabbitmq_config
         Tina4::QueueBackends::RabbitmqBackend.new(config)
@@ -281,11 +289,23 @@ module Tina4
 
     private
 
+    # Stamp the queue reference onto a popped job so job.fail / job.retry /
+    # job.complete can reach the backend. Returns the job (or nil) unchanged.
+    def attach(job)
+      job.queue = self if job
+      job
+    end
+
     def resolve_backend_arg(backend)
-      # If a backend instance is passed directly (legacy), use it
-      return backend if backend && !backend.is_a?(Symbol) && !backend.is_a?(String)
+      # If a backend instance is passed directly (legacy), use it. Best-effort
+      # propagate the queue's retry policy if the instance exposes setters.
+      if backend && !backend.is_a?(Symbol) && !backend.is_a?(String)
+        backend.max_retries = @max_retries if backend.respond_to?(:max_retries=)
+        backend.retry_backoff = @retry_backoff if backend.respond_to?(:retry_backoff=)
+        return backend
+      end
       # If a symbol or string name is passed, resolve it
-      Queue.resolve_backend(backend)
+      Queue.resolve_backend(backend, max_retries: @max_retries, retry_backoff: @retry_backoff)
     end
 
     def self.resolve_rabbitmq_config

data/lib/tina4/queue_backends/lite_backend.rb

@@ -5,10 +5,29 @@ require "time"
 
 module Tina4
   module QueueBackends
+    # File-based queue backend — JSON files on disk. Zero dependencies.
+    #
+    # Each job is stored as a separate .json file under <dir>/<topic>/.
+    # Dead-lettered jobs (those that exhausted their retries) live under the
+    # shared <dir>/dead_letter/ directory, tagged with their topic.
+    #
+    # Dequeue policy: highest priority first, ties broken oldest-first by the
+    # stored created_at (ISO-8601, so lexicographic == chronological). The
+    # file name is NOT the ordering key — the stored priority/created_at are.
     class LiteBackend
+      # Retry policy — settable so a Queue can propagate its own max_retries /
+      # retry_backoff onto a backend instance passed directly (legacy path).
+      attr_accessor :max_retries, :retry_backoff
+
       def initialize(options = {})
         @dir = options[:dir] || File.join(Dir.pwd, ".queue")
         @dead_letter_dir = File.join(@dir, "dead_letter")
+        # Retry policy. Mirrors the Python lite backend: a failed job is
+        # re-enqueued while attempts < max_retries, then dead-lettered.
+        @max_retries = options[:max_retries] || 3
+        # Seconds to delay a job's next attempt when fail() re-enqueues it.
+        # 0 (default) = retry on the very next pop/consume iteration.
+        @retry_backoff = options[:retry_backoff] || 0
         FileUtils.mkdir_p(@dir)
         FileUtils.mkdir_p(@dead_letter_dir)
         @mutex = Mutex.new
@@ -25,94 +44,85 @@ module Tina4
 
       def dequeue(topic)
         @mutex.synchronize do
-          dir = topic_path(topic)
-          return nil unless Dir.exist?(dir)
+          candidate = available_candidates(topic).first
+          return nil unless candidate
 
-          now = Time.now
-          candidates = []
+          File.delete(candidate[:file])
+          job_from_data(candidate[:data], topic)
+        end
+      end
 
-          Dir.glob(File.join(dir, "*.json")).each do |f|
-            data = JSON.parse(File.read(f))
-            # Skip messages that are not yet available (delayed)
-            if data["available_at"]
-              available_at = Time.parse(data["available_at"])
-              next if available_at > now
-            end
-            candidates << { file: f, data: data, priority: data["priority"] || 0, mtime: File.mtime(f) }
-          rescue JSON::ParserError
-            next
+      def dequeue_batch(topic, count)
+        @mutex.synchronize do
+          chosen = available_candidates(topic).first(count)
+          chosen.map do |c|
+            File.delete(c[:file])
+            job_from_data(c[:data], topic)
           end
-
-          return nil if candidates.empty?
-
-          # Sort by priority descending (higher first), then by mtime ascending (oldest first)
-          candidates.sort_by! { |c| [-c[:priority], c[:mtime]] }
-
-          chosen = candidates.first
-          File.delete(chosen[:file])
-          data = chosen[:data]
-
-          Tina4::Job.new(
-            topic: data["topic"] || topic.to_s,
-            payload: data["payload"],
-            id: data["id"],
-            priority: data["priority"] || 0,
-            available_at: data["available_at"] ? Time.parse(data["available_at"]) : nil,
-            attempts: data["attempts"] || 0
-          )
         end
       end
 
-      def dequeue_batch(topic, count)
+      # Find a specific pending job by id, claim it (delete the file) and
+      # return it. Returns nil when no pending job with that id exists.
+      def find_by_id(topic, id)
         @mutex.synchronize do
           dir = topic_path(topic)
-          return [] unless Dir.exist?(dir)
-
-          now = Time.now
-          candidates = []
+          return nil unless Dir.exist?(dir)
 
+          target = id.to_s
           Dir.glob(File.join(dir, "*.json")).each do |f|
             data = JSON.parse(File.read(f))
-            if data["available_at"]
-              available_at = Time.parse(data["available_at"])
-              next if available_at > now
-            end
-            candidates << { file: f, data: data, priority: data["priority"] || 0, mtime: File.mtime(f) }
+            next unless data["id"].to_s == target
+
+            File.delete(f)
+            return job_from_data(data, topic)
           rescue JSON::ParserError
             next
           end
-
-          return [] if candidates.empty?
-
-          candidates.sort_by! { |c| [-c[:priority], c[:mtime]] }
-          chosen = candidates.first(count)
-
-          chosen.map do |c|
-            File.delete(c[:file])
-            data = c[:data]
-            Tina4::Job.new(
-              topic: data["topic"] || topic.to_s,
-              payload: data["payload"],
-              id: data["id"],
-              priority: data["priority"] || 0,
-              available_at: data["available_at"] ? Time.parse(data["available_at"]) : nil,
-              attempts: data["attempts"] || 0
-            )
-          end
+          nil
         end
       end
 
       def acknowledge(message)
-        # File already deleted on dequeue
+        # File already deleted on dequeue — nothing to do.
+      end
+
+      def complete(message)
+        # Job file was already deleted on dequeue. complete() is terminal:
+        # the job is done and gone.
       end
 
       def requeue(message)
         enqueue(message)
       end
 
+      # Record a failed attempt. Increments attempts and stores the error.
+      # While attempts < max_retries the job is re-enqueued to pending (after
+      # the configured retry_backoff). Once attempts >= max_retries it is moved
+      # to the dead-letter store.
+      def fail(job, error = "")
+        job.attempts += 1
+        job.error = error
+        if job.attempts < @max_retries
+          requeue_job(job, delay_seconds: @retry_backoff, error: error)
+        else
+          move_to_dead_letter(job, error)
+        end
+      end
+
+      # Explicit re-queue requested by the caller (job.retry()). Always
+      # re-enqueues regardless of the retry limit — a manual override, distinct
+      # from the automatic fail() path. Increments attempts, clears the error.
+      def retry(job, delay_seconds: 0)
+        job.attempts += 1
+        requeue_job(job, delay_seconds: delay_seconds, error: nil)
+      end
+
       def dead_letter(message)
         path = File.join(@dead_letter_dir, "#{message.id}.json")
-        File.write(path, message.to_json)
+        data = message.to_hash
+        data[:status] = "dead"
+        File.write(path, JSON.generate(data))
       end
 
       def size(topic)
@@ -143,6 +153,7 @@ module Tina4
       end
 
       # Get dead letter jobs for a topic — messages that exceeded max retries.
+      # Returns Hashes (raw job data with status "dead").
       def dead_letters(topic, max_retries: 3)
         return [] unless Dir.exist?(@dead_letter_dir)
 
@@ -152,6 +163,7 @@ module Tina4
         files.each do |file|
           data = JSON.parse(File.read(file))
           next unless data["topic"] == topic.to_s
+          next if (data["attempts"] || 0) < max_retries
           data["status"] = "dead"
           jobs << data
         rescue JSON::ParserError
@@ -161,14 +173,13 @@ module Tina4
         jobs
       end
 
-      # Delete messages by status (completed, failed, dead).
-      # For 'dead', removes from the dead_letter directory.
-      # For 'failed', removes from the topic directory (re-queued failed messages).
-      # Returns the number of jobs purged.
+      # Delete messages by status. For "failed"/"dead"/"dead_letter", removes
+      # from the dead_letter directory. For "completed"/"pending", removes
+      # matching jobs from the topic (pending) directory. Returns count purged.
       def purge(topic, status)
         count = 0
 
-        if status.to_s == "dead"
+        if dead_status?(status)
           return 0 unless Dir.exist?(@dead_letter_dir)
 
           Dir.glob(File.join(@dead_letter_dir, "*.json")).each do |file|
@@ -180,13 +191,13 @@ module Tina4
           rescue JSON::ParserError
             next
           end
-        elsif status.to_s == "failed" || status.to_s == "completed" || status.to_s == "pending"
+        else
           dir = topic_path(topic)
           return 0 unless Dir.exist?(dir)
 
           Dir.glob(File.join(dir, "*.json")).each do |file|
             data = JSON.parse(File.read(file))
-            if data["status"] == status.to_s
+            if data["status"].to_s == status.to_s
               File.delete(file)
               count += 1
             end
@@ -198,7 +209,7 @@ module Tina4
         count
       end
 
-      # Re-queue failed messages (under max_retries) back to pending.
+      # Revive dead-letter jobs (under max_retries) back to pending.
       # Returns the number of jobs re-queued.
       def retry_failed(topic, max_retries: 3)
         return 0 unless Dir.exist?(@dead_letter_dir)
@@ -207,18 +218,18 @@ module Tina4
         FileUtils.mkdir_p(dir)
         count = 0
 
-        # Dead letter directory contains messages that the Consumer moved there.
-        # Only retry those whose attempts are under max_retries.
         Dir.glob(File.join(@dead_letter_dir, "*.json")).each do |file|
           data = JSON.parse(File.read(file))
           next unless data["topic"] == topic.to_s
           next if (data["attempts"] || 0) >= max_retries
 
-          data["status"] = "pending"
           msg = Tina4::Job.new(
             topic: data["topic"],
             payload: data["payload"],
-            id: data["id"]
+            id: data["id"],
+            priority: data["priority"] || 0,
+            attempts: data["attempts"] || 0,
+            error: data["error"]
           )
           enqueue(msg)
           File.delete(file)
@@ -242,14 +253,20 @@ module Tina4
         count
       end
 
-      # Get jobs that failed but are still eligible for retry (under max_retries).
+      # Jobs that have failed at least once but are still being retried.
+      #
+      # Under the auto-retry lifecycle a failed-but-retryable job lives in the
+      # pending queue (not the dead-letter dir), so this scans the topic dir
+      # for jobs with 0 < attempts < max_retries. Dead-lettered jobs are
+      # returned by dead_letters(). Returns Hashes.
       def failed(topic, max_retries: 3)
-        return [] unless Dir.exist?(@dead_letter_dir)
+        dir = topic_path(topic)
+        return [] unless Dir.exist?(dir)
         jobs = []
-        Dir.glob(File.join(@dead_letter_dir, "*.json")).sort_by { |f| File.mtime(f) }.each do |file|
+        Dir.glob(File.join(dir, "*.json")).sort_by { |f| File.mtime(f) }.each do |file|
           data = JSON.parse(File.read(file))
-          next unless data["topic"] == topic.to_s
-          next if (data["attempts"] || 0) >= max_retries
+          attempts = data["attempts"] || 0
+          next unless attempts > 0 && attempts < max_retries
           jobs << data
         rescue JSON::ParserError
           next
@@ -257,7 +274,12 @@ module Tina4
         jobs
       end
 
-      # Retry all dead letter jobs for this topic. Returns true if any were re-queued.
+      # Revive a specific dead-letter job by id back to the pending queue.
+      # When job_id is nil, revives every dead-letter for the topic.
+      #
+      # This is a manual override (Queue#retry(job_id)) — it always revives a
+      # dead-letter regardless of attempt count, mirroring job.retry. Returns
+      # true if any job was re-queued.
       def retry_job(topic, job_id: nil, delay_seconds: 0)
         return false unless Dir.exist?(@dead_letter_dir)
 
@@ -273,8 +295,10 @@ module Tina4
             topic: data["topic"],
             payload: data["payload"],
             id: data["id"],
+            priority: data["priority"] || 0,
             attempts: (data["attempts"] || 0) + 1,
-            available_at: available_at
+            available_at: available_at,
+            error: nil
           )
           enqueue(msg)
           File.delete(file)
@@ -289,6 +313,97 @@ module Tina4
 
       private
 
+      DEAD_STATES = %w[failed dead dead_letter].freeze
+
+      def dead_status?(status)
+        DEAD_STATES.include?(status.to_s)
+      end
+
+      # Return [{file:, data:}, ...] for every pending, non-delayed job in the
+      # topic, ordered by the dequeue policy: priority DESC, then created_at
+      # ASC (oldest first).
+      def available_candidates(topic)
+        dir = topic_path(topic)
+        return [] unless Dir.exist?(dir)
+
+        now = Time.now
+        candidates = []
+
+        Dir.glob(File.join(dir, "*.json")).each do |f|
+          data = JSON.parse(File.read(f))
+          # Skip messages that are not yet available (delayed).
+          if data["available_at"]
+            available_at = Time.parse(data["available_at"])
+            next if available_at > now
+          end
+          candidates << { file: f, data: data }
+        rescue JSON::ParserError
+          next
+        end
+
+        # priority DESC, then created_at ASC. created_at is an ISO-8601 string
+        # so lexicographic order == chronological order. Fall back to the file
+        # name for jobs written before created_at was persisted.
+        candidates.sort_by do |c|
+          [-(c[:data]["priority"] || 0), c[:data]["created_at"].to_s, c[:file]]
+        end
+      end
+
+      def job_from_data(data, topic)
+        Tina4::Job.new(
+          topic: data["topic"] || topic.to_s,
+          payload: data["payload"],
+          id: data["id"],
+          priority: data["priority"] || 0,
+          available_at: data["available_at"] ? Time.parse(data["available_at"]) : nil,
+          attempts: data["attempts"] || 0,
+          created_at: data["created_at"] ? Time.parse(data["created_at"]) : nil,
+          error: data["error"]
+        )
+      end
+
+      # Write the job back to the pending queue with a fresh created_at (so
+      # within a priority tier it sorts behind jobs not yet attempted) and the
+      # current attempts/error carried over.
+      def requeue_job(job, delay_seconds: 0, error: nil)
+        available_at = delay_seconds > 0 ? (Time.now + delay_seconds).iso8601(6) : nil
+        data = {
+          id: job.id,
+          topic: job.topic,
+          payload: job.payload,
+          status: "pending",
+          priority: job.priority,
+          attempts: job.attempts,
+          error: error,
+          created_at: Time.now.iso8601(6)
+        }
+        data[:available_at] = available_at if available_at
+        @mutex.synchronize do
+          topic_dir = topic_path(job.topic)
+          FileUtils.mkdir_p(topic_dir)
+          File.write(File.join(topic_dir, "#{job.id}.json"), JSON.generate(data))
+        end
+      end
+
+      # Move a failed job to the dead-letter directory. Terminal until a manual
+      # retry_failed/retry revives it.
+      def move_to_dead_letter(job, error = "")
+        data = {
+          id: job.id,
+          topic: job.topic,
+          payload: job.payload,
+          status: "dead",
+          priority: job.priority,
+          attempts: job.attempts,
+          error: error,
+          failed_at: Time.now.iso8601(6)
+        }
+        @mutex.synchronize do
+          FileUtils.mkdir_p(@dead_letter_dir)
+          File.write(File.join(@dead_letter_dir, "#{job.id}.json"), JSON.generate(data))
+        end
+      end
+
       def topic_path(topic)
         safe_topic = topic.to_s.gsub(/[^a-zA-Z0-9_-]/, "_")
         File.join(@dir, safe_topic)

data/lib/tina4/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.13.32
+  version: 3.13.33
 platform: ruby
 authors:
 - Tina4 Team