tina4 0.2.0

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

data/lib/tina4/localization.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+require "json"
+
+module Tina4
+  module Localization
+    LOCALE_DIRS = %w[locales translations i18n src/locales].freeze
+
+    class << self
+      def translations
+        @translations ||= {}
+      end
+
+      def current_locale
+        @current_locale || ENV["TINA4_LANGUAGE"] || "en"
+      end
+
+      def current_locale=(locale)
+        @current_locale = locale.to_s
+      end
+
+      def load(root_dir = Dir.pwd)
+        LOCALE_DIRS.each do |dir|
+          locale_dir = File.join(root_dir, dir)
+          next unless Dir.exist?(locale_dir)
+
+          Dir.glob(File.join(locale_dir, "*.json")).each do |file|
+            locale = File.basename(file, ".json")
+            data = JSON.parse(File.read(file))
+            translations[locale] ||= {}
+            translations[locale].merge!(data)
+            Tina4::Debug.debug("Loaded locale: #{locale} from #{file}")
+          end
+
+          # Also support YAML
+          Dir.glob(File.join(locale_dir, "*.{yml,yaml}")).each do |file|
+            begin
+              require "yaml"
+              locale = File.basename(file, File.extname(file))
+              data = YAML.safe_load(File.read(file))
+              translations[locale] ||= {}
+              translations[locale].merge!(data) if data.is_a?(Hash)
+            rescue LoadError
+              Tina4::Debug.warning("YAML support requires the 'yaml' gem")
+            end
+          end
+        end
+      end
+
+      def t(key, locale: nil, default: nil, **interpolations)
+        lang = locale || current_locale
+        value = lookup(lang, key)
+
+        if value.nil? && lang != "en"
+          value = lookup("en", key)
+        end
+
+        value = default || key if value.nil?
+
+        # Interpolation: "Hello %{name}" => "Hello World"
+        interpolations.each do |k, v|
+          value = value.gsub("%{#{k}}", v.to_s)
+        end
+
+        value
+      end
+
+      def add(locale, key, value)
+        translations[locale.to_s] ||= {}
+        keys = key.to_s.split(".")
+        hash = translations[locale.to_s]
+        keys[0..-2].each do |k|
+          hash[k] ||= {}
+          hash = hash[k]
+        end
+        hash[keys.last] = value
+      end
+
+      def available_locales
+        translations.keys
+      end
+
+      private
+
+      def lookup(locale, key)
+        keys = key.to_s.split(".")
+        result = translations[locale]
+        return nil unless result
+
+        keys.each do |k|
+          if result.is_a?(Hash)
+            result = result[k] || result[k.to_sym]
+          else
+            return nil
+          end
+        end
+        result.is_a?(String) ? result : nil
+      end
+    end
+  end
+end

data/lib/tina4/middleware.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Tina4
+  class Middleware
+    class << self
+      def before_handlers
+        @before_handlers ||= []
+      end
+
+      def after_handlers
+        @after_handlers ||= []
+      end
+
+      def before(pattern = nil, &block)
+        before_handlers << { pattern: pattern, handler: block }
+      end
+
+      def after(pattern = nil, &block)
+        after_handlers << { pattern: pattern, handler: block }
+      end
+
+      def clear!
+        @before_handlers = []
+        @after_handlers = []
+      end
+
+      def run_before(request, response)
+        before_handlers.each do |entry|
+          next unless matches_pattern?(request.path, entry[:pattern])
+          result = entry[:handler].call(request, response)
+          # If handler returns false, halt the request
+          return false if result == false
+        end
+        true
+      end
+
+      def run_after(request, response)
+        after_handlers.each do |entry|
+          next unless matches_pattern?(request.path, entry[:pattern])
+          entry[:handler].call(request, response)
+        end
+      end
+
+      private
+
+      def matches_pattern?(path, pattern)
+        return true if pattern.nil?
+        case pattern
+        when String
+          path.start_with?(pattern)
+        when Regexp
+          pattern.match?(path)
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/tina4/migration.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+require "fileutils"
+
+module Tina4
+  class Migration
+    TRACKING_TABLE = "tina4_migrations"
+
+    def initialize(db, migrations_dir: nil)
+      @db = db
+      @migrations_dir = migrations_dir || File.join(Dir.pwd, "migrations")
+      ensure_tracking_table
+    end
+
+    def run
+      pending = pending_migrations
+      if pending.empty?
+        Tina4::Debug.info("No pending migrations")
+        return []
+      end
+
+      results = []
+      pending.each do |file|
+        result = run_migration(file)
+        results << result
+      end
+      results
+    end
+
+    def rollback(steps = 1)
+      completed = completed_migrations.last(steps)
+      completed.reverse.each do |name|
+        down_file = File.join(@migrations_dir, name.sub(".sql", ".down.sql"))
+        if File.exist?(down_file)
+          execute_sql_file(down_file)
+          remove_migration_record(name)
+          Tina4::Debug.info("Rolled back: #{name}")
+        else
+          Tina4::Debug.warning("No rollback file for: #{name}")
+        end
+      end
+    end
+
+    def status
+      {
+        completed: completed_migrations,
+        pending: pending_migrations.map { |f| File.basename(f) }
+      }
+    end
+
+    def create(name)
+      FileUtils.mkdir_p(@migrations_dir)
+      timestamp = Time.now.strftime("%Y%m%d%H%M%S")
+      filename = "#{timestamp}_#{name.gsub(/\s+/, '_')}.sql"
+      filepath = File.join(@migrations_dir, filename)
+      File.write(filepath, "-- Migration: #{name}\n-- Created: #{Time.now}\n\n")
+
+      down_filepath = filepath.sub(".sql", ".down.sql")
+      File.write(down_filepath, "-- Rollback: #{name}\n-- Created: #{Time.now}\n\n")
+
+      Tina4::Debug.info("Created migration: #{filename}")
+      filepath
+    end
+
+    private
+
+    def ensure_tracking_table
+      unless @db.table_exists?(TRACKING_TABLE)
+        @db.execute(<<~SQL)
+          CREATE TABLE #{TRACKING_TABLE} (
+            id INTEGER PRIMARY KEY,
+            migration_name VARCHAR(255) NOT NULL,
+            executed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+          )
+        SQL
+        Tina4::Debug.info("Created migrations tracking table")
+      end
+    end
+
+    def completed_migrations
+      result = @db.fetch("SELECT migration_name FROM #{TRACKING_TABLE} ORDER BY id")
+      result.map { |r| r[:migration_name] }
+    end
+
+    def pending_migrations
+      return [] unless Dir.exist?(@migrations_dir)
+
+      completed = completed_migrations
+      Dir.glob(File.join(@migrations_dir, "*.sql"))
+         .reject { |f| f.end_with?(".down.sql") }
+         .sort
+         .reject { |f| completed.include?(File.basename(f)) }
+    end
+
+    def run_migration(file)
+      name = File.basename(file)
+      Tina4::Debug.info("Running migration: #{name}")
+      begin
+        execute_sql_file(file)
+        record_migration(name)
+        { name: name, status: "success" }
+      rescue => e
+        Tina4::Debug.error("Migration failed: #{name} - #{e.message}")
+        { name: name, status: "failed", error: e.message }
+      end
+    end
+
+    def execute_sql_file(file)
+      sql = File.read(file)
+      statements = sql.split(";").map(&:strip).reject(&:empty?)
+      statements.each do |stmt|
+        next if stmt.start_with?("--")
+        @db.execute(stmt)
+      end
+    end
+
+    def record_migration(name)
+      @db.insert(TRACKING_TABLE, { migration_name: name })
+    end
+
+    def remove_migration_record(name)
+      @db.delete(TRACKING_TABLE, { migration_name: name })
+    end
+  end
+end