tina4ruby 0.4.0

data/lib/tina4/session_handlers/file_handler.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+require "json"
+require "fileutils"
+
+module Tina4
+  module SessionHandlers
+    class FileHandler
+      def initialize(options = {})
+        @dir = options[:dir] || File.join(Dir.pwd, "sessions")
+        @ttl = options[:ttl] || 86400
+        FileUtils.mkdir_p(@dir)
+      end
+
+      def read(session_id)
+        path = session_path(session_id)
+        return nil unless File.exist?(path)
+
+        # Check expiry
+        if File.mtime(path) + @ttl < Time.now
+          File.delete(path)
+          return nil
+        end
+
+        data = File.read(path)
+        JSON.parse(data)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def write(session_id, data)
+        path = session_path(session_id)
+        File.write(path, JSON.generate(data))
+      end
+
+      def destroy(session_id)
+        path = session_path(session_id)
+        File.delete(path) if File.exist?(path)
+      end
+
+      def cleanup
+        return unless Dir.exist?(@dir)
+        Dir.glob(File.join(@dir, "sess_*")).each do |file|
+          File.delete(file) if File.mtime(file) + @ttl < Time.now
+        end
+      end
+
+      private
+
+      def session_path(session_id)
+        safe_id = session_id.gsub(/[^a-zA-Z0-9_-]/, "")
+        File.join(@dir, "sess_#{safe_id}.json")
+      end
+    end
+  end
+end

data/lib/tina4/session_handlers/mongo_handler.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+require "json"
+
+module Tina4
+  module SessionHandlers
+    class MongoHandler
+      def initialize(options = {})
+        require "mongo"
+        @ttl = options[:ttl] || 86400
+        client = Mongo::Client.new(
+          options[:uri] || "mongodb://localhost:27017",
+          database: options[:database] || "tina4_sessions"
+        )
+        @collection = client[options[:collection] || "sessions"]
+        # Ensure TTL index
+        @collection.indexes.create_one(
+          { updated_at: 1 },
+          expire_after_seconds: @ttl
+        )
+      rescue LoadError
+        raise "MongoDB session handler requires the 'mongo' gem. Install with: gem install mongo"
+      rescue Mongo::Error => e
+        Tina4::Debug.error("MongoDB session setup failed: #{e.message}")
+      end
+
+      def read(session_id)
+        doc = @collection.find(_id: session_id).first
+        return nil unless doc
+        doc["data"]
+      end
+
+      def write(session_id, data)
+        @collection.update_one(
+          { _id: session_id },
+          { "$set" => { data: data, updated_at: Time.now } },
+          upsert: true
+        )
+      end
+
+      def destroy(session_id)
+        @collection.delete_one(_id: session_id)
+      end
+
+      def cleanup
+        # MongoDB TTL index handles cleanup
+      end
+    end
+  end
+end

data/lib/tina4/session_handlers/redis_handler.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require "json"
+
+module Tina4
+  module SessionHandlers
+    class RedisHandler
+      def initialize(options = {})
+        require "redis"
+        @prefix = options[:prefix] || "tina4:session:"
+        @ttl = options[:ttl] || 86400
+        @redis = Redis.new(
+          host: options[:host] || "localhost",
+          port: options[:port] || 6379,
+          db: options[:db] || 0,
+          password: options[:password]
+        )
+      rescue LoadError
+        raise "Redis session handler requires the 'redis' gem. Install with: gem install redis"
+      end
+
+      def read(session_id)
+        data = @redis.get("#{@prefix}#{session_id}")
+        return nil unless data
+        JSON.parse(data)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def write(session_id, data)
+        key = "#{@prefix}#{session_id}"
+        @redis.setex(key, @ttl, JSON.generate(data))
+      end
+
+      def destroy(session_id)
+        @redis.del("#{@prefix}#{session_id}")
+      end
+
+      def cleanup
+        # Redis handles TTL automatically
+      end
+    end
+  end
+end

data/lib/tina4/swagger.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+require "json"
+
+module Tina4
+  module Swagger
+    class << self
+      def generate
+        spec = base_spec
+        Tina4::Router.routes.each do |route|
+          add_route_to_spec(spec, route)
+        end
+        spec
+      end
+
+      private
+
+      def base_spec
+        {
+          "openapi" => "3.0.3",
+          "info" => {
+            "title" => ENV["PROJECT_NAME"] || "Tina4 Ruby API",
+            "version" => ENV["VERSION"] || Tina4::VERSION,
+            "description" => "Auto-generated API documentation"
+          },
+          "servers" => [
+            { "url" => "/" }
+          ],
+          "paths" => {},
+          "components" => {
+            "securitySchemes" => {
+              "bearerAuth" => {
+                "type" => "http",
+                "scheme" => "bearer",
+                "bearerFormat" => "JWT"
+              }
+            }
+          }
+        }
+      end
+
+      def add_route_to_spec(spec, route)
+        path = convert_path(route.path)
+        method = route.method.downcase
+        return if method == "any"
+
+        spec["paths"][path] ||= {}
+        operation = {
+          "summary" => route.swagger_meta[:summary] || "#{method.upcase} #{route.path}",
+          "description" => route.swagger_meta[:description] || "",
+          "tags" => route.swagger_meta[:tags] || [extract_tag(route.path)],
+          "parameters" => build_parameters(route),
+          "responses" => route.swagger_meta[:responses] || default_responses
+        }
+
+        if route.auth_handler
+          operation["security"] = [{ "bearerAuth" => [] }]
+        end
+
+        if %w[post put patch].include?(method) && route.swagger_meta[:request_body]
+          operation["requestBody"] = route.swagger_meta[:request_body]
+        elsif %w[post put patch].include?(method)
+          operation["requestBody"] = default_request_body
+        end
+
+        spec["paths"][path][method] = operation
+      end
+
+      def convert_path(path)
+        # Convert {id:int} to {id}
+        path.gsub(/\{(\w+)(?::\w+)?\}/, '{\1}')
+      end
+
+      def extract_tag(path)
+        parts = path.split("/").reject(&:empty?)
+        parts.first || "default"
+      end
+
+      def build_parameters(route)
+        params = []
+        route.param_names.each do |param|
+          params << {
+            "name" => param[:name].to_s,
+            "in" => "path",
+            "required" => true,
+            "schema" => param_schema(param[:type])
+          }
+        end
+        params
+      end
+
+      def param_schema(type)
+        case type
+        when "int", "integer"
+          { "type" => "integer" }
+        when "float", "number"
+          { "type" => "number" }
+        else
+          { "type" => "string" }
+        end
+      end
+
+      def default_responses
+        {
+          "200" => { "description" => "Successful response" },
+          "400" => { "description" => "Bad request" },
+          "401" => { "description" => "Unauthorized" },
+          "404" => { "description" => "Not found" },
+          "500" => { "description" => "Internal server error" }
+        }
+      end
+
+      def default_request_body
+        {
+          "content" => {
+            "application/json" => {
+              "schema" => { "type" => "object" }
+            }
+          }
+        }
+      end
+    end
+  end
+end