SwifterEnum

# In your model - looks just like a regular Rails enum. No change needed to the db column.
class Order < ApplicationRecord
  swifter_enum :payment_status, PaymentStatusEnum
end

# Define your enum with its behavior
class PaymentStatusEnum < SwifterEnum::Base
  set_values ({
    pending: 0,
    processing: 10,
    completed: 20,
    failed: 30,
    refunded: 40
  })

  def completed?
    [:completed, :refunded].include?(value)
  end

  def can_refund?
    value == :completed
  end

  def icon
    case value
    when :pending then "clock"
    when :processing then "spinner"
    when :completed then "check-circle"
    when :failed then "x-circle"
    when :refunded then "rotate-left"
    end
  end

  def color
    case value
    when :pending then "gray"
    when :processing then "blue"
    when :completed then "green"
    when :failed then "red"
    when :refunded then "orange"
    end
  end
end

# Use it naturally - the enum is part of your model
order = Order.find(1)
order.payment_status.completed?       # => true
order.payment_status.can_refund?      # => true
order.payment_status.icon             # => "check-circle"
order.payment_status.color            # => "green"

# Safe access with bracket notation - raises error for invalid values
status = PaymentStatusEnum[:completed]  # ✓ Returns enum instance
status = PaymentStatusEnum[:invalid]    # ✗ Raises ArgumentError

# Validation in models
class Order < ApplicationRecord
  swifter_enum :payment_status, PaymentStatusEnum
  validates :payment_status, swifter_enum: true
end

order.payment_status  # => #<PaymentStatusEnum @value=:completed>

# Flexible equality checking - all of these work:
order.payment_status == :completed           # => true (symbol comparison)
order.payment_status == "completed"          # => true (string comparison)
order.payment_status == other.payment_status # => true (enum instance comparison)

# Use in case statements naturally
case order.payment_status
when :pending    then "Waiting for payment"
when :completed  then "All done!"
when :failed     then "Something went wrong"
end

# Or in arrays
[:completed, :refunded].include?(order.payment_status)  # => true

# Familiar Rails enum syntax
class Order < ApplicationRecord
  swifter_enum :payment_status, PaymentStatusEnum
  swifter_enum :priority, PriorityEnum
end

# Standard Rails enum features work unchanged:
order.payment_status = :processing        # Set with symbol, string, or enum instance
order.payment_status = "processing"       # String works too
order.payment_status = PaymentStatusEnum[:processing]  # Or enum instance
order.completed!                          # Bang method sets and saves
order.completed?                          # => true (query method)
order.not_completed?                      # => false (negative query)

Order.completed                           # Scope returning all completed orders
Order.not_completed                       # Scope returning all non-completed orders

order.payment_status      # => #<PaymentStatusEnum @value=:completed>

# Both setters work
order.payment_status = :pending           # Symbol
order.payment_status = PaymentStatusEnum[:pending]  # Enum instance

# Raw methods provide an 'escape hatch' to standard Rails enum handling
order.payment_status_raw  # => "completed" (original Rails enum value)
Order.payment_status_raws  # => {"pending"=>0, "processing"=>10, ...}

class SubscriptionTierEnum < SwifterEnum::Base
  set_values ({
    free: 0,
    basic: 10,
    pro: 20,
    enterprise: 30
  })

  def price
    case value
    when :free then 0
    when :basic then 9.99
    when :pro then 29.99
    when :enterprise then 99.99
    end
  end

  def features
    case value
    when :free then ["5 projects", "Basic support"]
    when :basic then ["20 projects", "Email support", "API access"]
    when :pro then ["Unlimited projects", "Priority support", "Advanced API"]
    when :enterprise then ["Everything in Pro", "SSO", "Dedicated support", "SLA"]
    end
  end

  def can_upgrade_to?(other_tier)
    return false unless other_tier.is_a?(self.class)
    self.class.values[other_tier.value] > self.class.values[value]
  end

  def badge_color
    case value
    when :free then "gray"
    when :basic then "blue"
    when :pro then "purple"
    when :enterprise then "gold"
    end
  end
end

# Clean, expressive code in your views and controllers
current_user.subscription_tier.price           # => 29.99
current_user.subscription_tier.features        # => ["Unlimited projects", ...]
current_user.subscription_tier.can_upgrade_to?(SubscriptionTierEnum[:enterprise])  # => true

# In your views
<span class="badge badge-<%= current_user.subscription_tier.badge_color %>">
  <%= current_user.subscription_tier.t %>
</span>
<ul>
  <% current_user.subscription_tier.features.each do |feature| %>
    <li><%= feature %></li>
  <% end %>
</ul>

class CameraEnum < SwifterEnum::Base
  # Using integers for database storage (most common)
  set_values ({ videographer: 0, handcam: 1 })

  # Or use strings for database storage (see "Using string values to store Enum" section)
  # set_values [:videographer, :handcam]

  def icon
    case @value
    when :videographer then "icons/video-camera"
    when :handcam then "icons/hand-stop"
    end
  end
end

class Video < ApplicationRecord
  swifter_enum :camera, CameraEnum

  # Optional validation
  validates :camera, swifter_enum: true
end

video = Video.first

# Getter returns an enum instance (not a string/symbol)
video.camera                    # => #<CameraEnum:0x000... @value=:handcam>
video.camera.value              # => :handcam (access underlying symbol)

# Multiple ways to set values
video.camera = :videographer                    # Symbol
video.camera = "videographer"                   # String
video.camera = CameraEnum[:videographer]        # Enum instance
video.camera = other_video.camera              # Copy from another instance

# Call your custom methods
video.camera.icon               # => "icons/video-camera"

# Works naturally with conditionals
if video.camera == :handcam
  # Do something
end