tina4 0.3.0 → 0.5.0

data/lib/tina4/queue_backends/lite_backend.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-require "json"
-require "fileutils"
-
-module Tina4
-  module QueueBackends
-    class LiteBackend
-      def initialize(options = {})
-        @dir = options[:dir] || File.join(Dir.pwd, ".queue")
-        @dead_letter_dir = File.join(@dir, "dead_letter")
-        FileUtils.mkdir_p(@dir)
-        FileUtils.mkdir_p(@dead_letter_dir)
-        @mutex = Mutex.new
-      end
-
-      def enqueue(message)
-        @mutex.synchronize do
-          topic_dir = topic_path(message.topic)
-          FileUtils.mkdir_p(topic_dir)
-          path = File.join(topic_dir, "#{message.id}.json")
-          File.write(path, message.to_json)
-        end
-      end
-
-      def dequeue(topic)
-        @mutex.synchronize do
-          dir = topic_path(topic)
-          return nil unless Dir.exist?(dir)
-
-          files = Dir.glob(File.join(dir, "*.json")).sort_by { |f| File.mtime(f) }
-          return nil if files.empty?
-
-          file = files.first
-          data = JSON.parse(File.read(file))
-          File.delete(file)
-
-          Tina4::QueueMessage.new(
-            topic: data["topic"],
-            payload: data["payload"],
-            id: data["id"]
-          )
-        end
-      end
-
-      def acknowledge(message)
-        # File already deleted on dequeue
-      end
-
-      def requeue(message)
-        enqueue(message)
-      end
-
-      def dead_letter(message)
-        path = File.join(@dead_letter_dir, "#{message.id}.json")
-        File.write(path, message.to_json)
-      end
-
-      def size(topic)
-        dir = topic_path(topic)
-        return 0 unless Dir.exist?(dir)
-        Dir.glob(File.join(dir, "*.json")).length
-      end
-
-      def topics
-        return [] unless Dir.exist?(@dir)
-        Dir.children(@dir)
-           .reject { |d| d == "dead_letter" }
-           .select { |d| File.directory?(File.join(@dir, d)) }
-      end
-
-      private
-
-      def topic_path(topic)
-        safe_topic = topic.to_s.gsub(/[^a-zA-Z0-9_-]/, "_")
-        File.join(@dir, safe_topic)
-      end
-    end
-  end
-end

data/lib/tina4/queue_backends/rabbitmq_backend.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module Tina4
-  module QueueBackends
-    class RabbitmqBackend
-      def initialize(options = {})
-        require "bunny"
-        @connection = Bunny.new(
-          host: options[:host] || "localhost",
-          port: options[:port] || 5672,
-          username: options[:username] || "guest",
-          password: options[:password] || "guest",
-          vhost: options[:vhost] || "/"
-        )
-        @connection.start
-        @channel = @connection.create_channel
-        @queues = {}
-        @exchanges = {}
-      rescue LoadError
-        raise "RabbitMQ backend requires the 'bunny' gem. Install with: gem install bunny"
-      end
-
-      def enqueue(message)
-        queue = get_queue(message.topic)
-        queue.publish(message.to_json, persistent: true)
-      end
-
-      def dequeue(topic)
-        queue = get_queue(topic)
-        delivery_info, _properties, payload = queue.pop
-        return nil unless payload
-
-        data = JSON.parse(payload)
-        msg = Tina4::QueueMessage.new(
-          topic: data["topic"],
-          payload: data["payload"],
-          id: data["id"]
-        )
-        @last_delivery_tag = delivery_info.delivery_tag
-        msg
-      end
-
-      def acknowledge(_message)
-        @channel.acknowledge(@last_delivery_tag) if @last_delivery_tag
-      end
-
-      def requeue(message)
-        enqueue(message)
-      end
-
-      def dead_letter(message)
-        dlq = get_queue("#{message.topic}.dead_letter")
-        dlq.publish(message.to_json, persistent: true)
-      end
-
-      def size(topic)
-        queue = get_queue(topic)
-        queue.message_count
-      end
-
-      def close
-        @channel&.close
-        @connection&.close
-      end
-
-      private
-
-      def get_queue(topic)
-        @queues[topic] ||= @channel.queue(topic, durable: true)
-      end
-    end
-  end
-end

data/lib/tina4/rack_app.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-require "json"
-
-module Tina4
-  class RackApp
-    STATIC_DIRS = %w[public src/public src/assets assets].freeze
-
-    # Pre-built frozen responses for zero-allocation fast paths
-    CORS_HEADERS = {
-      "access-control-allow-origin" => "*",
-      "access-control-allow-methods" => "GET, POST, PUT, PATCH, DELETE, OPTIONS",
-      "access-control-allow-headers" => "Content-Type, Authorization, Accept",
-      "access-control-max-age" => "86400"
-    }.freeze
-
-    OPTIONS_RESPONSE = [204, CORS_HEADERS, [""]].freeze
-
-    def initialize(root_dir: Dir.pwd)
-      @root_dir = root_dir
-      # Pre-compute static roots at boot (not per-request)
-      @static_roots = STATIC_DIRS.map { |d| File.join(root_dir, d) }
-                                  .select { |d| Dir.exist?(d) }
-                                  .freeze
-    end
-
-    def call(env)
-      method = env["REQUEST_METHOD"]
-      path = env["PATH_INFO"] || "/"
-
-      # Fast-path: OPTIONS preflight (zero allocation)
-      return OPTIONS_RESPONSE if method == "OPTIONS"
-
-      # Fast-path: API routes skip static file + swagger checks entirely
-      unless path.start_with?("/api/")
-        # Swagger
-        if path == "/swagger" || path == "/swagger/"
-          return serve_swagger_ui
-        end
-        if path == "/swagger/openapi.json"
-          return serve_openapi_json
-        end
-
-        # Static files (only for non-API paths)
-        static_response = try_static(path)
-        return static_response if static_response
-      end
-
-      # Route matching
-      result = Tina4::Router.find_route(path, method)
-      if result
-        route, path_params = result
-        handle_route(env, route, path_params)
-      else
-        handle_404(path)
-      end
-    rescue => e
-      handle_500(e)
-    end
-
-    private
-
-    def handle_route(env, route, path_params)
-      # Auth check
-      if route.auth_handler
-        auth_result = route.auth_handler.call(env)
-        return handle_403 unless auth_result
-      end
-
-      request = Tina4::Request.new(env, path_params)
-      response = Tina4::Response.new
-
-      # Execute handler
-      result = route.handler.call(request, response)
-
-      # Skip auto_detect if handler already returned the response object
-      final_response = result.equal?(response) ? result : Tina4::Response.auto_detect(result, response)
-      final_response.to_rack
-    end
-
-    def try_static(path)
-      return nil if path.include?("..")
-
-      @static_roots.each do |root|
-        full_path = File.join(root, path)
-        if File.file?(full_path)
-          return serve_static_file(full_path)
-        end
-
-        # Only try index.html for directory-like paths
-        if path.end_with?("/") || !path.include?(".")
-          index_path = File.join(full_path, "index.html")
-          if File.file?(index_path)
-            return serve_static_file(index_path)
-          end
-        end
-      end
-      nil
-    end
-
-    def serve_static_file(full_path)
-      ext = File.extname(full_path).downcase
-      content_type = Tina4::Response::MIME_TYPES[ext] || "application/octet-stream"
-      [200, { "content-type" => content_type }, [File.binread(full_path)]]
-    end
-
-    def serve_swagger_ui
-      html = <<~HTML
-        <!DOCTYPE html>
-        <html lang="en">
-        <head>
-          <meta charset="UTF-8">
-          <title>API Documentation</title>
-          <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui.css">
-        </head>
-        <body>
-          <div id="swagger-ui"></div>
-          <script src="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js"></script>
-          <script>
-            SwaggerUIBundle({ url: '/swagger/openapi.json', dom_id: '#swagger-ui' });
-          </script>
-        </body>
-        </html>
-      HTML
-      [200, { "content-type" => "text/html; charset=utf-8" }, [html]]
-    end
-
-    def serve_openapi_json
-      spec = Tina4::Swagger.generate
-      [200, { "content-type" => "application/json; charset=utf-8" }, [JSON.generate(spec)]]
-    end
-
-    def handle_403
-      body = Tina4::Template.render_error(403) rescue "403 Forbidden"
-      [403, { "content-type" => "text/html" }, [body]]
-    end
-
-    def handle_404(path)
-      Tina4::Debug.warning("404 Not Found: #{path}")
-      body = Tina4::Template.render_error(404) rescue "404 Not Found"
-      [404, { "content-type" => "text/html" }, [body]]
-    end
-
-    def handle_500(error)
-      Tina4::Debug.error("500 Internal Server Error: #{error.message}")
-      Tina4::Debug.error(error.backtrace&.first(10)&.join("\n"))
-      body = Tina4::Template.render_error(500) rescue "500 Internal Server Error: #{error.message}"
-      [500, { "content-type" => "text/html" }, [body]]
-    end
-  end
-end

data/lib/tina4/request.rb

@@ -1,158 +0,0 @@
-# frozen_string_literal: true
-require "uri"
-require "json"
-
-module Tina4
-  class Request
-    attr_reader :env, :method, :path, :query_string, :content_type,
-                :path_params, :ip
-
-    def initialize(env, path_params = {})
-      @env = env
-      @method = env["REQUEST_METHOD"]
-      @path = env["PATH_INFO"] || "/"
-      @query_string = env["QUERY_STRING"] || ""
-      @content_type = env["CONTENT_TYPE"] || ""
-      @ip = env["REMOTE_ADDR"] || "127.0.0.1"
-      @path_params = path_params
-
-      # Lazy-initialized fields (nil = not yet computed)
-      @headers = nil
-      @cookies = nil
-      @session = nil
-      @body = nil
-      @params = nil
-      @files = nil
-      @json_body = nil
-    end
-
-    # Lazy accessors — only compute when needed
-    def headers
-      @headers ||= extract_headers
-    end
-
-    def cookies
-      @cookies ||= parse_cookies
-    end
-
-    def session
-      @session ||= @env["tina4.session"] || {}
-    end
-
-    def body
-      @body ||= read_body
-    end
-
-    def files
-      @files ||= extract_files
-    end
-
-    def params
-      @params ||= build_params
-    end
-
-    def [](key)
-      params[key.to_s] || params[key.to_sym] || @path_params[key.to_sym]
-    end
-
-    def header(name)
-      headers[name.to_s.downcase.gsub("-", "_")]
-    end
-
-    def json_body
-      @json_body ||= begin
-        JSON.parse(body)
-      rescue JSON::ParserError, TypeError
-        {}
-      end
-    end
-
-    def bearer_token
-      auth = header("authorization") || ""
-      auth.sub(/\ABearer\s+/i, "") if auth =~ /\ABearer\s+/i
-    end
-
-    private
-
-    def extract_headers
-      h = {}
-      @env.each do |key, value|
-        if key.start_with?("HTTP_")
-          h[key[5..].downcase] = value
-        end
-      end
-      h
-    end
-
-    def parse_cookies
-      cookie_str = @env["HTTP_COOKIE"]
-      return {} unless cookie_str && !cookie_str.empty?
-
-      result = {}
-      cookie_str.split(";").each do |pair|
-        key, value = pair.strip.split("=", 2)
-        result[key] = value if key
-      end
-      result
-    end
-
-    def read_body
-      input = @env["rack.input"]
-      return "" unless input
-      input.rewind if input.respond_to?(:rewind)
-      data = input.read || ""
-      input.rewind if input.respond_to?(:rewind)
-      data
-    end
-
-    def build_params
-      p = {}
-
-      # Query string params
-      parse_query_string(@query_string, p) unless @query_string.empty?
-
-      # Body params
-      if @content_type.include?("application/json")
-        json_body.each { |k, v| p[k.to_s] = v }
-      elsif @content_type.include?("application/x-www-form-urlencoded")
-        parse_query_string(body, p)
-      end
-
-      # Path params (highest priority)
-      @path_params.each { |k, v| p[k.to_s] = v }
-      p
-    end
-
-    def parse_query_string(qs, target = {})
-      return target if qs.nil? || qs.empty?
-      qs.split("&").each do |pair|
-        key, value = pair.split("=", 2)
-        target[URI.decode_www_form_component(key.to_s)] = URI.decode_www_form_component(value.to_s)
-      end
-      target
-    end
-
-    def extract_files
-      result = {}
-      return result unless @content_type.include?("multipart/form-data")
-      begin
-        form_hash = @env["rack.request.form_hash"]
-        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
-              }
-            end
-          end
-        end
-      rescue StandardError
-        # Multipart parsing failed
-      end
-      result
-    end
-  end
-end

data/lib/tina4/response.rb

@@ -1,172 +0,0 @@
-# frozen_string_literal: true
-require "json"
-require "uri"
-
-module Tina4
-  class Response
-    MIME_TYPES = {
-      ".html" => "text/html", ".htm" => "text/html",
-      ".css" => "text/css", ".js" => "application/javascript",
-      ".json" => "application/json", ".xml" => "application/xml",
-      ".txt" => "text/plain", ".csv" => "text/csv",
-      ".png" => "image/png", ".jpg" => "image/jpeg",
-      ".jpeg" => "image/jpeg", ".gif" => "image/gif",
-      ".svg" => "image/svg+xml", ".ico" => "image/x-icon",
-      ".webp" => "image/webp", ".pdf" => "application/pdf",
-      ".zip" => "application/zip", ".woff" => "font/woff",
-      ".woff2" => "font/woff2", ".ttf" => "font/ttf",
-      ".eot" => "application/vnd.ms-fontobject",
-      ".mp3" => "audio/mpeg", ".mp4" => "video/mp4",
-      ".webm" => "video/webm"
-    }.freeze
-
-    # Pre-frozen header values
-    JSON_CONTENT_TYPE = "application/json; charset=utf-8"
-    HTML_CONTENT_TYPE = "text/html; charset=utf-8"
-    TEXT_CONTENT_TYPE = "text/plain; charset=utf-8"
-    XML_CONTENT_TYPE  = "application/xml; charset=utf-8"
-
-    attr_accessor :status, :headers, :body, :cookies
-
-    def initialize
-      @status = 200
-      @headers = { "content-type" => HTML_CONTENT_TYPE }
-      @body = ""
-      @cookies = nil  # Lazy — most responses have no cookies
-    end
-
-    def json(data, status_or_opts = nil, status: nil)
-      @status = status || (status_or_opts.is_a?(Integer) ? status_or_opts : 200)
-      @headers["content-type"] = JSON_CONTENT_TYPE
-      @body = data.is_a?(String) ? data : JSON.generate(data)
-      self
-    end
-
-    def html(content, status_or_opts = nil, status: nil)
-      @status = status || (status_or_opts.is_a?(Integer) ? status_or_opts : 200)
-      @headers["content-type"] = HTML_CONTENT_TYPE
-      @body = content.to_s
-      self
-    end
-
-    def text(content, status_or_opts = nil, status: nil)
-      @status = status || (status_or_opts.is_a?(Integer) ? status_or_opts : 200)
-      @headers["content-type"] = TEXT_CONTENT_TYPE
-      @body = content.to_s
-      self
-    end
-
-    def xml(content, status: 200)
-      @status = status
-      @headers["content-type"] = XML_CONTENT_TYPE
-      @body = content.to_s
-      self
-    end
-
-    def csv(content, filename: "export.csv", status: 200)
-      @status = status
-      @headers["content-type"] = "text/csv"
-      @headers["content-disposition"] = "attachment; filename=\"#{filename}\""
-      @body = content.to_s
-      self
-    end
-
-    def redirect(url, status: 302)
-      @status = status
-      @headers["location"] = url
-      @body = ""
-      self
-    end
-
-    def file(path, content_type: nil, download: false)
-      unless ::File.exist?(path)
-        @status = 404
-        @body = "File not found"
-        return self
-      end
-      ext = ::File.extname(path).downcase
-      @headers["content-type"] = content_type || MIME_TYPES[ext] || "application/octet-stream"
-      if download
-        @headers["content-disposition"] = "attachment; filename=\"#{::File.basename(path)}\""
-      end
-      @body = ::File.binread(path)
-      self
-    end
-
-    def render(template_path, data = {}, status: 200)
-      @status = status
-      @headers["content-type"] = HTML_CONTENT_TYPE
-      @body = Tina4::Template.render(template_path, data)
-      self
-    end
-
-    def set_cookie(name, value, opts = {})
-      cookie = "#{name}=#{URI.encode_www_form_component(value)}"
-      cookie += "; Path=#{opts[:path] || '/'}"
-      cookie += "; HttpOnly" if opts.fetch(:http_only, true)
-      cookie += "; Secure" if opts[:secure]
-      cookie += "; SameSite=#{opts[:same_site] || 'Lax'}"
-      cookie += "; Max-Age=#{opts[:max_age]}" if opts[:max_age]
-      cookie += "; Expires=#{opts[:expires].httpdate}" if opts[:expires]
-      @cookies ||= []
-      @cookies << cookie
-      self
-    end
-
-    def delete_cookie(name, path: "/")
-      set_cookie(name, "", max_age: 0, path: path)
-    end
-
-    def add_header(key, value)
-      @headers[key] = value
-      self
-    end
-
-    def add_cors_headers(origin: "*", methods: "GET, POST, PUT, PATCH, DELETE, OPTIONS",
-                         headers_list: "Content-Type, Authorization, Accept", credentials: false)
-      @headers["access-control-allow-origin"] = origin
-      @headers["access-control-allow-methods"] = methods
-      @headers["access-control-allow-headers"] = headers_list
-      @headers["access-control-allow-credentials"] = "true" if credentials
-      @headers["access-control-max-age"] = "86400"
-      self
-    end
-
-    def to_rack
-      # Fast path: no cookies (99% of API responses)
-      if @cookies.nil? || @cookies.empty?
-        return [@status, @headers, [@body.to_s]]
-      end
-
-      # Cookie path
-      final_headers = @headers.dup
-      final_headers["set-cookie"] = @cookies.join("\n")
-      [@status, final_headers, [@body.to_s]]
-    end
-
-    def self.auto_detect(result, response)
-      case result
-      when Tina4::Response
-        result
-      when Hash, Array
-        response.json(result)
-      when String
-        if result.start_with?("<")
-          response.html(result)
-        else
-          response.text(result)
-        end
-      when Integer
-        response.status = result
-        response.body = ""
-        response
-      when NilClass
-        response.status = 204
-        response.body = ""
-        response
-      else
-        response.json(result.respond_to?(:to_hash) ? result.to_hash : { data: result.to_s })
-      end
-    end
-  end
-end