dami 1.0.0

data/lib/dami/inflector.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+module Dami
+  module Inflector
+    # Caches for performance
+    @plural_cache = {}
+    @singular_cache = {}
+
+    UNCOUNTABLE = %w(
+      equipment information rice money species series fish sheep jeans police deer news homework
+      air water sugar tea coffee milk butter cheese bread jam chocolate wine beer music art
+      software love happiness furniture luggage advice work traffic weather accommodation
+      education knowledge research progress health safety violence peace chaos math physics
+      chemistry biology moose swine bison aircraft spacecraft salmon trout offspring
+    ).freeze
+
+    # These singular words end in 's' but are NOT plural!
+    SINGULAR_ENDING_IN_S = %w(
+      bus gas lens glass class mass grass brass canvas atlas bias cosmos dais iris oasis pancreas
+      alias status thesis basis crisis analysis diagnosis emphasis hypothesis neurosis osmosis
+      paralysis parenthesis synopsis
+    ).freeze
+
+    IRREGULAR = {
+      'person' => 'people', 'man' => 'men', 'woman' => 'women', 'child' => 'children',
+      'tooth' => 'teeth', 'foot' => 'feet', 'mouse' => 'mice', 'goose' => 'geese',
+      'ox' => 'oxen', 'quiz' => 'quizzes', 'matrix' => 'matrices', 'vertex' => 'vertices',
+      'index' => 'indices', 'sex' => 'sexes', 'move' => 'moves', 'zombie' => 'zombies',
+      'cactus' => 'cacti', 'focus' => 'foci', 'fungus' => 'fungi', 'nucleus' => 'nuclei',
+      'radius' => 'radii', 'stimulus' => 'stimuli', 'axis' => 'axes', 'analysis' => 'analyses',
+      'basis' => 'bases', 'crisis' => 'crises', 'diagnosis' => 'diagnoses',
+      'ellipsis' => 'ellipses', 'hypothesis' => 'hypotheses', 'oasis' => 'oases',
+      'paralysis' => 'paralyses', 'parenthesis' => 'parentheses', 'synopsis' => 'synopses',
+      'thesis' => 'theses', 'phenomenon' => 'phenomena', 'criterion' => 'criteria',
+      'datum' => 'data',
+      # Add the common -s words as irregular to handle them explicitly
+      'bus' => 'buses', 'gas' => 'gases', 'lens' => 'lenses', 'glass' => 'glasses',
+      'class' => 'classes', 'mass' => 'masses', 'grass' => 'grasses', 'brass' => 'brasses',
+      'canvas' => 'canvases', 'atlas' => 'atlases', 'bias' => 'biases', 'cosmos' => 'cosmoses',
+      'dais' => 'daises', 'iris' => 'irises', 'pancreas' => 'pancreases',
+      'alias' => 'aliases', 'status' => 'statuses'
+    }.freeze
+
+    IRREGULAR_REVERSE = IRREGULAR.invert.freeze
+
+    # Rules ordered from most specific to least specific
+    PLURAL_RULES = [
+      # Irregular patterns
+      [/^(ox)$/i, '\1en'],
+      [/^(m|l)ouse$/i, '\1ice'],
+      [/(quiz)$/i, '\1zes'],
+      
+      # Words ending in s, ss, x, z, ch, sh
+      [/(ss)$/i, '\1es'],
+      [/(x|z|ch|sh)$/i, '\1es'],
+      
+      # Words ending in o
+      [/(tomat|potat|ech|her|vet)o$/i, '\1oes'],
+      [/o$/i, 'os'],
+      
+      # Words ending in f or fe
+      [/(lea|loa|thie|shel|wol|hal|cal|kni)f$/i, '\1ves'],
+      [/(wi|li)fe$/i, '\1ves'],
+      
+      # Words ending in y
+      [/([^aeiou])y$/i, '\1ies'],
+      [/([aeiou]y)$/i, '\1s'],
+      
+      # Words ending in is
+      [/(ax|test)is$/i, '\1es'],
+      [/sis$/i, 'ses'],
+      
+      # Words ending in us
+      [/(octop|vir|radi|nucle|fung|cact|stimul)us$/i, '\1i'],
+      [/us$/i, 'uses'],
+      
+      # Words ending in um
+      [/([ti])um$/i, '\1a'],
+      
+      # Words ending in ix or ex
+      [/(matr|vert|ind)(ix|ex)$/i, '\1ices'],
+      
+      # Single 's' at the end (but not ss)
+      [/([^s])s$/i, '\1ses'],
+      
+      # Default: just add s
+      [/$/, 's']
+    ].freeze
+
+    SINGULAR_RULES = [
+      # Irregular patterns first
+      [/^oxen$/i, 'ox'],
+      [/^(m|l)ice$/i, '\1ouse'],
+      [/(quiz)zes$/i, '\1'],
+      
+      # Words ending in sses
+      [/(ss)es$/i, '\1'],
+      
+      # Words ending in xes, zes, ches, shes
+      [/(x|z|ch|sh)es$/i, '\1'],
+      
+      # Words ending in oes
+      [/(tomat|potat|ech|her|vet)oes$/i, '\1o'],
+      [/oes$/i, 'o'],
+      
+      # Words ending in ves
+      [/(lea|loa|thie|shel|wol|hal|cal|kni)ves$/i, '\1f'],
+      [/(wi|li)ves$/i, '\1fe'],
+      
+      # Words ending in ies
+      [/([^aeiou])ies$/i, '\1y'],
+      
+      # Words ending in uses (from -us)
+      [/([^aeiouy]|qu)uses$/i, '\1us'],
+      
+      # Words ending in i (Latin plurals)
+      [/(octop|vir|radi|nucle|fung|cact|stimul)i$/i, '\1us'],
+      
+      # Words ending in a (Greek/Latin plurals)
+      [/([ti])a$/i, '\1um'],
+      
+      # Words ending in ices
+      [/(matr|vert|ind)ices$/i, '\1ex'],
+      
+      # Words ending in es
+      [/(ax|test)es$/i, '\1is'],
+      [/ses$/i, 'sis'],
+      
+      # Words ending in s (default - MUST be last)
+      [/s$/i, '']
+    ].freeze
+
+    def self.apply_case(original, new_word)
+      return new_word if original == new_word
+      
+      if original == original.upcase
+        new_word.upcase
+      elsif original == original.capitalize
+        new_word.capitalize
+      elsif original[0] == original[0].upcase
+        new_word[0].upcase + new_word[1..-1]
+      else
+        new_word
+      end
+    end
+
+    def self.pluralize(word)
+      str = word.to_s.strip
+      return str if str.empty?
+      return @plural_cache[str] if @plural_cache.key?(str)
+
+      lower = str.downcase
+      
+      # Uncountable
+      if UNCOUNTABLE.include?(lower)
+        return @plural_cache[str] = str
+      end
+      
+      # Irregular singular -> plural (includes bus, gas, lens, etc.)
+      if irregular = IRREGULAR[lower]
+        return @plural_cache[str] = apply_case(str, irregular)
+      end
+      
+      # Already irregular plural
+      if IRREGULAR_REVERSE.key?(lower)
+        return @plural_cache[str] = str
+      end
+      
+      # Already plural check - a simple heuristic
+      # If it ends in 's' but isn't in our singular list, it might be plural
+      if lower.end_with?('s') && !lower.end_with?('ss') && !SINGULAR_ENDING_IN_S.include?(lower)
+        # Try to singularize and re-pluralize to check
+        test_singular = apply_singular_rules(str)
+        if test_singular != str
+          test_plural = apply_plural_rules(test_singular)
+          if test_plural.downcase == lower
+            return @plural_cache[str] = str  # Already plural
+          end
+        end
+      end
+      
+      # Apply plural rules
+      result = apply_plural_rules(str)
+      @plural_cache[str] = result
+    end
+
+    def self.singularize(word)
+      str = word.to_s.strip
+      return str if str.empty?
+      return @singular_cache[str] if @singular_cache.key?(str)
+
+      lower = str.downcase
+      
+      # Uncountable
+      if UNCOUNTABLE.include?(lower)
+        return @singular_cache[str] = str
+      end
+      
+      # Irregular plural -> singular (includes buses, gases, lenses, etc.)
+      if irregular = IRREGULAR_REVERSE[lower]
+        return @singular_cache[str] = apply_case(str, irregular)
+      end
+      
+      # Already irregular singular
+      if IRREGULAR.key?(lower)
+        return @singular_cache[str] = str
+      end
+      
+      # Check if it's a known singular word ending in 's'
+      if SINGULAR_ENDING_IN_S.include?(lower)
+        return @singular_cache[str] = str
+      end
+      
+      # Already singular check - if it doesn't end in 's', it's probably singular
+      if !lower.end_with?('s')
+        return @singular_cache[str] = str
+      end
+      
+      # Apply singular rules
+      result = apply_singular_rules(str)
+      @singular_cache[str] = result
+    end
+
+    private
+
+    def self.apply_plural_rules(str)
+      PLURAL_RULES.each do |regex, replacement|
+        if str =~ regex
+          result = str.sub(regex, replacement)
+          return apply_case(str, result)
+        end
+      end
+      str
+    end
+
+    def self.apply_singular_rules(str)
+      SINGULAR_RULES.each do |regex, replacement|
+        if str =~ regex
+          result = str.sub(regex, replacement)
+          return apply_case(str, result)
+        end
+      end
+      str
+    end
+  end
+end

data/lib/dami/localization.rb

@@ -0,0 +1,131 @@
+# File: lib/dami/localization.rb
+# frozen_string_literal: true
+#raise "LOCALIZATION FILE RELOADED AT #{Time.now.to_f}"
+
+module Dami
+  class << self
+    attr_reader :translations
+  end
+  
+  @translations = {}
+  @locale = nil
+  
+  # Process-wide default locale (set once at boot).
+  def self.locale
+    instance_variable_get(:@locale)
+  end
+
+  def self.locale=(new_locale)
+    instance_variable_set(:@locale, new_locale&.to_sym)
+  end
+
+  # Per-thread override. Web servers run requests on threads, so a request's
+  # locale must never leak into another request: set it here (or use
+  # with_locale), never via Dami.locale= from inside a request.
+  def self.thread_locale
+    Thread.current[:dami_locale]
+  end
+
+  def self.thread_locale=(new_locale)
+    Thread.current[:dami_locale] = new_locale&.to_sym
+  end
+
+  def self.current_locale
+    locale = Thread.current[:dami_locale] || instance_variable_get(:@locale)
+
+    # Only convert to symbol if locale exists and is not empty
+    return locale.to_sym if locale && !locale.to_s.empty?
+
+    if defined?(I18n) && I18n.respond_to?(:locale)
+      i18n_locale = I18n.locale
+      return i18n_locale.to_sym if i18n_locale
+    end
+
+    :en
+  end
+  def self.localize(scope, &block)
+    scope_storage = (@translations[scope] ||= {})
+    LocalizationProxy.new(scope_storage).instance_eval(&block)
+  end
+  
+  def self.translate(key, *args)
+    keys = key.to_s.split('.').map(&:to_sym)
+    locale = current_locale
+    
+    message = @translations.dig(*keys.insert(1, locale))
+    if message.is_a?(Proc)
+      message.call(*args)
+    else
+      message || "translation missing: #{locale}.#{key}"
+    end
+  end
+  
+  # Thread-local: only the calling thread sees the temporary locale.
+  def self.with_locale(temp_locale, &block)
+    original_locale = Thread.current[:dami_locale]
+    Thread.current[:dami_locale] = temp_locale&.to_sym
+    yield
+  ensure
+    Thread.current[:dami_locale] = original_locale
+  end
+  # --- Helper Methods ---
+  
+  def self.localize_model(model_name, locale: nil)
+    locale ||= current_locale
+    @translations.dig(:models, locale, model_name, :model_name)
+  end
+  
+  class << self
+    alias_method :lm, :localize_model
+  end
+  
+  def self.localize_field(model_name, field_name, locale: nil)
+    locale ||= current_locale
+    @translations.dig(:models, locale, model_name, field_name)
+  end
+  
+  class << self
+    alias_method :lf, :localize_field
+  end
+  
+  # --- DSL Proxy Classes ---
+  
+  class LocalizationProxy
+    def initialize(storage); @storage = storage; end
+    def en(&block); locale(:en, &block); end
+    def es(&block); locale(:es, &block); end
+    def fr(&block); locale(:fr, &block); end
+    def de(&block); locale(:de, &block); end
+    def ja(&block); locale(:ja, &block); end
+    def zh(&block); locale(:zh, &block); end
+    def pt(&block); locale(:pt, &block); end
+    def it(&block); locale(:it, &block); end
+    def ru(&block); locale(:ru, &block); end
+    def ar(&block); locale(:ar, &block); end
+    
+    def locale(lang_code, &block)
+      locale_storage = (@storage[lang_code.to_sym] ||= {})
+      LocaleProxy.new(locale_storage).instance_eval(&block)
+    end
+  end
+  
+  class LocaleProxy
+    def initialize(storage); @storage = storage; end
+    def set(key, value); @storage[key.to_sym] = value; end
+    
+    def attributes_for(model_name, &block)
+      model_storage = (@storage[model_name.to_sym] ||= {})
+      AttributesProxy.new(model_storage).instance_eval(&block)
+    end
+    
+    def enum_for(model_name, attribute, &block)
+      enum_storage = ((@storage[model_name.to_sym] ||= {})[attribute.to_sym] = {})
+      AttributesProxy.new(enum_storage).instance_eval(&block)
+    end
+  end
+  
+  class AttributesProxy
+    def initialize(storage); @storage = storage; end
+    def set(key, value); @storage[key.to_sym] = value; end
+  end
+end

data/lib/dami/migration.rb

@@ -0,0 +1,84 @@
+# lib/dami/migration.rb - Fix create_table to support block parameter syntax
+
+module Dami
+  class Migration
+    def initialize(adapter)
+      @adapter = adapter
+    end
+    
+    def up
+      # This should be overridden by the migration file
+    end
+    
+    def down
+      # This should be overridden by the migration file  
+    end
+    
+    # Schema methods
+def create_table(name, &block)
+  table_definition = TableDefinition.new
+  
+  # Support both styles: do |t| ... end and do ... end
+  if block.arity == 0
+    table_definition.instance_eval(&block)
+  else
+    yield table_definition
+  end
+  
+  @adapter.create_table(name, table_definition.columns)
+end
+    
+    def drop_table(name)
+      @adapter.execute("DROP TABLE IF EXISTS #{name}")
+    end
+    
+    def add_column(table, column, type, **options)
+      @adapter.add_column(table, column, type, **options)
+    end
+    
+    def remove_column(table, column)
+      # SQLite has limited DROP COLUMN support
+      # This will work in SQLite 3.35.0+ but fail gracefully in older versions
+      begin
+        @adapter.execute("ALTER TABLE #{table} DROP COLUMN #{column}")
+      rescue SQLite3::Exception => e
+        # Log the limitation but don't crash
+        puts "Note: DROP COLUMN not supported in this SQLite version: #{e.message}"
+      end
+    end
+    def add_index(table_name, column_name, **options)
+      @adapter.add_index(table_name, column_name, options)
+    end
+
+    def remove_index(table_name, column_name, **options)
+      @adapter.remove_index(table_name, column_name, options)
+    end
+
+    
+  end
+  
+  class TableDefinition
+    attr_reader :columns
+    
+    def initialize
+      @columns = []
+    end
+    
+    def field(name, type, **options)
+      @columns << { name: name, type: type, **options }
+    end
+    
+    # created_at / updated_at columns. Dami fills them automatically on
+    # create/update when the model declares the same two fields.
+    def timestamps
+      field(:created_at, :datetime)
+      field(:updated_at, :datetime)
+    end
+
+    # Shorthand for a foreign-key column: t.references :user -> user_id INTEGER REFERENCES users(id)
+    def references(name, **options)
+      table = options.delete(:table) || Dami::Inflector.pluralize(name.to_s)
+      field(:"#{name}_id", :integer, references: table, **options)
+    end
+  end
+end

data/lib/dami/migrator.rb

@@ -0,0 +1,105 @@
+# lib/dami/migrator.rb
+# frozen_string_literal: true
+module Dami
+  class Migrator
+    def initialize(adapter, path: Dami.configuration.migrations_path)
+      @adapter = adapter
+      @path = path
+      ensure_schema_migrations_table
+    end
+    
+    def migrate
+      pending_migrations.each { |m| run_migration(m) }
+      dump_schema # ADD THIS LINE
+    end
+    
+    def rollback(steps = 1)
+      completed_migrations.reverse.first(steps).each { |m| reverse_migration(m) }
+      dump_schema
+    end
+    
+    private
+
+    def ensure_schema_migrations_table
+      return if @adapter.table_exists?(:schema_migrations)
+      
+      @adapter.execute <<-SQL
+        CREATE TABLE schema_migrations (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          version VARCHAR(255) NOT NULL UNIQUE,
+          created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+      SQL
+    end
+    
+    def all_migrations
+      return [] unless Dir.exist?(@path)
+      Dir.glob("#{@path}/*.rb").sort.map do |file|
+        version = File.basename(file).match(/^(\d+)_/)[1]
+        { version: version, file: file }
+      end
+    end
+    
+    def completed_versions
+      query = { 
+        model_name: :schema_migrations, 
+        conditions: [], 
+        order_by: nil, 
+        limit: nil, 
+        offset: nil 
+      }
+      @adapter.query_records(query).map { |r| r[:version] }
+    end
+    
+    def pending_migrations
+      all_migrations.reject { |m| completed_versions.include?(m[:version]) }
+    end
+    
+    def completed_migrations
+      all_migrations.select { |m| completed_versions.include?(m[:version]) }
+    end
+    
+    def load_migration(file)
+      migration = Migration.new(@adapter)
+      # This part is flexible; it will define up/down methods if they exist.
+      migration.instance_eval(File.read(file), file)
+      migration
+    end
+    
+    def run_migration(migration_info)
+      migration = load_migration(migration_info[:file])
+      @adapter.transaction do
+        # THE FIX: Call the new method name.
+        migration.up
+        @adapter.insert_record(:schema_migrations, { version: migration_info[:version] })
+      end
+    end
+    
+    def reverse_migration(migration_info)
+      migration = load_migration(migration_info[:file])
+      @adapter.transaction do
+        # THE FIX: Call the new method name.
+        migration.down
+        
+        @adapter.execute(
+          "DELETE FROM schema_migrations WHERE version = ?",
+          [migration_info[:version]]
+        )
+      end
+    rescue => e
+      puts "Error in reverse_migration for #{migration_info[:version]}: #{e.message}"
+      puts e.backtrace.first(5)
+      raise
+    end
+    def dump_schema
+      require_relative 'schema/dumper'
+      dumper = Dami::Schema::Dumper.new(@adapter)
+      schema_content = dumper.dump
+      
+      # Use the configured path.
+      schema_path = Dami.configuration.schema_path
+      FileUtils.mkdir_p(File.dirname(schema_path))
+      File.write(schema_path, schema_content)
+    end
+  end
+end