better_model 2.0.0 → 3.0.0

data/lib/better_model/state_transition.rb

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

data/lib/better_model/stateable/errors.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module BetterModel
-  module Stateable
-    # Base error for all Stateable errors
-    class StateableError < StandardError; end
-
-    # Raised when Stateable is not enabled but methods are called
-    class NotEnabledError < StateableError
-      def initialize(msg = nil)
-        super(msg || "Stateable is not enabled. Add 'stateable do...end' to your model.")
-      end
-    end
-
-    # Raised when an invalid state is referenced
-    class InvalidStateError < StateableError
-      def initialize(state)
-        super("Invalid state: #{state.inspect}")
-      end
-    end
-
-    # Raised when trying to transition to an invalid state from current state
-    class InvalidTransitionError < StateableError
-      def initialize(event, from_state, to_state)
-        super("Cannot transition from #{from_state.inspect} to #{to_state.inspect} via #{event.inspect}")
-      end
-    end
-
-    # Raised when a guard condition fails
-    class GuardFailedError < StateableError
-      def initialize(event, guard_description = nil)
-        msg = "Guard failed for transition #{event.inspect}"
-        msg += ": #{guard_description}" if guard_description
-        super(msg)
-      end
-    end
-
-    # Raised when a transition validation fails
-    class ValidationFailedError < StateableError
-      def initialize(event, errors)
-        super("Validation failed for transition #{event.inspect}: #{errors.full_messages.join(', ')}")
-      end
-    end
-  end
-end

data/lib/better_model/validatable/business_rule_validator.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module BetterModel
-  module Validatable
-    # Validator per business rules custom
-    #
-    # Permette di eseguire metodi custom come validatori, delegando la logica
-    # di validazione complessa a metodi del modello.
-    #
-    # Il metodo della business rule deve aggiungere errori tramite `errors.add`
-    # se la validazione fallisce.
-    #
-    # Esempio:
-    #   validates_with BusinessRuleValidator, rule_name: :valid_category
-    #
-    #   # Nel modello:
-    #   def valid_category
-    #     unless Category.exists?(id: category_id)
-    #       errors.add(:category_id, "must be a valid category")
-    #     end
-    #   end
-    #
-    class BusinessRuleValidator < ActiveModel::Validator
-      def initialize(options)
-        super
-
-        @rule_name = options[:rule_name]
-
-        unless @rule_name
-          raise ArgumentError, "BusinessRuleValidator requires :rule_name option"
-        end
-      end
-
-      def validate(record)
-        # Verifica che il metodo esista
-        unless record.respond_to?(@rule_name, true)
-          raise NoMethodError, "Business rule method '#{@rule_name}' not found in #{record.class.name}. " \
-                               "Define it in your model: def #{@rule_name}; ...; end"
-        end
-
-        # Esegui il metodo della business rule
-        # Il metodo stesso è responsabile di aggiungere errori tramite errors.add
-        record.send(@rule_name)
-      end
-    end
-  end
-end

data/lib/better_model/validatable/order_validator.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module BetterModel
-  module Validatable
-    # Validator per validazioni di ordine tra campi (cross-field)
-    #
-    # Verifica che un campo sia in una relazione d'ordine rispetto ad un altro campo.
-    # Supporta date/time (before/after) e numeri (lteq/gteq/lt/gt).
-    #
-    # Esempio:
-    #   validates_with OrderValidator,
-    #                  attributes: [:starts_at],
-    #                  second_field: :ends_at,
-    #                  comparator: :before
-    #
-    class OrderValidator < ActiveModel::EachValidator
-      COMPARATORS = {
-        before: :<,
-        after: :>,
-        lteq: :<=,
-        gteq: :>=,
-        lt: :<,
-        gt: :>
-      }.freeze
-
-      def initialize(options)
-        super
-
-        @second_field = options[:second_field]
-        @comparator = options[:comparator]
-
-        unless @second_field
-          raise ArgumentError, "OrderValidator requires :second_field option"
-        end
-
-        unless COMPARATORS.key?(@comparator)
-          raise ArgumentError, "Invalid comparator: #{@comparator}. Valid: #{COMPARATORS.keys.join(', ')}"
-        end
-      end
-
-      def validate_each(record, attribute, value)
-        second_value = record.send(@second_field)
-
-        # Skip validation if either field is nil (use presence validation for that)
-        return if value.nil? || second_value.nil?
-
-        # Get the comparison operator
-        operator = COMPARATORS[@comparator]
-
-        # Perform comparison
-        unless value.send(operator, second_value)
-          record.errors.add(attribute, error_message(attribute, @comparator, @second_field))
-        end
-      end
-
-      private
-
-      def error_message(first_field, comparator, second_field)
-        # Messaggi user-friendly basati sul comparatore
-        case comparator
-        when :before
-          "must be before #{second_field.to_s.humanize.downcase}"
-        when :after
-          "must be after #{second_field.to_s.humanize.downcase}"
-        when :lteq
-          "must be less than or equal to #{second_field.to_s.humanize.downcase}"
-        when :gteq
-          "must be greater than or equal to #{second_field.to_s.humanize.downcase}"
-        when :lt
-          "must be less than #{second_field.to_s.humanize.downcase}"
-        when :gt
-          "must be greater than #{second_field.to_s.humanize.downcase}"
-        end
-      end
-    end
-  end
-end

data/lib/better_model/version_record.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module BetterModel
-  # Version model for tracking changes
-  # This is the base AR model for version history
-  # Actual table_name is set dynamically in subclasses
-  class Version < ActiveRecord::Base
-    self.abstract_class = true
-
-    # Polymorphic association to the tracked model
-    belongs_to :item, polymorphic: true, optional: true
-
-    # Optional: belongs_to user who made the change
-    # belongs_to :updated_by, class_name: "User", optional: true
-
-    # Serialize object_changes as JSON
-    # Rails handles this automatically for json/jsonb columns
-
-    # Validations
-    validates :item_type, :event, presence: true
-    validates :event, inclusion: { in: %w[created updated destroyed] }
-
-    # Scopes
-    scope :for_item, ->(item) { where(item_type: item.class.name, item_id: item.id) }
-    scope :created_events, -> { where(event: "created") }
-    scope :updated_events, -> { where(event: "updated") }
-    scope :destroyed_events, -> { where(event: "destroyed") }
-    scope :by_user, ->(user_id) { where(updated_by_id: user_id) }
-    scope :between, ->(start_time, end_time) { where(created_at: start_time..end_time) }
-    scope :recent, ->(limit = 10) { order(created_at: :desc).limit(limit) }
-
-    # Get the change for a specific field
-    #
-    # @param field_name [Symbol, String] Field name
-    # @return [Hash, nil] Hash with :before and :after keys
-    def change_for(field_name)
-      return nil unless object_changes
-
-      field = field_name.to_s
-      return nil unless object_changes.key?(field)
-
-      {
-        before: object_changes[field][0],
-        after: object_changes[field][1]
-      }
-    end
-
-    # Check if a specific field changed in this version
-    # This method overrides ActiveRecord's changed? to accept a field_name parameter
-    #
-    # @param field_name [Symbol, String, nil] Field name (if nil, calls ActiveRecord's changed?)
-    # @return [Boolean]
-    def changed?(field_name = nil)
-      return super() if field_name.nil?
-
-      object_changes&.key?(field_name.to_s) || false
-    end
-
-    # Get list of changed fields
-    #
-    # @return [Array<String>]
-    def changed_fields
-      object_changes&.keys || []
-    end
-  end
-end

data/lib/generators/better_model/taggable/taggable_generator.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators"
-require "rails/generators/migration"
-
-module BetterModel
-  module Generators
-    class TaggableGenerator < Rails::Generators::NamedBase
-      include Rails::Generators::Migration
-
-      source_root File.expand_path("templates", __dir__)
-
-      class_option :column_name, type: :string, default: "tags",
-                   desc: "Name of the tags column (default: tags)"
-      class_option :skip_index, type: :boolean, default: false,
-                   desc: "Skip adding GIN index (PostgreSQL only)"
-
-      def self.next_migration_number(dirname)
-        next_migration_number = current_migration_number(dirname) + 1
-        ActiveRecord::Migration.next_migration_number(next_migration_number)
-      end
-
-      def create_migration_file
-        migration_template "migration.rb.tt",
-                          "db/migrate/add_#{column_name}_to_#{table_name}.rb"
-      end
-
-      def show_readme
-        # Display README as template to interpolate variables
-        if behavior == :invoke
-          say "=" * 79, :green
-          say ""
-          say "Taggable column has been added to your model!"
-          say ""
-          say "Next steps:"
-          say ""
-          say "1. Run the migration:"
-          say "   $ bin/rails db:migrate"
-          say ""
-          say "2. Add Taggable configuration to your model:"
-          say ""
-          say "   class #{model_name} < ApplicationRecord"
-          say "     include BetterModel"
-          say ""
-          if postgresql?
-            say "     # PostgreSQL: No additional configuration needed"
-          else
-            say "     # SQLite/MySQL: Add serialization for the tags column"
-            say "     serialize :#{column_name}, coder: JSON, type: Array"
-            say ""
-          end
-          say "     taggable do"
-          say "       tag_field :#{column_name}      # Column name (default: :tags)"
-          say "       normalize true              # Convert to lowercase"
-          say "       strip true                  # Remove whitespace (default)"
-          say "       min_length 2                # Minimum tag length"
-          say "       max_length 30               # Maximum tag length"
-          say "       validates_tags minimum: 1, maximum: 10"
-          say "     end"
-          say "   end"
-          say ""
-          say "3. Usage examples:"
-          say ""
-          say "   # Add tags"
-          say "   #{name.underscore}.tag_with(\"ruby\", \"rails\", \"web\")"
-          say ""
-          say "   # Remove tags"
-          say "   #{name.underscore}.untag(\"web\")"
-          say ""
-          say "   # Replace all tags"
-          say "   #{name.underscore}.retag(\"ruby\", \"api\")"
-          say ""
-          say "   # Check for tag"
-          say "   #{name.underscore}.tagged_with?(\"ruby\")  # => true"
-          say ""
-          say "   # CSV interface"
-          say "   #{name.underscore}.tag_list = \"ruby, rails, tutorial\""
-          say "   #{name.underscore}.tag_list  # => \"ruby, rails, tutorial\""
-          say ""
-          say "   # Search with tags (Predicable integration)"
-          say "   #{model_name}.#{column_name}_contains(\"ruby\")"
-          say "   #{model_name}.#{column_name}_overlaps([\"ruby\", \"python\"])"
-          say "   #{model_name}.#{column_name}_contains_all([\"ruby\", \"rails\"])"
-          say ""
-          say "   # Statistics"
-          say "   #{model_name}.tag_counts                    # => {\"ruby\" => 45, \"rails\" => 38}"
-          say "   #{model_name}.popular_tags(limit: 10)       # => [[\"ruby\", 45], [\"rails\", 38]]"
-          say "   #{model_name}.related_tags(\"ruby\", limit: 5)  # => [\"rails\", \"gem\", \"tutorial\"]"
-          say ""
-          say "For more information, see: docs/taggable.md"
-          say ""
-          say "=" * 79, :green
-        end
-      end
-
-      private
-
-      def table_name
-        name.tableize
-      end
-
-      def model_name
-        name.camelize
-      end
-
-      def migration_class_name
-        "Add#{column_name.camelize}To#{name.camelize.pluralize}"
-      end
-
-      def column_name
-        options[:column_name]
-      end
-
-      def add_index?
-        !options[:skip_index]
-      end
-
-      def postgresql?
-        # Check if PostgreSQL adapter is being used
-        # Note: This checks the current adapter, which may not reflect production
-        # The migration template includes runtime detection as well
-        return false unless defined?(ActiveRecord::Base)
-
-        adapter_name = ActiveRecord::Base.connection.adapter_name rescue nil
-        adapter_name == "PostgreSQL"
-      end
-    end
-  end
-end

data/lib/generators/better_model/taggable/templates/README.tt

@@ -1,62 +0,0 @@
-===============================================================================
-
-Taggable column has been added to your model!
-
-Next steps:
-
-1. Run the migration:
-   $ bin/rails db:migrate
-
-2. Add Taggable configuration to your model:
-
-   class <%= model_name %> < ApplicationRecord
-     include BetterModel
-
-<% if postgresql? -%>
-     # PostgreSQL: No additional configuration needed
-<% else -%>
-     # SQLite/MySQL: Add serialization for the tags column
-     serialize :<%= column_name %>, coder: JSON, type: Array
-
-<% end -%>
-     taggable do
-       tag_field :<%= column_name %>      # Column name (default: :tags)
-       normalize true              # Convert to lowercase
-       strip true                  # Remove whitespace (default)
-       min_length 2                # Minimum tag length
-       max_length 30               # Maximum tag length
-       validates_tags minimum: 1, maximum: 10
-     end
-   end
-
-3. Usage examples:
-
-   # Add tags
-   product.tag_with("ruby", "rails", "web")
-
-   # Remove tags
-   product.untag("web")
-
-   # Replace all tags
-   product.retag("ruby", "api")
-
-   # Check for tag
-   product.tagged_with?("ruby")  # => true
-
-   # CSV interface
-   product.tag_list = "ruby, rails, tutorial"
-   product.tag_list  # => "ruby, rails, tutorial"
-
-   # Search with tags (Predicable integration)
-   <%= model_name %>.<%= column_name %>_contains("ruby")
-   <%= model_name %>.<%= column_name %>_overlaps(["ruby", "python"])
-   <%= model_name %>.<%= column_name %>_contains_all(["ruby", "rails"])
-
-   # Statistics
-   <%= model_name %>.tag_counts                    # => {"ruby" => 45, "rails" => 38}
-   <%= model_name %>.popular_tags(limit: 10)       # => [["ruby", 45], ["rails", 38]]
-   <%= model_name %>.related_tags("ruby", limit: 5)  # => ["rails", "gem", "tutorial"]
-
-For more information, see: docs/taggable.md
-
-===============================================================================

data/lib/generators/better_model/taggable/templates/migration.rb.tt

@@ -1,21 +0,0 @@
-class <%= migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
-  def change
-    change_table :<%= table_name %> do |t|
-      # Tags column - database-specific implementation
-      if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
-        # PostgreSQL: Use native array with default empty array
-        t.string :<%= column_name %>, array: true, default: []
-      else
-        # SQLite/MySQL: Use text column (requires serialization in model)
-        t.text :<%= column_name %>
-      end
-    end
-<% if add_index? -%>
-
-    # Add index for PostgreSQL array searches (GIN index for better performance)
-    if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
-      add_index :<%= table_name %>, :<%= column_name %>, using: 'gin'
-    end
-<% end -%>
-  end
-end