module Audited::Auditor::AuditedClassMethods

def audit_as(user, &block)
  Audited.audit_class.as_user(user, &block)
end

def audited_columns
  @audited_columns ||= column_names - non_audited_columns
end

def auditing_enabled
  Audited.store.fetch("#{table_name}_auditing_enabled", true) && Audited.auditing_enabled
end

def auditing_enabled=(val)
  Audited.store["#{table_name}_auditing_enabled"] = val
end

def calculate_non_audited_columns
  if audited_options[:only].present?
    (column_names | default_ignored_attributes) - audited_options[:only]
  elsif audited_options[:except].present?
    default_ignored_attributes | audited_options[:except]
  else
    default_ignored_attributes
  end
end

def default_ignored_attributes
  [primary_key, inheritance_column] | Audited.ignored_attributes
end

def disable_auditing
  self.auditing_enabled = false
end

def enable_auditing
  self.auditing_enabled = true
end

def non_audited_columns
  @non_audited_columns ||= calculate_non_audited_columns
end

def non_audited_columns=(columns)
  @audited_columns = nil # reset cached audited columns on assignment
  @non_audited_columns = columns.map(&:to_s)
end

def normalize_audited_options
  audited_options[:on] = Array.wrap(audited_options[:on])
  audited_options[:on] = [:create, :update, :destroy] if audited_options[:on].empty?
  audited_options[:only] = Array.wrap(audited_options[:only]).map(&:to_s)
  audited_options[:except] = Array.wrap(audited_options[:except]).map(&:to_s)
  max_audits = audited_options[:max_audits] || Audited.max_audits
  audited_options[:max_audits] = Integer(max_audits).abs if max_audits
end

def with_auditing
  auditing_was_enabled = auditing_enabled
  enable_auditing
  yield
ensure
  disable_auditing unless auditing_was_enabled
end

def without_auditing
  auditing_was_enabled = auditing_enabled
  disable_auditing
  yield
ensure
  enable_auditing if auditing_was_enabled
end