tina4ruby 0.4.0

data/lib/tina4/drivers/mssql_driver.rb

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

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

data/lib/tina4/drivers/postgres_driver.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Tina4
+  module Drivers
+    class PostgresDriver
+      attr_reader :connection
+
+      def connect(connection_string)
+        require "pg"
+        @connection = PG.connect(connection_string)
+      end
+
+      def close
+        @connection&.close
+      end
+
+      def execute_query(sql, params = [])
+        converted_sql = convert_placeholders(sql)
+        result = if params.empty?
+                   @connection.exec(converted_sql)
+                 else
+                   @connection.exec_params(converted_sql, params)
+                 end
+        result.map { |row| symbolize_keys(row) }
+      end
+
+      def execute(sql, params = [])
+        converted_sql = convert_placeholders(sql)
+        if params.empty?
+          @connection.exec(converted_sql)
+        else
+          @connection.exec_params(converted_sql, params)
+        end
+      end
+
+      def last_insert_id
+        result = @connection.exec("SELECT lastval()")
+        result.first["lastval"].to_i
+      rescue PG::Error
+        nil
+      end
+
+      def placeholder
+        "?"
+      end
+
+      def placeholders(count)
+        (1..count).map { |i| "$#{i}" }.join(", ")
+      end
+
+      def apply_limit(sql, limit, offset = 0)
+        "#{sql} LIMIT #{limit} OFFSET #{offset}"
+      end
+
+      def begin_transaction
+        @connection.exec("BEGIN")
+      end
+
+      def commit
+        @connection.exec("COMMIT")
+      end
+
+      def rollback
+        @connection.exec("ROLLBACK")
+      end
+
+      def tables
+        sql = "SELECT tablename FROM pg_tables WHERE schemaname = 'public'"
+        rows = execute_query(sql)
+        rows.map { |r| r[:tablename] }
+      end
+
+      def columns(table_name)
+        sql = "SELECT column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_name = $1"
+        rows = execute_query(sql, [table_name])
+        rows.map do |r|
+          {
+            name: r[:column_name],
+            type: r[:data_type],
+            nullable: r[:is_nullable] == "YES",
+            default: r[:column_default],
+            primary_key: false
+          }
+        end
+      end
+
+      private
+
+      def convert_placeholders(sql)
+        counter = 0
+        sql.gsub("?") { counter += 1; "$#{counter}" }
+      end
+
+      def symbolize_keys(hash)
+        hash.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+      end
+    end
+  end
+end

data/lib/tina4/drivers/sqlite_driver.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Tina4
+  module Drivers
+    class SqliteDriver
+      attr_reader :connection
+
+      def connect(connection_string)
+        require "sqlite3"
+        db_path = connection_string.sub(/^sqlite:\/\//, "").sub(/^sqlite:/, "")
+        @connection = SQLite3::Database.new(db_path)
+        @connection.results_as_hash = true
+        @connection.execute("PRAGMA journal_mode=WAL")
+        @connection.execute("PRAGMA foreign_keys=ON")
+      end
+
+      def close
+        @connection&.close
+      end
+
+      def execute_query(sql, params = [])
+        results = @connection.execute(sql, params)
+        results.map { |row| symbolize_keys(row) }
+      end
+
+      def execute(sql, params = [])
+        @connection.execute(sql, params)
+      end
+
+      def last_insert_id
+        @connection.last_insert_row_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.execute("BEGIN TRANSACTION")
+      end
+
+      def commit
+        @connection.execute("COMMIT")
+      end
+
+      def rollback
+        @connection.execute("ROLLBACK")
+      end
+
+      def tables
+        rows = execute_query("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'")
+        rows.map { |r| r[:name] }
+      end
+
+      def columns(table_name)
+        rows = execute_query("PRAGMA table_info(#{table_name})")
+        rows.map do |r|
+          {
+            name: r[:name],
+            type: r[:type],
+            nullable: r[:notnull] == 0,
+            default: r[:dflt_value],
+            primary_key: r[:pk] == 1
+          }
+        end
+      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/env.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+require "digest"
+
+module Tina4
+  module Env
+    DEFAULT_ENV = {
+      "PROJECT_NAME" => "Tina4 Ruby Project",
+      "VERSION" => "1.0.0",
+      "TINA4_LANGUAGE" => "en",
+      "TINA4_DEBUG_LEVEL" => "[TINA4_LOG_ALL]",
+      "SECRET" => "tina4-secret-change-me"
+    }.freeze
+
+    class << self
+      def load(root_dir = Dir.pwd)
+        env_file = resolve_env_file(root_dir)
+        unless File.exist?(env_file)
+          create_default_env(env_file)
+        end
+        parse_env_file(env_file)
+      end
+
+      private
+
+      def resolve_env_file(root_dir)
+        environment = ENV["ENVIRONMENT"]
+        if environment && !environment.empty?
+          candidate = File.join(root_dir, ".env.#{environment}")
+          return candidate if File.exist?(candidate)
+        end
+        File.join(root_dir, ".env")
+      end
+
+      def create_default_env(path)
+        api_key = Digest::MD5.hexdigest(Time.now.to_s)
+        content = DEFAULT_ENV.map { |k, v| "#{k}=\"#{v}\"" }.join("\n")
+        content += "\nAPI_KEY=\"#{api_key}\"\n"
+        File.write(path, content)
+      end
+
+      def parse_env_file(path)
+        return unless File.exist?(path)
+        File.readlines(path).each do |line|
+          line = line.strip
+          next if line.empty? || line.start_with?("#")
+          if (match = line.match(/\A([A-Za-z_][A-Za-z0-9_]*)=["']?(.*)["']?\z/))
+            key = match[1]
+            value = match[2].gsub(/["']\z/, "")
+            ENV[key] ||= value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tina4/field_types.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Tina4
+  module FieldTypes
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def field_definitions
+        @field_definitions ||= {}
+      end
+
+      def primary_key_field
+        @primary_key_field
+      end
+
+      def table_name(name = nil)
+        if name
+          @table_name = name
+        else
+          @table_name || self.name.split("::").last.downcase + "s"
+        end
+      end
+
+      def integer_field(name, primary_key: false, auto_increment: false, nullable: true, default: nil)
+        register_field(name, :integer, primary_key: primary_key, auto_increment: auto_increment,
+                       nullable: nullable, default: default)
+      end
+
+      def string_field(name, length: 255, primary_key: false, nullable: true, default: nil)
+        register_field(name, :string, length: length, primary_key: primary_key,
+                       nullable: nullable, default: default)
+      end
+
+      def text_field(name, nullable: true, default: nil)
+        register_field(name, :text, nullable: nullable, default: default)
+      end
+
+      def float_field(name, nullable: true, default: nil)
+        register_field(name, :float, nullable: nullable, default: default)
+      end
+
+      def decimal_field(name, precision: 10, scale: 2, nullable: true, default: nil)
+        register_field(name, :decimal, precision: precision, scale: scale,
+                       nullable: nullable, default: default)
+      end
+
+      def boolean_field(name, nullable: true, default: nil)
+        register_field(name, :boolean, nullable: nullable, default: default)
+      end
+
+      def date_field(name, nullable: true, default: nil)
+        register_field(name, :date, nullable: nullable, default: default)
+      end
+
+      def datetime_field(name, nullable: true, default: nil)
+        register_field(name, :datetime, nullable: nullable, default: default)
+      end
+
+      def timestamp_field(name, nullable: true, default: nil)
+        register_field(name, :timestamp, nullable: nullable, default: default)
+      end
+
+      def blob_field(name, nullable: true, default: nil)
+        register_field(name, :blob, nullable: nullable, default: default)
+      end
+
+      def json_field(name, nullable: true, default: nil)
+        register_field(name, :json, nullable: nullable, default: default)
+      end
+
+      private
+
+      def register_field(name, type, **options)
+        field_definitions[name] = { type: type }.merge(options)
+        @primary_key_field = name if options[:primary_key]
+
+        # Define getter/setter
+        attr_accessor name
+      end
+    end
+  end
+end