tina4ruby 0.4.0

data/lib/tina4/crud.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Tina4
+  module Crud
+    class << self
+      def generate_table(records, table_name: "data", primary_key: "id", editable: true)
+        return "<p>No records found.</p>" if records.nil? || records.empty?
+
+        columns = records.first.keys
+
+        html = <<~HTML
+          <div class="table-responsive">
+          <table class="table table-striped table-hover" id="crud-#{table_name}">
+          <thead class="table-dark"><tr>
+        HTML
+
+        columns.each do |col|
+          html += "<th>#{col}</th>"
+        end
+        html += "<th>Actions</th>" if editable
+        html += "</tr></thead><tbody>"
+
+        records.each do |row|
+          pk_value = row[primary_key.to_sym] || row[primary_key.to_s]
+          html += "<tr data-id=\"#{pk_value}\">"
+          columns.each do |col|
+            value = row[col]
+            if editable
+              html += "<td contenteditable=\"true\" data-field=\"#{col}\">#{value}</td>"
+            else
+              html += "<td>#{value}</td>"
+            end
+          end
+          if editable
+            html += "<td>"
+            html += "<button class=\"btn btn-sm btn-primary me-1\" onclick=\"crudSave('#{table_name}', '#{pk_value}')\">Save</button>"
+            html += "<button class=\"btn btn-sm btn-danger\" onclick=\"crudDelete('#{table_name}', '#{pk_value}')\">Delete</button>"
+            html += "</td>"
+          end
+          html += "</tr>"
+        end
+
+        html += "</tbody></table></div>"
+
+        if editable
+          html += crud_javascript(table_name)
+        end
+
+        html
+      end
+
+      def generate_form(fields, action: "/", method: "POST", table_name: "data")
+        html = "<form action=\"#{action}\" method=\"#{method}\" class=\"needs-validation\" novalidate>"
+        html += "<input type=\"hidden\" name=\"_method\" value=\"#{method}\">" if %w[PUT PATCH DELETE].include?(method.upcase)
+
+        fields.each do |field|
+          name = field[:name]
+          type = field[:type] || :string
+          label = field[:label] || name.to_s.capitalize
+          value = field[:value] || ""
+          required = field[:required] || false
+
+          html += "<div class=\"mb-3\">"
+          html += "<label for=\"#{name}\" class=\"form-label\">#{label}</label>"
+
+          case type.to_sym
+          when :text
+            html += "<textarea class=\"form-control\" id=\"#{name}\" name=\"#{name}\" #{'required' if required}>#{value}</textarea>"
+          when :boolean
+            checked = value ? "checked" : ""
+            html += "<div class=\"form-check\">"
+            html += "<input class=\"form-check-input\" type=\"checkbox\" id=\"#{name}\" name=\"#{name}\" #{checked}>"
+            html += "</div>"
+          when :select
+            html += "<select class=\"form-select\" id=\"#{name}\" name=\"#{name}\" #{'required' if required}>"
+            (field[:options] || []).each do |opt|
+              selected = opt[:value].to_s == value.to_s ? "selected" : ""
+              html += "<option value=\"#{opt[:value]}\" #{selected}>#{opt[:label]}</option>"
+            end
+            html += "</select>"
+          when :date
+            html += "<input type=\"date\" class=\"form-control\" id=\"#{name}\" name=\"#{name}\" value=\"#{value}\" #{'required' if required}>"
+          when :integer, :number
+            html += "<input type=\"number\" class=\"form-control\" id=\"#{name}\" name=\"#{name}\" value=\"#{value}\" #{'required' if required}>"
+          else
+            html += "<input type=\"text\" class=\"form-control\" id=\"#{name}\" name=\"#{name}\" value=\"#{value}\" #{'required' if required}>"
+          end
+          html += "</div>"
+        end
+
+        html += "<button type=\"submit\" class=\"btn btn-primary\">Submit</button>"
+        html += "</form>"
+        html
+      end
+
+      private
+
+      def crud_javascript(table_name)
+        <<~JS
+          <script>
+          function crudSave(table, id) {
+            const row = document.querySelector(`tr[data-id="${id}"]`);
+            const cells = row.querySelectorAll('td[data-field]');
+            const data = {};
+            cells.forEach(cell => { data[cell.dataset.field] = cell.textContent; });
+            fetch(`/api/${table}/${id}`, {
+              method: 'PUT',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify(data)
+            }).then(r => r.json()).then(d => { alert('Saved!'); }).catch(e => alert('Error: ' + e));
+          }
+          function crudDelete(table, id) {
+            if (!confirm('Delete this record?')) return;
+            fetch(`/api/${table}/${id}`, { method: 'DELETE' })
+              .then(r => r.json())
+              .then(d => { document.querySelector(`tr[data-id="${id}"]`).remove(); })
+              .catch(e => alert('Error: ' + e));
+          }
+          </script>
+        JS
+      end
+    end
+  end
+end

data/lib/tina4/database.rb

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

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

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Convenience require for all development/optional tools.
+# Usage: require "tina4/dev"
+
+require_relative "dev_reload"
+require_relative "scss_compiler"
+require_relative "testing"
+require_relative "graphql"
+require_relative "websocket"
+require_relative "wsdl"
+require_relative "swagger"
+require_relative "seeder"
+require_relative "crud"
+require_relative "api"

data/lib/tina4/dev_reload.rb

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

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