tina4ruby 0.4.0

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

data/lib/tina4/orm.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+require "json"
+
+module Tina4
+  class ORM
+    include Tina4::FieldTypes
+
+    class << self
+      def db
+        Tina4.database
+      end
+
+      def find(id)
+        pk = primary_key_field || :id
+        result = db.fetch_one("SELECT * FROM #{table_name} WHERE #{pk} = ?", [id])
+        return nil unless result
+        from_hash(result)
+      end
+
+      def where(conditions, params = [])
+        sql = "SELECT * FROM #{table_name} WHERE #{conditions}"
+        results = db.fetch(sql, params)
+        results.map { |row| from_hash(row) }
+      end
+
+      def all(limit: nil, skip: nil, order_by: nil)
+        sql = "SELECT * FROM #{table_name}"
+        sql += " ORDER BY #{order_by}" if order_by
+        results = db.fetch(sql, [], limit: limit, skip: skip)
+        results.map { |row| from_hash(row) }
+      end
+
+      def count(conditions = nil, params = [])
+        sql = "SELECT COUNT(*) as cnt FROM #{table_name}"
+        sql += " WHERE #{conditions}" if conditions
+        result = db.fetch_one(sql, params)
+        result[:cnt].to_i
+      end
+
+      def create(attributes = {})
+        instance = new(attributes)
+        instance.save
+        instance
+      end
+
+      def from_hash(hash)
+        instance = new
+        hash.each do |key, value|
+          setter = "#{key}="
+          instance.send(setter, value) if instance.respond_to?(setter)
+        end
+        instance.instance_variable_set(:@persisted, true)
+        instance
+      end
+    end
+
+    def initialize(attributes = {})
+      @persisted = false
+      @errors = []
+      attributes.each do |key, value|
+        setter = "#{key}="
+        send(setter, value) if respond_to?(setter)
+      end
+      # Set defaults
+      self.class.field_definitions.each do |name, opts|
+        if send(name).nil? && opts[:default]
+          send("#{name}=", opts[:default])
+        end
+      end
+    end
+
+    def save
+      @errors = []
+      validate_fields
+      return false unless @errors.empty?
+
+      data = to_hash(exclude_nil: true)
+      pk = self.class.primary_key_field || :id
+      pk_value = send(pk)
+
+      if @persisted && pk_value
+        filter = { pk => pk_value }
+        data.delete(pk)
+        self.class.db.update(self.class.table_name, data, filter)
+      else
+        result = self.class.db.insert(self.class.table_name, data)
+        if result[:last_id] && respond_to?("#{pk}=")
+          send("#{pk}=", result[:last_id])
+        end
+        @persisted = true
+      end
+      true
+    rescue => e
+      @errors << e.message
+      false
+    end
+
+    def delete
+      pk = self.class.primary_key_field || :id
+      pk_value = send(pk)
+      return false unless pk_value
+
+      self.class.db.delete(self.class.table_name, { pk => pk_value })
+      @persisted = false
+      true
+    end
+
+    def load(id = nil)
+      pk = self.class.primary_key_field || :id
+      id ||= send(pk)
+      return false unless id
+
+      result = self.class.db.fetch_one("SELECT * FROM #{self.class.table_name} WHERE #{pk} = ?", [id])
+      return false unless result
+
+      result.each do |key, value|
+        setter = "#{key}="
+        send(setter, value) if respond_to?(setter)
+      end
+      @persisted = true
+      true
+    end
+
+    def persisted?
+      @persisted
+    end
+
+    def errors
+      @errors
+    end
+
+    def to_hash(exclude_nil: false)
+      hash = {}
+      self.class.field_definitions.each_key do |name|
+        value = send(name)
+        next if exclude_nil && value.nil?
+        hash[name] = value
+      end
+      hash
+    end
+
+    def to_json(*_args)
+      JSON.generate(to_hash)
+    end
+
+    def to_s
+      "#<#{self.class.name} #{to_hash}>"
+    end
+
+    def select(*fields)
+      fields_str = fields.map(&:to_s).join(", ")
+      pk = self.class.primary_key_field || :id
+      pk_value = send(pk)
+      self.class.db.fetch_one("SELECT #{fields_str} FROM #{self.class.table_name} WHERE #{pk} = ?", [pk_value])
+    end
+
+    private
+
+    def validate_fields
+      self.class.field_definitions.each do |name, opts|
+        value = send(name)
+        if !opts[:nullable] && value.nil? && !opts[:auto_increment] && !opts[:default]
+          @errors << "#{name} cannot be null"
+        end
+      end
+    end
+  end
+end