tina4ruby 0.5.2 → 3.0.0

data/lib/tina4/database/sqlite3_adapter.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Tina4
+  module Adapters
+    class Sqlite3Adapter
+      attr_reader :connection, :db_path
+
+      def initialize(connection_string = nil)
+        @connection = nil
+        @db_path = nil
+        @in_transaction = false
+        connect(connection_string) if connection_string
+      end
+
+      def connect(connection_string)
+        require "sqlite3"
+        @db_path = connection_string.to_s.sub(/^sqlite3?:\/\//, "").sub(/^sqlite3?:/, "")
+        @connection = SQLite3::Database.new(@db_path)
+        @connection.results_as_hash = true
+        @connection.execute("PRAGMA journal_mode=WAL")
+        @connection.execute("PRAGMA foreign_keys=ON")
+        self
+      end
+
+      def close
+        @connection.close if @connection
+        @connection = nil
+      end
+
+      def connected?
+        !@connection.nil? && !@connection.closed?
+      end
+
+      # Execute a query and return rows as array of symbol-keyed hashes
+      def query(sql, params = [])
+        results = @connection.execute(sql, params)
+        results.map { |row| symbolize_keys(row) }
+      end
+
+      # Paginated fetch
+      def fetch(sql, limit = nil, offset = nil)
+        effective_sql = sql
+        if limit
+          effective_sql = "#{sql} LIMIT #{limit}"
+          effective_sql += " OFFSET #{offset}" if offset && offset > 0
+        end
+        query(effective_sql)
+      end
+
+      # Execute DDL or DML without returning rows
+      def exec(sql, params = [])
+        @connection.execute(sql, params)
+        { affected_rows: @connection.changes }
+      end
+
+      # Check if a table exists
+      def table_exists?(table)
+        rows = query(
+          "SELECT name FROM sqlite_master WHERE type='table' AND name = ?",
+          [table.to_s]
+        )
+        !rows.empty?
+      end
+
+      # Get column metadata for a table
+      def columns(table)
+        query("PRAGMA table_info(#{table})").map do |r|
+          {
+            name: r[:name],
+            type: r[:type],
+            nullable: r[:notnull] == 0,
+            default: r[:dflt_value],
+            primary_key: r[:pk] == 1
+          }
+        end
+      end
+
+      # List all user tables
+      def tables
+        rows = query("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'")
+        rows.map { |r| r[:name] }
+      end
+
+      # Get last inserted row id
+      def last_insert_id
+        @connection.last_insert_row_id
+      end
+
+      # Transaction support
+      def begin_transaction
+        return if @in_transaction
+        @connection.execute("BEGIN TRANSACTION")
+        @in_transaction = true
+      end
+
+      def commit
+        return unless @in_transaction
+        @connection.execute("COMMIT")
+        @in_transaction = false
+      end
+
+      def rollback
+        return unless @in_transaction
+        @connection.execute("ROLLBACK")
+        @in_transaction = false
+      end
+
+      def transaction
+        begin_transaction
+        yield self
+        commit
+      rescue => e
+        rollback
+        raise e
+      end
+
+      # Convenience: placeholder for parameterized queries
+      def placeholder
+        "?"
+      end
+
+      def placeholders(count)
+        (["?"] * count).join(", ")
+      end
+
+      def apply_limit(sql, limit, offset = 0)
+        "#{sql} LIMIT #{limit} OFFSET #{offset}"
+      end
+
+      private
+
+      def symbolize_keys(hash)
+        hash.each_with_object({}) do |(k, v), h|
+          h[k.to_s.to_sym] = v if k.is_a?(String) || k.is_a?(Symbol)
+        end
+      end
+    end
+  end
+end

data/lib/tina4/database.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require "json"
+require "uri"
 
 module Tina4
   class Database
@@ -11,26 +12,27 @@ module Tina4
       "postgres" => "Tina4::Drivers::PostgresDriver",
       "postgresql" => "Tina4::Drivers::PostgresDriver",
       "mysql" => "Tina4::Drivers::MysqlDriver",
-      "mysql2" => "Tina4::Drivers::MysqlDriver",
       "mssql" => "Tina4::Drivers::MssqlDriver",
       "sqlserver" => "Tina4::Drivers::MssqlDriver",
       "firebird" => "Tina4::Drivers::FirebirdDriver"
     }.freeze
 
-    def initialize(connection_string, driver_name: nil)
-      @connection_string = connection_string
-      @driver_name = driver_name || detect_driver(connection_string)
+    def initialize(connection_string = nil, username: nil, password: nil, driver_name: nil)
+      @connection_string = connection_string || ENV["DATABASE_URL"]
+      @username = username || ENV["DATABASE_USERNAME"]
+      @password = password || ENV["DATABASE_PASSWORD"]
+      @driver_name = driver_name || detect_driver(@connection_string)
       @driver = create_driver
       @connected = false
       connect
     end
 
     def connect
-      @driver.connect(@connection_string)
+      @driver.connect(@connection_string, username: @username, password: @password)
       @connected = true
-      Tina4::Debug.info("Database connected: #{@driver_name}")
+      Tina4::Log.info("Database connected: #{@driver_name}")
     rescue => e
-      Tina4::Debug.error("Database connection failed: #{e.message}")
+      Tina4::Log.error("Database connection failed: #{e.message}")
       @connected = false
     end
 
@@ -54,6 +56,16 @@ module Tina4
     end
 
     def insert(table, data)
+      # List of hashes — batch insert
+      if data.is_a?(Array)
+        return { success: true, affected_rows: 0 } if data.empty?
+        keys = data.first.keys.map(&:to_s)
+        placeholders = @driver.placeholders(keys.length)
+        sql = "INSERT INTO #{table} (#{keys.join(', ')}) VALUES (#{placeholders})"
+        params_list = data.map { |row| keys.map { |k| row[k.to_sym] || row[k] } }
+        return execute_many(sql, params_list)
+      end
+
       columns = data.keys.map(&:to_s)
       placeholders = @driver.placeholders(columns.length)
       sql = "INSERT INTO #{table} (#{columns.join(', ')}) VALUES (#{placeholders})"
@@ -72,6 +84,21 @@ module Tina4
     end
 
     def delete(table, filter = {})
+      # List of hashes — delete each row
+      if filter.is_a?(Array)
+        filter.each { |row| delete(table, row) }
+        return { success: true }
+      end
+
+      # String filter — raw WHERE clause
+      if filter.is_a?(String)
+        sql = "DELETE FROM #{table}"
+        sql += " WHERE #{filter}" unless filter.empty?
+        @driver.execute(sql)
+        return { success: true }
+      end
+
+      # Hash filter — build WHERE from keys
       where_parts = filter.keys.map { |k| "#{k} = #{@driver.placeholder}" }
       sql = "DELETE FROM #{table}"
       sql += " WHERE #{where_parts.join(' AND ')}" unless filter.empty?
@@ -83,6 +110,15 @@ module Tina4
       @driver.execute(sql, params)
     end
 
+    def execute_many(sql, params_list = [])
+      total_affected = 0
+      params_list.each do |params|
+        @driver.execute(sql, params)
+        total_affected += 1
+      end
+      { success: true, affected_rows: total_affected }
+    end
+
     def transaction
       @driver.begin_transaction
       yield self

data/lib/tina4/debug.rb

@@ -1,83 +1,8 @@
 # frozen_string_literal: true
-require "logger"
-require "fileutils"
 
-module Tina4
-  module Debug
-    LEVELS = {
-      "[TINA4_LOG_ALL]" => Logger::DEBUG,
-      "[TINA4_LOG_DEBUG]" => Logger::DEBUG,
-      "[TINA4_LOG_INFO]" => Logger::INFO,
-      "[TINA4_LOG_WARNING]" => Logger::WARN,
-      "[TINA4_LOG_ERROR]" => Logger::ERROR,
-      "[TINA4_LOG_NONE]" => Logger::FATAL
-    }.freeze
-
-    COLORS = {
-      reset: "\e[0m", red: "\e[31m", green: "\e[32m",
-      yellow: "\e[33m", blue: "\e[34m", magenta: "\e[35m",
-      cyan: "\e[36m", gray: "\e[90m"
-    }.freeze
-
-    class << self
-      def setup(root_dir = Dir.pwd)
-        log_dir = File.join(root_dir, "logs")
-        FileUtils.mkdir_p(log_dir)
-        log_file = File.join(log_dir, "debug.log")
-        @file_logger = Logger.new(log_file, 10, 5 * 1024 * 1024)
-        @file_logger.level = Logger::DEBUG
-        @console_logger = Logger.new($stdout)
-        @console_logger.level = resolve_level
-        @console_logger.formatter = method(:color_formatter)
-        @file_logger.formatter = method(:plain_formatter)
-        @initialized = true
-      end
-
-      def info(message, *args)
-        log(:info, message, *args)
-      end
-
-      def debug(message, *args)
-        log(:debug, message, *args)
-      end
-
-      def warning(message, *args)
-        log(:warn, message, *args)
-      end
+# Backward compatibility: Tina4::Debug is now Tina4::Log
+require_relative "log"
 
-      def error(message, *args)
-        log(:error, message, *args)
-      end
-
-      private
-
-      def log(level, message, *args)
-        setup unless @initialized
-        full_message = args.empty? ? message.to_s : "#{message} #{args.map(&:to_s).join(' ')}"
-        @console_logger.send(level, full_message)
-        @file_logger.send(level, full_message)
-      end
-
-      def resolve_level
-        env_level = ENV["TINA4_DEBUG_LEVEL"] || "[TINA4_LOG_ALL]"
-        LEVELS[env_level] || Logger::DEBUG
-      end
-
-      def color_formatter(severity, datetime, _progname, message)
-        color = case severity
-                when "DEBUG" then COLORS[:gray]
-                when "INFO"  then COLORS[:green]
-                when "WARN"  then COLORS[:yellow]
-                when "ERROR" then COLORS[:red]
-                else COLORS[:reset]
-                end
-        ts = datetime.strftime("%Y-%m-%d %H:%M:%S")
-        "#{COLORS[:gray]}[#{ts}]#{COLORS[:reset]} #{color}[#{severity}]#{COLORS[:reset]} #{message}\n"
-      end
-
-      def plain_formatter(severity, datetime, _progname, message)
-        "[#{datetime.strftime('%Y-%m-%d %H:%M:%S')}] [#{severity}] #{message}\n"
-      end
-    end
-  end
+module Tina4
+  Debug = Log
 end