tina4ruby 0.5.2 → 3.0.0

data/lib/tina4/router.rb

@@ -2,14 +2,17 @@
 
 module Tina4
   class Route
-    attr_reader :method, :path, :handler, :auth_handler, :swagger_meta, :path_regex, :param_names
+    attr_reader :method, :path, :handler, :auth_handler, :swagger_meta,
+                :path_regex, :param_names, :middleware, :template
 
-    def initialize(method, path, handler, auth_handler: nil, swagger_meta: {})
+    def initialize(method, path, handler, auth_handler: nil, swagger_meta: {}, middleware: [], template: nil)
       @method = method.to_s.upcase.freeze
       @path = normalize_path(path).freeze
       @handler = handler
       @auth_handler = auth_handler
       @swagger_meta = swagger_meta
+      @middleware = middleware.freeze
+      @template = template&.freeze
       @param_names = []
       @path_regex = compile_pattern(@path)
       @param_names.freeze
@@ -17,7 +20,7 @@ module Tina4
 
     # Returns params hash if matched, false otherwise
     def match?(request_path, request_method = nil)
-      return false if request_method && @method != request_method.to_s.upcase
+      return false if request_method && @method != "ANY" && @method != request_method.to_s.upcase
       match_path(request_path)
     end
 
@@ -27,7 +30,6 @@ module Tina4
       return false unless match
 
       if @param_names.empty?
-        # Static route — no params to extract
         {}
       else
         params = {}
@@ -39,6 +41,15 @@ module Tina4
       end
     end
 
+    # Run per-route middleware chain; returns true if all pass
+    def run_middleware(request, response)
+      @middleware.each do |mw|
+        result = mw.call(request, response)
+        return false if result == false
+      end
+      true
+    end
+
     private
 
     def normalize_path(path)
@@ -53,7 +64,15 @@ module Tina4
 
       parts = path.split("/").reject(&:empty?)
       regex_parts = parts.map do |part|
-        if part =~ /\A\{(\w+)(?::(\w+))?\}\z/
+        if part =~ /\A\*(\w+)\z/
+          # Catch-all splat parameter: *path captures everything after
+          name = Regexp.last_match(1)
+          @param_names << { name: name.to_sym, type: "path" }
+          '(.+)'
+        elsif part =~ /\A\{(\w+)(?::(\w+))?\}\z/
+          # Tina4/Python-style brace params: {id} or {id:int}
+          # This is the ONLY supported param syntax, matching Python exactly.
+          # Do NOT add :id (colon) style params.
           name = Regexp.last_match(1)
           type = Regexp.last_match(2) || "string"
           @param_names << { name: name.to_sym, type: type }
@@ -97,14 +116,43 @@ module Tina4
         @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)
+      def add_route(method, path, handler, auth_handler: nil, swagger_meta: {}, middleware: [], template: nil)
+        route = Route.new(method, path, handler,
+                          auth_handler: auth_handler,
+                          swagger_meta: swagger_meta,
+                          middleware: middleware,
+                          template: template)
         routes << route
         method_index[route.method] << route
-        Tina4::Debug.debug("Route registered: #{method.upcase} #{path}")
+        Tina4::Log.debug("Route registered: #{method.upcase} #{path}")
         route
       end
 
+      # Convenience registration methods matching tina4-python pattern
+      def get(path, middleware: [], swagger_meta: {}, template: nil, &block)
+        add_route("GET", path, block, middleware: middleware, swagger_meta: swagger_meta, template: template)
+      end
+
+      def post(path, middleware: [], swagger_meta: {}, template: nil, &block)
+        add_route("POST", path, block, middleware: middleware, swagger_meta: swagger_meta, template: template)
+      end
+
+      def put(path, middleware: [], swagger_meta: {}, template: nil, &block)
+        add_route("PUT", path, block, middleware: middleware, swagger_meta: swagger_meta, template: template)
+      end
+
+      def patch(path, middleware: [], swagger_meta: {}, template: nil, &block)
+        add_route("PATCH", path, block, middleware: middleware, swagger_meta: swagger_meta, template: template)
+      end
+
+      def delete(path, middleware: [], swagger_meta: {}, template: nil, &block)
+        add_route("DELETE", path, block, middleware: middleware, swagger_meta: swagger_meta, template: template)
+      end
+
+      def any(path, middleware: [], swagger_meta: {}, template: nil, &block)
+        add_route("ANY", path, block, middleware: middleware, swagger_meta: swagger_meta, template: template)
+      end
+
       def find_route(path, method)
         normalized_method = method.upcase
         # Normalize path once (not per-route)
@@ -112,8 +160,8 @@ module Tina4
         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]
+        # Check ANY routes first, then method-specific routes
+        candidates = (method_index["ANY"] || []) + (method_index[normalized_method] || [])
         candidates.each do |route|
           params = route.match_path(normalized_path)
           return [route, params] if params
@@ -126,23 +174,50 @@ module Tina4
         @method_index = Hash.new { |h, k| h[k] = [] }
       end
 
-      def group(prefix, auth_handler: nil, &block)
-        GroupContext.new(prefix, auth_handler).instance_eval(&block)
+      def group(prefix, auth_handler: nil, middleware: [], &block)
+        GroupContext.new(prefix, auth_handler, middleware).instance_eval(&block)
+      end
+
+      # Load route files from a directory (file-based route discovery)
+      def load_routes(directory)
+        return unless Dir.exist?(directory)
+        Dir.glob(File.join(directory, "**/*.rb")).sort.each do |file|
+          begin
+            load file
+            Tina4::Log.debug("Route loaded: #{file}")
+          rescue => e
+            Tina4::Log.error("Failed to load route #{file}: #{e.message}")
+          end
+        end
       end
     end
 
     class GroupContext
-      def initialize(prefix, auth_handler = nil)
+      def initialize(prefix, auth_handler = nil, middleware = [])
         @prefix = prefix.chomp("/")
         @auth_handler = auth_handler
+        @middleware = middleware
       end
 
       %w[get post put patch delete any].each do |m|
-        define_method(m) do |path, swagger_meta: {}, &handler|
+        define_method(m) do |path, middleware: [], swagger_meta: {}, template: nil, &handler|
           full_path = "#{@prefix}#{path}"
-          Tina4::Router.add_route(m, full_path, handler, auth_handler: @auth_handler, swagger_meta: swagger_meta)
+          combined_middleware = @middleware + middleware
+          Tina4::Router.add_route(m, full_path, handler,
+                                  auth_handler: @auth_handler,
+                                  swagger_meta: swagger_meta,
+                                  middleware: combined_middleware,
+                                  template: template)
         end
       end
+
+      # Nested groups
+      def group(prefix, auth_handler: nil, middleware: [], &block)
+        full_prefix = "#{@prefix}#{prefix}"
+        combined_middleware = @middleware + middleware
+        nested_auth = auth_handler || @auth_handler
+        GroupContext.new(full_prefix, nested_auth, combined_middleware).instance_eval(&block)
+      end
     end
   end
 end

data/lib/tina4/scss_compiler.rb

@@ -31,9 +31,9 @@ module Tina4
         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}")
+        Tina4::Log.debug("Compiled SCSS: #{scss_file} -> #{css_file}")
       rescue => e
-        Tina4::Debug.error("SCSS compilation failed: #{scss_file} - #{e.message}")
+        Tina4::Log.error("SCSS compilation failed: #{scss_file} - #{e.message}")
       end
 
       def compile_scss(content, base_dir)

data/lib/tina4/seeder.rb

@@ -90,6 +90,13 @@ module Tina4
       @rng = seed ? Random.new(seed) : Random.new
     end
 
+    # Static factory — create a seeded FakeData instance.
+    #   fake = FakeData.seed(42)
+    #   fake.name  # deterministic
+    def self.seed(seed)
+      new(seed: seed)
+    end
+
     def first_name
       FIRST_NAMES[@rng.rand(FIRST_NAMES.length)]
     end
@@ -328,13 +335,13 @@ module Tina4
     table = orm_class.table_name
 
     if fields.empty?
-      Tina4::Debug.error("Seeder: No fields found on #{orm_class.name}")
+      Tina4::Log.error("Seeder: No fields found on #{orm_class.name}")
       return 0
     end
 
     db = Tina4.database
     unless db
-      Tina4::Debug.error("Seeder: No database connection. Set Tina4.database first.")
+      Tina4::Log.error("Seeder: No database connection. Set Tina4.database first.")
       return 0
     end
 
@@ -343,7 +350,7 @@ module Tina4
       begin
         result = db.fetch_one("SELECT count(*) as cnt FROM #{table}")
         if result && result[:cnt].to_i >= count
-          Tina4::Debug.info("Seeder: #{table} already has #{result[:cnt]} records, skipping")
+          Tina4::Log.info("Seeder: #{table} already has #{result[:cnt]} records, skipping")
           return 0
         end
       rescue => e
@@ -355,9 +362,9 @@ module Tina4
     if clear
       begin
         db.execute("DELETE FROM #{table}")
-        Tina4::Debug.info("Seeder: Cleared #{table}")
+        Tina4::Log.info("Seeder: Cleared #{table}")
       rescue => e
-        Tina4::Debug.warn("Seeder: Could not clear #{table}: #{e.message}")
+        Tina4::Log.warn("Seeder: Could not clear #{table}: #{e.message}")
       end
     end
 
@@ -384,14 +391,14 @@ module Tina4
         if obj.save
           inserted += 1
         else
-          Tina4::Debug.warn("Seeder: Insert failed for #{table} row #{i + 1}: #{obj.errors.join(', ')}")
+          Tina4::Log.warn("Seeder: Insert failed for #{table} row #{i + 1}: #{obj.errors.join(', ')}")
         end
       rescue => e
-        Tina4::Debug.warn("Seeder: Insert failed for #{table} row #{i + 1}: #{e.message}")
+        Tina4::Log.warn("Seeder: Insert failed for #{table} row #{i + 1}: #{e.message}")
       end
     end
 
-    Tina4::Debug.info("Seeder: Inserted #{inserted}/#{count} records into #{table}")
+    Tina4::Log.info("Seeder: Inserted #{inserted}/#{count} records into #{table}")
     inserted
   end
 
@@ -409,7 +416,7 @@ module Tina4
     db = Tina4.database
 
     unless db
-      Tina4::Debug.error("Seeder: No database connection.")
+      Tina4::Log.error("Seeder: No database connection.")
       return 0
     end
 
@@ -417,7 +424,7 @@ module Tina4
       begin
         db.execute("DELETE FROM #{table_name}")
       rescue => e
-        Tina4::Debug.warn("Seeder: Could not clear #{table_name}: #{e.message}")
+        Tina4::Log.warn("Seeder: Could not clear #{table_name}: #{e.message}")
       end
     end
 
@@ -438,63 +445,51 @@ module Tina4
         db.insert(table_name, row)
         inserted += 1
       rescue => e
-        Tina4::Debug.warn("Seeder: Insert failed for #{table_name} row #{i + 1}: #{e.message}")
+        Tina4::Log.warn("Seeder: Insert failed for #{table_name} row #{i + 1}: #{e.message}")
       end
     end
 
-    Tina4::Debug.info("Seeder: Inserted #{inserted}/#{count} records into #{table_name}")
+    Tina4::Log.info("Seeder: Inserted #{inserted}/#{count} records into #{table_name}")
     inserted
   end
 
-  # Builder class for seeding multiple ORM classes with dependency resolution.
+  # Seed multiple ORM classes in batch with optional dependency-aware clearing.
+  #
+  # @param tasks [Array<Hash>] each hash has :orm_class, :count, :overrides, :seed
+  # @param clear [Boolean] delete existing records (in reverse order) before seeding
+  # @return [Hash] { "ClassName" => inserted_count, ... }
   #
   # @example
-  #   seeder = Tina4::Seeder.new
-  #   seeder.add(User, count: 20)
-  #   seeder.add(Order, count: 100, overrides: { status: "pending" })
-  #   seeder.run(clear: true)
-  class Seeder
-    def initialize
-      @tasks = []
-    end
-
-    def add(orm_class, count: 10, overrides: {}, seed: nil)
-      @tasks << {
-        orm_class: orm_class,
-        count: count,
-        overrides: overrides,
-        seed: seed
-      }
-      self
-    end
-
-    def run(clear: false)
-      results = {}
-
-      if clear
-        @tasks.reverse_each do |task|
-          begin
-            Tina4.database&.execute("DELETE FROM #{task[:orm_class].table_name}")
-            Tina4::Debug.info("Seeder: Cleared #{task[:orm_class].table_name}")
-          rescue => e
-            Tina4::Debug.warn("Seeder: Could not clear #{task[:orm_class].table_name}: #{e.message}")
-          end
-        end
-      end
+  #   Tina4.seed_batch([
+  #     { orm_class: User, count: 20 },
+  #     { orm_class: Order, count: 100, overrides: { status: "pending" } }
+  #   ], clear: true)
+  def self.seed_batch(tasks, clear: false)
+    results = {}
 
-      @tasks.each do |task|
-        n = Tina4.seed_orm(
-          task[:orm_class],
-          count: task[:count],
-          overrides: task[:overrides],
-          clear: false,
-          seed: task[:seed]
-        )
-        results[task[:orm_class].name] = n
+    if clear
+      tasks.reverse_each do |task|
+        begin
+          Tina4.database&.execute("DELETE FROM #{task[:orm_class].table_name}")
+          Tina4::Log.info("Seeder: Cleared #{task[:orm_class].table_name}")
+        rescue => e
+          Tina4::Log.warn("Seeder: Could not clear #{task[:orm_class].table_name}: #{e.message}")
+        end
       end
+    end
 
-      results
+    tasks.each do |task|
+      n = Tina4.seed_orm(
+        task[:orm_class],
+        count: task[:count] || 10,
+        overrides: task[:overrides] || {},
+        clear: false,
+        seed: task[:seed]
+      )
+      results[task[:orm_class].name] = n
     end
+
+    results
   end
 
   # Run all seed files in the given folder.
@@ -502,7 +497,7 @@ module Tina4
   # @param seed_folder [String] path to seed files (default: "seeds")
   def self.seed(seed_folder: "seeds", clear: false)
     unless Dir.exist?(seed_folder)
-      Tina4::Debug.info("Seeder: No seeds folder found at #{seed_folder}")
+      Tina4::Log.info("Seeder: No seeds folder found at #{seed_folder}")
       return
     end
 
@@ -510,19 +505,19 @@ module Tina4
     files.reject! { |f| File.basename(f).start_with?("_") }
 
     if files.empty?
-      Tina4::Debug.info("Seeder: No seed files found in #{seed_folder}")
+      Tina4::Log.info("Seeder: No seed files found in #{seed_folder}")
       return
     end
 
-    Tina4::Debug.info("Seeder: Found #{files.length} seed file(s) in #{seed_folder}")
+    Tina4::Log.info("Seeder: Found #{files.length} seed file(s) in #{seed_folder}")
 
     files.each do |filepath|
       begin
-        Tina4::Debug.info("Seeder: Running #{File.basename(filepath)}...")
+        Tina4::Log.info("Seeder: Running #{File.basename(filepath)}...")
         load filepath
-        Tina4::Debug.info("Seeder: Completed #{File.basename(filepath)}")
+        Tina4::Log.info("Seeder: Completed #{File.basename(filepath)}")
       rescue => e
-        Tina4::Debug.error("Seeder: Failed to run #{File.basename(filepath)}: #{e.message}")
+        Tina4::Log.error("Seeder: Failed to run #{File.basename(filepath)}: #{e.message}")
       end
     end
   end