tina4 0.3.0 → 0.5.0

data/lib/tina4/router.rb

@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-
-module Tina4
-  class Route
-    attr_reader :method, :path, :handler, :auth_handler, :swagger_meta, :path_regex, :param_names
-
-    def initialize(method, path, handler, auth_handler: nil, swagger_meta: {})
-      @method = method.to_s.upcase.freeze
-      @path = normalize_path(path).freeze
-      @handler = handler
-      @auth_handler = auth_handler
-      @swagger_meta = swagger_meta
-      @param_names = []
-      @path_regex = compile_pattern(@path)
-      @param_names.freeze
-    end
-
-    # Returns params hash if matched, false otherwise
-    def match_path(request_path)
-      match = @path_regex.match(request_path)
-      return false unless match
-
-      if @param_names.empty?
-        # Static route — no params to extract
-        {}
-      else
-        params = {}
-        @param_names.each_with_index do |param_def, i|
-          raw_value = match[i + 1]
-          params[param_def[:name]] = cast_param(raw_value, param_def[:type])
-        end
-        params
-      end
-    end
-
-    private
-
-    def normalize_path(path)
-      p = path.to_s.gsub("\\", "/")
-      p = "/#{p}" unless p.start_with?("/")
-      p = p.chomp("/") unless p == "/"
-      p
-    end
-
-    def compile_pattern(path)
-      return Regexp.new("\\A/\\z") if path == "/"
-
-      parts = path.split("/").reject(&:empty?)
-      regex_parts = parts.map do |part|
-        if part =~ /\A\{(\w+)(?::(\w+))?\}\z/
-          name = Regexp.last_match(1)
-          type = Regexp.last_match(2) || "string"
-          @param_names << { name: name.to_sym, type: type }
-          case type
-          when "int", "integer"
-            '(\d+)'
-          when "float", "number"
-            '([\d.]+)'
-          when "path"
-            '(.+)'
-          else
-            '([^/]+)'
-          end
-        else
-          Regexp.escape(part)
-        end
-      end
-      Regexp.new("\\A/#{regex_parts.join("/")}\\z")
-    end
-
-    def cast_param(value, type)
-      case type
-      when "int", "integer"
-        value.to_i
-      when "float", "number"
-        value.to_f
-      else
-        value
-      end
-    end
-  end
-
-  module Router
-    class << self
-      def routes
-        @routes ||= []
-      end
-
-      # Routes indexed by HTTP method for O(1) method lookup
-      def method_index
-        @method_index ||= Hash.new { |h, k| h[k] = [] }
-      end
-
-      def add_route(method, path, handler, auth_handler: nil, swagger_meta: {})
-        route = Route.new(method, path, handler, auth_handler: auth_handler, swagger_meta: swagger_meta)
-        routes << route
-        method_index[route.method] << route
-        Tina4::Debug.debug("Route registered: #{method.upcase} #{path}")
-        route
-      end
-
-      def find_route(path, method)
-        normalized_method = method.upcase
-        # Normalize path once (not per-route)
-        normalized_path = path.gsub("\\", "/")
-        normalized_path = "/#{normalized_path}" unless normalized_path.start_with?("/")
-        normalized_path = normalized_path.chomp("/") unless normalized_path == "/"
-
-        # Only scan routes matching this HTTP method
-        candidates = method_index[normalized_method]
-        candidates.each do |route|
-          params = route.match_path(normalized_path)
-          return [route, params] if params
-        end
-        nil
-      end
-
-      def clear!
-        @routes = []
-        @method_index = Hash.new { |h, k| h[k] = [] }
-      end
-
-      def group(prefix, auth_handler: nil, &block)
-        GroupContext.new(prefix, auth_handler).instance_eval(&block)
-      end
-    end
-
-    class GroupContext
-      def initialize(prefix, auth_handler = nil)
-        @prefix = prefix.chomp("/")
-        @auth_handler = auth_handler
-      end
-
-      %w[get post put patch delete any].each do |m|
-        define_method(m) do |path, swagger_meta: {}, &handler|
-          full_path = "#{@prefix}#{path}"
-          Tina4::Router.add_route(m, full_path, handler, auth_handler: @auth_handler, swagger_meta: swagger_meta)
-        end
-      end
-    end
-  end
-end

data/lib/tina4/scss_compiler.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-require "fileutils"
-
-module Tina4
-  module ScssCompiler
-    SCSS_DIRS = %w[src/scss scss src/styles styles].freeze
-    CSS_OUTPUT = "public/css"
-
-    class << self
-      def compile_all(root_dir = Dir.pwd)
-        output_dir = File.join(root_dir, CSS_OUTPUT)
-        FileUtils.mkdir_p(output_dir)
-
-        SCSS_DIRS.each do |dir|
-          scss_dir = File.join(root_dir, dir)
-          next unless Dir.exist?(scss_dir)
-
-          Dir.glob(File.join(scss_dir, "**/*.scss")).each do |scss_file|
-            next if File.basename(scss_file).start_with?("_") # Skip partials
-            compile_file(scss_file, output_dir, scss_dir)
-          end
-        end
-      end
-
-      def compile_file(scss_file, output_dir, base_dir)
-        relative = scss_file.sub(base_dir, "").sub(/\.scss$/, ".css")
-        css_file = File.join(output_dir, relative)
-        FileUtils.mkdir_p(File.dirname(css_file))
-
-        scss_content = File.read(scss_file)
-        css_content = compile_scss(scss_content, File.dirname(scss_file))
-        File.write(css_file, css_content)
-
-        Tina4::Debug.debug("Compiled SCSS: #{scss_file} -> #{css_file}")
-      rescue => e
-        Tina4::Debug.error("SCSS compilation failed: #{scss_file} - #{e.message}")
-      end
-
-      def compile_scss(content, base_dir)
-        # Try sassc gem first
-        begin
-          require "sassc"
-          return SassC::Engine.new(content, style: :expanded, load_paths: [base_dir]).render
-        rescue LoadError
-          # Fall through to basic compiler
-        end
-
-        # Basic SCSS to CSS conversion (handles common patterns)
-        basic_compile(content, base_dir)
-      end
-
-      private
-
-      def basic_compile(content, base_dir)
-        # Handle @import
-        content = process_imports(content, base_dir)
-
-        # Handle variables
-        variables = {}
-        content = content.gsub(/\$([a-zA-Z_][\w-]*)\s*:\s*(.+?);/) do
-          variables[Regexp.last_match(1)] = Regexp.last_match(2).strip
-          ""
-        end
-
-        # Replace variable references
-        variables.each do |name, value|
-          content = content.gsub("$#{name}", value)
-        end
-
-        # Handle nesting (basic single-level)
-        content = flatten_nesting(content)
-
-        # Handle & parent selector
-        content = content.gsub(/&/, "")
-
-        content
-      end
-
-      def process_imports(content, base_dir)
-        content.gsub(/@import\s+["'](.+?)["']\s*;/) do
-          import_path = Regexp.last_match(1)
-          candidates = [
-            File.join(base_dir, "#{import_path}.scss"),
-            File.join(base_dir, "_#{import_path}.scss"),
-            File.join(base_dir, import_path)
-          ]
-          found = candidates.find { |c| File.exist?(c) }
-          if found
-            imported = File.read(found)
-            process_imports(imported, File.dirname(found))
-          else
-            "/* import not found: #{import_path} */"
-          end
-        end
-      end
-
-      def flatten_nesting(content)
-        # Very basic nesting flattener - handles single level
-        result = ""
-        content.scan(/([^{]+)\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}/m) do |selector, body|
-          selector = selector.strip
-          # Check for nested rules
-          if body =~ /\{/
-            # Has nested content
-            props = ""
-            nested = ""
-            body.scan(/([^{;]+(?:\{[^}]*\}|;))/m) do |part_arr|
-              part = part_arr[0].strip
-              if part.include?("{")
-                # Nested rule
-                if part =~ /\A(.+?)\s*\{(.*?)\}\s*\z/m
-                  nested_sel = Regexp.last_match(1).strip
-                  nested_body = Regexp.last_match(2).strip
-                  full_sel = "#{selector} #{nested_sel}"
-                  nested += "#{full_sel} { #{nested_body} }\n"
-                end
-              else
-                props += "  #{part}\n" unless part.empty?
-              end
-            end
-            result += "#{selector} {\n#{props}}\n" unless props.strip.empty?
-            result += nested
-          else
-            result += "#{selector} {\n#{body}\n}\n"
-          end
-        end
-        result.empty? ? content : result
-      end
-    end
-  end
-end

data/lib/tina4/session.rb

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-require "securerandom"
-require "json"
-
-module Tina4
-  class Session
-    DEFAULT_OPTIONS = {
-      cookie_name: "tina4_session",
-      secret: nil,
-      max_age: 86400,
-      handler: :file,
-      handler_options: {}
-    }.freeze
-
-    attr_reader :id, :data
-
-    def initialize(env, options = {})
-      @options = DEFAULT_OPTIONS.merge(options)
-      @options[:secret] ||= ENV["SECRET"] || "tina4-default-secret"
-      @handler = create_handler
-      @id = extract_session_id(env) || SecureRandom.hex(32)
-      @data = load_session
-      @modified = false
-    end
-
-    def [](key)
-      @data[key.to_s]
-    end
-
-    def []=(key, value)
-      @data[key.to_s] = value
-      @modified = true
-    end
-
-    def delete(key)
-      @data.delete(key.to_s)
-      @modified = true
-    end
-
-    def clear
-      @data = {}
-      @modified = true
-    end
-
-    def to_hash
-      @data.dup
-    end
-
-    def save
-      return unless @modified
-      @handler.write(@id, @data)
-      @modified = false
-    end
-
-    def destroy
-      @handler.destroy(@id)
-      @data = {}
-    end
-
-    def cookie_header
-      "#{@options[:cookie_name]}=#{@id}; Path=/; HttpOnly; SameSite=Lax; Max-Age=#{@options[:max_age]}"
-    end
-
-    private
-
-    def extract_session_id(env)
-      cookie_str = env["HTTP_COOKIE"] || ""
-      cookie_str.split(";").each do |pair|
-        key, value = pair.strip.split("=", 2)
-        return value if key == @options[:cookie_name]
-      end
-      nil
-    end
-
-    def load_session
-      existing = @handler.read(@id)
-      existing || {}
-    end
-
-    def create_handler
-      case @options[:handler].to_sym
-      when :file
-        Tina4::SessionHandlers::FileHandler.new(@options[:handler_options])
-      when :redis
-        Tina4::SessionHandlers::RedisHandler.new(@options[:handler_options])
-      when :mongo, :mongodb
-        Tina4::SessionHandlers::MongoHandler.new(@options[:handler_options])
-      else
-        Tina4::SessionHandlers::FileHandler.new(@options[:handler_options])
-      end
-    end
-  end
-
-  class LazySession
-    def initialize(env, options = {})
-      @env = env
-      @options = options
-      @session = nil
-    end
-
-    def [](key)
-      ensure_loaded
-      @session[key]
-    end
-
-    def []=(key, value)
-      ensure_loaded
-      @session[key] = value
-    end
-
-    def delete(key)
-      ensure_loaded
-      @session.delete(key)
-    end
-
-    def clear
-      ensure_loaded
-      @session.clear
-    end
-
-    def save
-      @session&.save
-    end
-
-    def destroy
-      @session&.destroy
-    end
-
-    def cookie_header
-      ensure_loaded
-      @session.cookie_header
-    end
-
-    def to_hash
-      ensure_loaded
-      @session.to_hash
-    end
-
-    private
-
-    def ensure_loaded
-      @session ||= Session.new(@env, @options)
-    end
-  end
-end

data/lib/tina4/session_handlers/file_handler.rb

@@ -1,55 +0,0 @@
-# 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

@@ -1,49 +0,0 @@
-# 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

@@ -1,43 +0,0 @@
-# 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

@@ -1,123 +0,0 @@
-# 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