better_model 1.0.0 → 1.2.0

data/lib/better_model/archivable.rb

@@ -115,7 +115,7 @@ module BetterModel
 
           # Applica default scope SOLO se configurato
           if archivable_config[:skip_archived_by_default]
-            default_scope -> { not_archived }
+            default_scope -> { where(archived_at: nil) }
           end
         end
       end
@@ -124,19 +124,19 @@ module BetterModel
       #
       # @return [ActiveRecord::Relation]
       def archived_only
-        raise NotEnabledError unless archivable_enabled?
+        raise ArchivableNotEnabledError unless archivable_enabled?
         unscoped.archived
       end
 
       # Helper: alias per archived_at_today
       def archived_today
-        raise NotEnabledError unless archivable_enabled?
+        raise ArchivableNotEnabledError unless archivable_enabled?
         archived_at_today
       end
 
       # Helper: alias per archived_at_this_week
       def archived_this_week
-        raise NotEnabledError unless archivable_enabled?
+        raise ArchivableNotEnabledError unless archivable_enabled?
         archived_at_this_week
       end
 
@@ -145,7 +145,7 @@ module BetterModel
       # @param duration [ActiveSupport::Duration] Durata (es: 7.days)
       # @return [ActiveRecord::Relation]
       def archived_recently(duration = 7.days)
-        raise NotEnabledError unless archivable_enabled?
+        raise ArchivableNotEnabledError unless archivable_enabled?
         archived_at_within(duration)
       end
 
@@ -164,10 +164,10 @@ module BetterModel
     # @param by [Integer, Object] ID utente o oggetto user (opzionale)
     # @param reason [String] Motivo dell'archiviazione (opzionale)
     # @return [self]
-    # @raise [NotEnabledError] se archivable non è attivo
+    # @raise [ArchivableNotEnabledError] se archivable non è attivo
     # @raise [AlreadyArchivedError] se già archiviato
     def archive!(by: nil, reason: nil)
-      raise NotEnabledError unless self.class.archivable_enabled?
+      raise ArchivableNotEnabledError unless self.class.archivable_enabled?
       raise AlreadyArchivedError, "Record is already archived" if archived?
 
       self.archived_at = Time.current
@@ -186,10 +186,10 @@ module BetterModel
     # Ripristina record archiviato
     #
     # @return [self]
-    # @raise [NotEnabledError] se archivable non è attivo
+    # @raise [ArchivableNotEnabledError] se archivable non è attivo
     # @raise [NotArchivedError] se non archiviato
     def restore!
-      raise NotEnabledError unless self.class.archivable_enabled?
+      raise ArchivableNotEnabledError unless self.class.archivable_enabled?
       raise NotArchivedError, "Record is not archived" unless archived?
 
       self.archived_at = nil
@@ -241,7 +241,7 @@ module BetterModel
   class AlreadyArchivedError < ArchivableError; end
   class NotArchivedError < ArchivableError; end
 
-  class NotEnabledError < ArchivableError
+  class ArchivableNotEnabledError < ArchivableError
     def initialize(msg = nil)
       super(msg || "Archivable is not enabled. Add 'archivable do...end' to your model.")
     end

data/lib/better_model/predicable.rb

@@ -58,6 +58,9 @@ module BetterModel
           column = columns_hash[field_name.to_s]
           next unless column
 
+          # Base predicates available for all column types
+          define_base_predicates(field_name, column.type)
+
           case column.type
           when :string, :text
             define_string_predicates(field_name)
@@ -68,18 +71,14 @@ module BetterModel
           when :date, :datetime, :time, :timestamp
             define_date_predicates(field_name)
           when :jsonb, :json
-            # JSONB/JSON: base predicates + PostgreSQL-specific
-            define_base_predicates(field_name)
+            # JSONB/JSON: PostgreSQL-specific predicates
             define_postgresql_jsonb_predicates(field_name)
           else
             # Check for array columns (PostgreSQL)
             if column.respond_to?(:array?) && column.array?
-              define_base_predicates(field_name)
               define_postgresql_array_predicates(field_name)
-            else
-              # Default: genera solo predicati base
-              define_base_predicates(field_name)
             end
+            # Unknown types only get base predicates
           end
         end
       end
@@ -143,7 +142,7 @@ module BetterModel
       end
 
       # Genera predicati base: _eq, _not_eq, _present
-      def define_base_predicates(field_name)
+      def define_base_predicates(field_name, column_type = nil)
         table = arel_table
         field = table[field_name]
 
@@ -151,24 +150,27 @@ module BetterModel
         scope :"#{field_name}_eq", ->(value) { where(field.eq(value)) }
         scope :"#{field_name}_not_eq", ->(value) { where(field.not_eq(value)) }
 
-        # Presence
-        scope :"#{field_name}_present", -> { where(field.not_eq(nil)) }
+        # Presence - skip for string/text types as they get specialized version
+        # String types need to check for both nil and empty string
+        unless [ :string, :text ].include?(column_type)
+          scope :"#{field_name}_present", -> { where(field.not_eq(nil)) }
+        end
 
-        register_predicable_scopes(
-          :"#{field_name}_eq",
-          :"#{field_name}_not_eq",
-          :"#{field_name}_present"
-        )
+        scopes_to_register = [ :"#{field_name}_eq", :"#{field_name}_not_eq" ]
+        scopes_to_register << :"#{field_name}_present" unless [ :string, :text ].include?(column_type)
+
+        register_predicable_scopes(*scopes_to_register)
       end
 
-      # Genera predicati per campi stringa (14 scope)
+      # Genera predicati per campi stringa (12 scope)
+      # Base predicates (_eq, _not_eq) are defined separately
+      # _present is defined here to handle both nil and empty strings
       def define_string_predicates(field_name)
         table = arel_table
         field = table[field_name]
 
-        # Comparison (2)
-        scope :"#{field_name}_eq", ->(value) { where(field.eq(value)) }
-        scope :"#{field_name}_not_eq", ->(value) { where(field.not_eq(value)) }
+        # String-specific presence check (checks both nil and empty string)
+        scope :"#{field_name}_present", -> { where(field.not_eq(nil).and(field.not_eq(""))) }
 
         # Pattern matching (4)
         scope :"#{field_name}_matches", ->(pattern) { where(field.matches(pattern)) }
@@ -203,14 +205,11 @@ module BetterModel
         scope :"#{field_name}_in", ->(values) { where(field.in(Array(values))) }
         scope :"#{field_name}_not_in", ->(values) { where.not(field.in(Array(values))) }
 
-        # Presence (3)
-        scope :"#{field_name}_present", -> { where(field.not_eq(nil).and(field.not_eq(""))) }
+        # Presence (2) - _present is overridden above for string-specific behavior
         scope :"#{field_name}_blank", -> { where(field.eq(nil).or(field.eq(""))) }
         scope :"#{field_name}_null", -> { where(field.eq(nil)) }
 
         register_predicable_scopes(
-          :"#{field_name}_eq",
-          :"#{field_name}_not_eq",
           :"#{field_name}_matches",
           :"#{field_name}_start",
           :"#{field_name}_end",
@@ -226,14 +225,13 @@ module BetterModel
         )
       end
 
-      # Genera predicati per campi numerici (11 scope)
+      # Genera predicati per campi numerici (8 scope)
+      # Base predicates (_eq, _not_eq, _present) are defined separately
       def define_numeric_predicates(field_name)
         table = arel_table
         field = table[field_name]
 
-        # Comparison (6)
-        scope :"#{field_name}_eq", ->(value) { where(field.eq(value)) }
-        scope :"#{field_name}_not_eq", ->(value) { where(field.not_eq(value)) }
+        # Comparison (4)
         scope :"#{field_name}_lt", ->(value) { where(field.lt(value)) }
         scope :"#{field_name}_lteq", ->(value) { where(field.lteq(value)) }
         scope :"#{field_name}_gt", ->(value) { where(field.gt(value)) }
@@ -247,12 +245,7 @@ module BetterModel
         scope :"#{field_name}_in", ->(values) { where(field.in(Array(values))) }
         scope :"#{field_name}_not_in", ->(values) { where.not(field.in(Array(values))) }
 
-        # Presence (1)
-        scope :"#{field_name}_present", -> { where(field.not_eq(nil)) }
-
         register_predicable_scopes(
-          :"#{field_name}_eq",
-          :"#{field_name}_not_eq",
           :"#{field_name}_lt",
           :"#{field_name}_lteq",
           :"#{field_name}_gt",
@@ -265,32 +258,27 @@ module BetterModel
         )
       end
 
-      # Genera predicati per campi booleani (5 scope)
+      # Genera predicati per campi booleani (2 scope)
+      # Base predicates (_eq, _not_eq, _present) are defined separately
       def define_boolean_predicates(field_name)
         table = arel_table
         field = table[field_name]
 
-        # Comparison (2)
-        scope :"#{field_name}_eq", ->(value) { where(field.eq(value)) }
-        scope :"#{field_name}_not_eq", ->(value) { where(field.not_eq(value)) }
-
         # Boolean shortcuts (2)
         scope :"#{field_name}_true", -> { where(field.eq(true)) }
         scope :"#{field_name}_false", -> { where(field.eq(false)) }
 
-        # Presence (1)
-        scope :"#{field_name}_present", -> { where(field.not_eq(nil)) }
-
         register_predicable_scopes(
-          :"#{field_name}_eq",
-          :"#{field_name}_not_eq",
           :"#{field_name}_true",
-          :"#{field_name}_false",
-          :"#{field_name}_present"
+          :"#{field_name}_false"
         )
       end
 
       # Genera predicati per campi array PostgreSQL (3 scope)
+      #
+      # NOTA: Questo metodo non è coperto da test automatici perché richiede
+      # PostgreSQL. I test vengono eseguiti su SQLite per performance.
+      # Testare manualmente su PostgreSQL con: rails console RAILS_ENV=test
       def define_postgresql_array_predicates(field_name)
         return unless postgresql_adapter?
 
@@ -343,6 +331,10 @@ module BetterModel
       end
 
       # Genera predicati per campi JSONB PostgreSQL (4 scope)
+      #
+      # NOTA: Questo metodo non è coperto da test automatici perché richiede
+      # PostgreSQL con supporto JSONB. I test vengono eseguiti su SQLite per performance.
+      # Testare manualmente su PostgreSQL con: rails console RAILS_ENV=test
       def define_postgresql_jsonb_predicates(field_name)
         return unless postgresql_adapter?
 
@@ -391,14 +383,13 @@ module BetterModel
         )
       end
 
-      # Genera predicati per campi data/datetime (22 scope)
+      # Genera predicati per campi data/datetime (17 scope)
+      # Base predicates (_eq, _not_eq, _present) are defined separately
       def define_date_predicates(field_name)
         table = arel_table
         field = table[field_name]
 
-        # Comparison (6)
-        scope :"#{field_name}_eq", ->(value) { where(field.eq(value)) }
-        scope :"#{field_name}_not_eq", ->(value) { where(field.not_eq(value)) }
+        # Comparison (4)
         scope :"#{field_name}_lt", ->(value) { where(field.lt(value)) }
         scope :"#{field_name}_lteq", ->(value) { where(field.lteq(value)) }
         scope :"#{field_name}_gt", ->(value) { where(field.gt(value)) }
@@ -440,15 +431,12 @@ module BetterModel
           where(field.gteq(time_ago))
         }
 
-        # Presence (4)
-        scope :"#{field_name}_present", -> { where(field.not_eq(nil)) }
+        # Presence (3) - _present is defined in base predicates
         scope :"#{field_name}_blank", -> { where(field.eq(nil)) }
         scope :"#{field_name}_null", -> { where(field.eq(nil)) }
         scope :"#{field_name}_not_null", -> { where(field.not_eq(nil)) }
 
         register_predicable_scopes(
-          :"#{field_name}_eq",
-          :"#{field_name}_not_eq",
           :"#{field_name}_lt",
           :"#{field_name}_lteq",
           :"#{field_name}_gt",
@@ -465,7 +453,6 @@ module BetterModel
           :"#{field_name}_past",
           :"#{field_name}_future",
           :"#{field_name}_within",
-          :"#{field_name}_present",
           :"#{field_name}_blank",
           :"#{field_name}_null",
           :"#{field_name}_not_null"

data/lib/better_model/sortable.rb

@@ -188,6 +188,10 @@ module BetterModel
       end
 
       # Genera SQL per gestione NULL multi-database
+      #
+      # NOTA: Il blocco MySQL else qui sotto non è coperto da test automatici
+      # perché i test vengono eseguiti su SQLite. Testare manualmente su MySQL
+      # con: rails console RAILS_ENV=test
       def nulls_order_sql(field_name, direction, nulls_position)
         quoted_field = connection.quote_column_name(field_name)
 

data/lib/better_model/state_transition.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module BetterModel
+  # StateTransition - Base ActiveRecord model for state transition history
+  #
+  # Questo è un modello abstract. Le classi concrete vengono generate dinamicamente
+  # per ogni tabella (state_transitions, order_transitions, etc.).
+  #
+  # Schema della tabella:
+  #   t.string :transitionable_type, null: false
+  #   t.integer :transitionable_id, null: false
+  #   t.string :event, null: false
+  #   t.string :from_state, null: false
+  #   t.string :to_state, null: false
+  #   t.json :metadata
+  #   t.datetime :created_at, null: false
+  #
+  # Utilizzo:
+  #   # Tutte le transizioni di un modello
+  #   order.state_transitions
+  #
+  #   # Query globali (tramite classi dinamiche)
+  #   BetterModel::StateTransitions.for_model(Order)
+  #   BetterModel::OrderTransitions.by_event(:confirm)
+  #
+  class StateTransition < ActiveRecord::Base
+    # Default table name (can be overridden by dynamic subclasses)
+    self.table_name = "state_transitions"
+
+    # Polymorphic association
+    belongs_to :transitionable, polymorphic: true
+
+    # Validations
+    validates :event, :from_state, :to_state, presence: true
+
+    # Scopes
+
+    # Scope per modello specifico
+    #
+    # @param model_class [Class] Classe del modello
+    # @return [ActiveRecord::Relation]
+    #
+    scope :for_model, ->(model_class) {
+      where(transitionable_type: model_class.name)
+    }
+
+    # Scope per evento specifico
+    #
+    # @param event [Symbol, String] Nome dell'evento
+    # @return [ActiveRecord::Relation]
+    #
+    scope :by_event, ->(event) {
+      where(event: event.to_s)
+    }
+
+    # Scope per stato di partenza
+    #
+    # @param state [Symbol, String] Stato di partenza
+    # @return [ActiveRecord::Relation]
+    #
+    scope :from_state, ->(state) {
+      where(from_state: state.to_s)
+    }
+
+    # Scope per stato di arrivo
+    #
+    # @param state [Symbol, String] Stato di arrivo
+    # @return [ActiveRecord::Relation]
+    #
+    scope :to_state, ->(state) {
+      where(to_state: state.to_s)
+    }
+
+    # Scope per transizioni recenti
+    #
+    # @param duration [ActiveSupport::Duration] Durata (es. 7.days)
+    # @return [ActiveRecord::Relation]
+    #
+    scope :recent, ->(duration = 7.days) {
+      where("created_at >= ?", duration.ago)
+    }
+
+    # Scope per transizioni in un periodo
+    #
+    # @param start_time [Time, Date] Inizio periodo
+    # @param end_time [Time, Date] Fine periodo
+    # @return [ActiveRecord::Relation]
+    #
+    scope :between, ->(start_time, end_time) {
+      where(created_at: start_time..end_time)
+    }
+
+    # Metodi di istanza
+
+    # Formatted description della transizione
+    #
+    # @return [String]
+    #
+    def description
+      "#{transitionable_type}##{transitionable_id}: #{from_state} -> #{to_state} (#{event})"
+    end
+
+    # Alias per retrocompatibilità
+    alias_method :to_s, :description
+  end
+end