tina4 0.3.0 → 0.5.0

data/lib/tina4/database.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-require "json"
-
-module Tina4
-  class Database
-    attr_reader :driver, :driver_name, :connected
-
-    DRIVERS = {
-      "sqlite" => "Tina4::Drivers::SqliteDriver",
-      "sqlite3" => "Tina4::Drivers::SqliteDriver",
-      "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)
-      @driver = create_driver
-      @connected = false
-      connect
-    end
-
-    def connect
-      @driver.connect(@connection_string)
-      @connected = true
-      Tina4::Debug.info("Database connected: #{@driver_name}")
-    rescue => e
-      Tina4::Debug.error("Database connection failed: #{e.message}")
-      @connected = false
-    end
-
-    def close
-      @driver.close if @connected
-      @connected = false
-    end
-
-    def fetch(sql, params = [], limit: nil, skip: nil)
-      effective_sql = sql
-      if limit
-        effective_sql = @driver.apply_limit(effective_sql, limit, skip || 0)
-      end
-      rows = @driver.execute_query(effective_sql, params)
-      Tina4::DatabaseResult.new(rows, sql: effective_sql)
-    end
-
-    def fetch_one(sql, params = [])
-      result = fetch(sql, params, limit: 1)
-      result.first
-    end
-
-    def insert(table, data)
-      columns = data.keys.map(&:to_s)
-      placeholders = @driver.placeholders(columns.length)
-      sql = "INSERT INTO #{table} (#{columns.join(', ')}) VALUES (#{placeholders})"
-      @driver.execute(sql, data.values)
-      { success: true, last_id: @driver.last_insert_id }
-    end
-
-    def update(table, data, filter = {})
-      set_parts = data.keys.map { |k| "#{k} = #{@driver.placeholder}" }
-      where_parts = filter.keys.map { |k| "#{k} = #{@driver.placeholder}" }
-      sql = "UPDATE #{table} SET #{set_parts.join(', ')}"
-      sql += " WHERE #{where_parts.join(' AND ')}" unless filter.empty?
-      values = data.values + filter.values
-      @driver.execute(sql, values)
-      { success: true }
-    end
-
-    def delete(table, filter = {})
-      where_parts = filter.keys.map { |k| "#{k} = #{@driver.placeholder}" }
-      sql = "DELETE FROM #{table}"
-      sql += " WHERE #{where_parts.join(' AND ')}" unless filter.empty?
-      @driver.execute(sql, filter.values)
-      { success: true }
-    end
-
-    def execute(sql, params = [])
-      @driver.execute(sql, params)
-    end
-
-    def transaction
-      @driver.begin_transaction
-      yield self
-      @driver.commit
-    rescue => e
-      @driver.rollback
-      raise e
-    end
-
-    def tables
-      @driver.tables
-    end
-
-    def columns(table_name)
-      @driver.columns(table_name)
-    end
-
-    def table_exists?(table_name)
-      tables.any? { |t| t.downcase == table_name.to_s.downcase }
-    end
-
-    private
-
-    def detect_driver(conn)
-      case conn.to_s.downcase
-      when /\.db$/, /\.sqlite/, /sqlite/
-        "sqlite"
-      when /postgres/, /^pg:/
-        "postgres"
-      when /mysql/
-        "mysql"
-      when /mssql/, /sqlserver/
-        "mssql"
-      when /firebird/, /\.fdb$/
-        "firebird"
-      else
-        "sqlite"
-      end
-    end
-
-    def create_driver
-      klass_name = DRIVERS[@driver_name]
-      raise "Unknown database driver: #{@driver_name}" unless klass_name
-      klass = Object.const_get(klass_name)
-      klass.new
-    rescue NameError
-      raise "Driver #{klass_name} not loaded. Install the required gem."
-    end
-  end
-end

data/lib/tina4/database_result.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-require "json"
-
-module Tina4
-  class DatabaseResult
-    include Enumerable
-
-    attr_reader :records, :sql, :count
-
-    def initialize(records = [], sql: "")
-      @records = records || []
-      @sql = sql
-      @count = @records.length
-    end
-
-    def each(&block)
-      @records.each(&block)
-    end
-
-    def first
-      @records.first
-    end
-
-    def last
-      @records.last
-    end
-
-    def empty?
-      @records.empty?
-    end
-
-    def [](index)
-      @records[index]
-    end
-
-    def to_array
-      @records.map do |record|
-        record.is_a?(Hash) ? record : record.to_h
-      end
-    end
-
-    def to_json(*_args)
-      JSON.generate(to_array)
-    end
-
-    def to_csv(separator: ",", headers: true)
-      return "" if @records.empty?
-      lines = []
-      cols = @records.first.keys
-      lines << cols.join(separator) if headers
-      @records.each do |row|
-        lines << cols.map { |c| escape_csv(row[c], separator) }.join(separator)
-      end
-      lines.join("\n")
-    end
-
-    def to_paginate(page: 1, per_page: 10)
-      total = @records.length
-      total_pages = (total.to_f / per_page).ceil
-      offset = (page - 1) * per_page
-      page_records = @records[offset, per_page] || []
-      {
-        data: page_records,
-        page: page,
-        per_page: per_page,
-        total: total,
-        total_pages: total_pages,
-        has_next: page < total_pages,
-        has_prev: page > 1
-      }
-    end
-
-    def to_crud(table_name: "data", primary_key: "id", editable: true)
-      Tina4::Crud.generate_table(@records, table_name: table_name,
-                                  primary_key: primary_key, editable: editable)
-    end
-
-    private
-
-    def escape_csv(value, separator)
-      str = value.to_s
-      if str.include?(separator) || str.include?('"') || str.include?("\n")
-        "\"#{str.gsub('"', '""')}\""
-      else
-        str
-      end
-    end
-  end
-end

data/lib/tina4/debug.rb

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

data/lib/tina4/dev_reload.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Tina4
-  module DevReload
-    WATCH_EXTENSIONS = %w[.rb .twig .html .erb .scss .css .js].freeze
-    WATCH_DIRS = %w[src routes lib templates public].freeze
-    IGNORE_DIRS = %w[.git node_modules vendor logs sessions .queue .keys].freeze
-
-    class << self
-      def start(root_dir: Dir.pwd, &on_change)
-        require "listen"
-
-        dirs = WATCH_DIRS
-          .map { |d| File.join(root_dir, d) }
-          .select { |d| Dir.exist?(d) }
-
-        # Also watch root for .rb files
-        dirs << root_dir
-
-        Tina4::Debug.info("Dev reload watching: #{dirs.join(', ')}")
-
-        @listener = Listen.to(*dirs, only: /\.(#{WATCH_EXTENSIONS.map { |e| e.delete('.') }.join('|')})$/, ignore: build_ignore_regex) do |modified, added, removed|
-          changes = { modified: modified, added: added, removed: removed }
-          all_files = modified + added + removed
-          next if all_files.empty?
-
-          Tina4::Debug.info("File changes detected:")
-          modified.each { |f| Tina4::Debug.debug("  Modified: #{f}") }
-          added.each { |f| Tina4::Debug.debug("  Added: #{f}") }
-          removed.each { |f| Tina4::Debug.debug("  Removed: #{f}") }
-
-          # Reload Ruby files
-          modified.select { |f| f.end_with?(".rb") }.each do |file|
-            begin
-              load file
-              Tina4::Debug.info("Reloaded: #{file}")
-            rescue => e
-              Tina4::Debug.error("Reload failed: #{file} - #{e.message}")
-            end
-          end
-
-          # Recompile SCSS
-          scss_changes = all_files.select { |f| f.end_with?(".scss") }
-          if scss_changes.any?
-            Tina4::ScssCompiler.compile_all(root_dir)
-          end
-
-          on_change&.call(changes)
-        end
-
-        @listener.start
-        Tina4::Debug.info("Dev reload started")
-      end
-
-      def stop
-        @listener&.stop
-        Tina4::Debug.info("Dev reload stopped")
-      end
-
-      private
-
-      def build_ignore_regex
-        pattern = IGNORE_DIRS.map { |d| Regexp.escape(d) }.join("|")
-        /#{pattern}/
-      end
-    end
-  end
-end

data/lib/tina4/drivers/firebird_driver.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-module Tina4
-  module Drivers
-    class FirebirdDriver
-      attr_reader :connection
-
-      def connect(connection_string)
-        require "fb"
-        db_path = connection_string.sub(/^firebird:\/\//, "")
-        @connection = Fb::Database.new(database: db_path).connect
-      rescue LoadError
-        raise "Firebird driver requires the 'fb' gem. Install it with: gem install fb"
-      end
-
-      def close
-        @connection&.close
-      end
-
-      def execute_query(sql, params = [])
-        if params.empty?
-          @connection.query(:hash, sql)
-        else
-          @connection.query(:hash, sql, *params)
-        end.map { |row| stringify_keys(row) }
-      end
-
-      def execute(sql, params = [])
-        if params.empty?
-          @connection.execute(sql)
-        else
-          @connection.execute(sql, *params)
-        end
-      end
-
-      def last_insert_id
-        nil
-      end
-
-      def placeholder
-        "?"
-      end
-
-      def placeholders(count)
-        (["?"] * count).join(", ")
-      end
-
-      def apply_limit(sql, limit, offset = 0)
-        "SELECT FIRST #{limit} SKIP #{offset} * FROM (#{sql})"
-      end
-
-      def begin_transaction
-        @transaction = @connection.transaction
-      end
-
-      def commit
-        @transaction&.commit
-      end
-
-      def rollback
-        @transaction&.rollback
-      end
-
-      def tables
-        sql = "SELECT RDB\$RELATION_NAME FROM RDB\$RELATIONS WHERE RDB\$SYSTEM_FLAG = 0 AND RDB\$VIEW_BLR IS NULL"
-        rows = execute_query(sql)
-        rows.map { |r| (r["RDB\$RELATION_NAME"] || r["rdb\$relation_name"] || "").strip }
-      end
-
-      def columns(table_name)
-        sql = "SELECT RF.RDB\$FIELD_NAME, F.RDB\$FIELD_TYPE, RF.RDB\$NULL_FLAG, RF.RDB\$DEFAULT_SOURCE " \
-              "FROM RDB\$RELATION_FIELDS RF " \
-              "JOIN RDB\$FIELDS F ON RF.RDB\$FIELD_SOURCE = F.RDB\$FIELD_NAME " \
-              "WHERE RF.RDB\$RELATION_NAME = ?"
-        rows = execute_query(sql, [table_name.upcase])
-        rows.map do |r|
-          {
-            name: (r["RDB\$FIELD_NAME"] || r["rdb\$field_name"] || "").strip,
-            type: r["RDB\$FIELD_TYPE"] || r["rdb\$field_type"],
-            nullable: (r["RDB\$NULL_FLAG"] || r["rdb\$null_flag"]).nil?,
-            default: r["RDB\$DEFAULT_SOURCE"] || r["rdb\$default_source"],
-            primary_key: false
-          }
-        end
-      end
-
-      private
-
-      def stringify_keys(hash)
-        hash.each_with_object({}) { |(k, v), h| h[k.to_s] = v }
-      end
-    end
-  end
-end

data/lib/tina4/drivers/mssql_driver.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module Tina4
-  module Drivers
-    class MssqlDriver
-      attr_reader :connection
-
-      def connect(connection_string)
-        require "tiny_tds"
-        uri = parse_connection(connection_string)
-        @connection = TinyTds::Client.new(
-          host: uri[:host],
-          port: uri[:port] || 1433,
-          username: uri[:username],
-          password: uri[:password],
-          database: uri[:database]
-        )
-      end
-
-      def close
-        @connection&.close
-      end
-
-      def execute_query(sql, params = [])
-        effective_sql = interpolate_params(sql, params)
-        result = @connection.execute(effective_sql)
-        rows = result.each(symbolize_keys: true).to_a
-        result.cancel if result.respond_to?(:cancel)
-        rows
-      end
-
-      def execute(sql, params = [])
-        effective_sql = interpolate_params(sql, params)
-        result = @connection.execute(effective_sql)
-        result.do
-      end
-
-      def last_insert_id
-        result = @connection.execute("SELECT SCOPE_IDENTITY() AS id")
-        row = result.first
-        result.cancel if result.respond_to?(:cancel)
-        row[:id]&.to_i
-      end
-
-      def placeholder
-        "?"
-      end
-
-      def placeholders(count)
-        (["?"] * count).join(", ")
-      end
-
-      def apply_limit(sql, limit, offset = 0)
-        "#{sql} OFFSET #{offset} ROWS FETCH NEXT #{limit} ROWS ONLY"
-      end
-
-      def begin_transaction
-        @connection.execute("BEGIN TRANSACTION").do
-      end
-
-      def commit
-        @connection.execute("COMMIT").do
-      end
-
-      def rollback
-        @connection.execute("ROLLBACK").do
-      end
-
-      def tables
-        rows = execute_query("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE'")
-        rows.map { |r| r[:TABLE_NAME] || r[:table_name] }
-      end
-
-      def columns(table_name)
-        sql = "SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = ?"
-        rows = execute_query(sql, [table_name])
-        rows.map do |r|
-          {
-            name: r[:COLUMN_NAME] || r[:column_name],
-            type: r[:DATA_TYPE] || r[:data_type],
-            nullable: (r[:IS_NULLABLE] || r[:is_nullable]) == "YES",
-            default: r[:COLUMN_DEFAULT] || r[:column_default],
-            primary_key: false
-          }
-        end
-      end
-
-      private
-
-      def parse_connection(str)
-        # Format: mssql://user:pass@host:port/database
-        match = str.match(%r{(?:mssql|sqlserver)://(?:(\w+):([^@]+)@)?([^:/]+)(?::(\d+))?/(.+)})
-        if match
-          { username: match[1], password: match[2], host: match[3],
-            port: match[4]&.to_i, database: match[5] }
-        else
-          { host: "localhost", database: str }
-        end
-      end
-
-      def interpolate_params(sql, params)
-        return sql if params.empty?
-        result = sql.dup
-        params.each do |param|
-          escaped = param.is_a?(String) ? "'#{param.gsub("'", "''")}'" : param.to_s
-          result = result.sub("?", escaped)
-        end
-        result
-      end
-    end
-  end
-end

data/lib/tina4/drivers/mysql_driver.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module Tina4
-  module Drivers
-    class MysqlDriver
-      attr_reader :connection
-
-      def connect(connection_string)
-        require "mysql2"
-        uri = URI.parse(connection_string.sub(/^mysql:\/\//, "mysql2://"))
-        @connection = Mysql2::Client.new(
-          host: uri.host || "localhost",
-          port: uri.port || 3306,
-          username: uri.user,
-          password: uri.password,
-          database: uri.path&.sub("/", "")
-        )
-      end
-
-      def close
-        @connection&.close
-      end
-
-      def execute_query(sql, params = [])
-        if params.empty?
-          results = @connection.query(sql, symbolize_keys: true)
-        else
-          stmt = @connection.prepare(sql)
-          results = stmt.execute(*params, symbolize_keys: true)
-        end
-        results.to_a
-      end
-
-      def execute(sql, params = [])
-        if params.empty?
-          @connection.query(sql)
-        else
-          stmt = @connection.prepare(sql)
-          stmt.execute(*params)
-        end
-      end
-
-      def last_insert_id
-        @connection.last_id
-      end
-
-      def placeholder
-        "?"
-      end
-
-      def placeholders(count)
-        (["?"] * count).join(", ")
-      end
-
-      def apply_limit(sql, limit, offset = 0)
-        "#{sql} LIMIT #{limit} OFFSET #{offset}"
-      end
-
-      def begin_transaction
-        @connection.query("START TRANSACTION")
-      end
-
-      def commit
-        @connection.query("COMMIT")
-      end
-
-      def rollback
-        @connection.query("ROLLBACK")
-      end
-
-      def tables
-        rows = execute_query("SHOW TABLES")
-        rows.map { |r| r.values.first }
-      end
-
-      def columns(table_name)
-        rows = execute_query("DESCRIBE #{table_name}")
-        rows.map do |r|
-          {
-            name: r[:Field],
-            type: r[:Type],
-            nullable: r[:Null] == "YES",
-            default: r[:Default],
-            primary_key: r[:Key] == "PRI"
-          }
-        end
-      end
-    end
-  end
-end