gem 'rails_stuff'

# Disable auto-setup:
RailsStuff.load_modules = []

# Enable particular modules:
RailsStuff.load_modules = %i(sort_scope statusable)

class ApplicationController < ActionController::Base
  extend RailsStuff::ResourcesController # when using without railtie
end

class UsersController < ApplicationController
  resources_controller
  permit_attrs :name, :email
end

class ProjectsController < ApplicationController
  resources_controller sti: true,
    after_save_action: :index,
    source_relation: -> { user.projects }
  resource_helper :user

  # or just
  resources_controller sti: true,
    after_save_action: :index,
    belongs_to: :user
    # `belongs_to: [:user, optional: true]` for shallow routes

  permit_attrs :name
  permit_attrs_for Project::External, :company
  permit_attrs_for Project::Internal, :department
end

# in controller
extend RailsStuff::SortScope # when using without railtie

has_sort_scope by: [:name, :created_at, :balance], default: [:name]

# this scope will accept
#   - `sort=name`
#   - `sort=name&sort_desc=true`
#   - `sort[name]&sort[created_at]`
#   - `sort[name]&sort[created_at]=desc

# access current sort scope hash with
current_sort_scope # => {'name' => :desc} or {'name' => :asc, 'id' => :desc}

# in model
extend RailsStuff::NullifyBlankAttrs # when using without railtie

nullify_blank_attrs :email, :title

association_writer :product do |val|
  super(val).tap { update_price if product }
end

# in model
extend RailsStuff::RandomUniqAttr # when using without railtie

# Uses DEFAULT_GENERATOR which is SecureRandom(32)
random_uniq_attr :token

# Uses custom generator, which takes template from settings
random_uniq_attr(:code) do |instance|
  MyGenerator.generate(instance.parent.code_template)
end

class User < ActiveRecord::Base
  extend RailsStuff::Statusable # when using without railtie

  # Setup with array and it'll store status values as strings.
  STATUSES = %i(confirmed banned)
  has_status_field # uses #status field and STATUSES as values

  # Or pass everything explicitly
  has_status_field :subscription_status, %i(expired active), prefix: :subs_
  # :prefix is used for methods that are build
end

class Order < ActiveRecord::Base
  # Provide hash, and it'll store mapped values in database.
  STATUSES_MAPPING = {submitted: 1, confirmed: 2, delivered: 3}
  has_status_field
end

user = User.first

# And you get:
# Scopes
User.confirmed.subs_active
User.not_banned.not_subs_expired
# Useful with has_scope
User.with_status(param[:status]).with_subscription_status(params[:subs_status])
# When using mapped values, scopes will accept status names:
Order.with_status(:confirmed)

# Translation & select helpers (requires activemodel_translation gem)
User.statuses.translate(:active)
user.subscription_status_name # translates current status
User.statuses.select_options
User.subscription_statuses.select_options except: [:expired]
Order.statuses.map([:submitted, :delivered]) # => [1, 3]
Order.statuses.unmap([1, 3]) # => [:submitted, :delivered]

# Accessors
user.status = 'confirmed' or user.confirmed!
user.status_sym # :confirmed
user.subscription_status = :active or user.subs_active!
user.subscription_status # 'active'
user.banned? or user.subs_expired?

# ... and inclusion validator

class Project
  extend RailsStuff::TypesTracker
  # you can also override default list class (Array) with:
  self.types_list_class = FilterableArray
  # smth ...

  # If you want to show all available descendants in development
  # (ex. in dropdown/select), you definitely want this:
  require_nested # will load all .rb files in app/models/project
end

class Project::Big < Project
  unregister_type # remove this class from types_list

  # Or add options for custom list.
  # Following will call types_list.add Project::Big, :arg, option: :example
  register_type :arg, option: :example
end

class Project::Internal < Project::Big; end
class Project::External < Project::Big; end
class Project::Small < Project; end

Project.types_list # [Internal, External, Small]

# Scopes for each type:
Project.internal or Project.big

ParamsParser.parse_int(params[:field]) # _float, _decimal, _string, _boolean, _datetime
ParamsParser.parse_int_array(params[:field_with_array])
ParamsParser.parse_json(json_string)

# There is basic .parse method. It runs block only if input is not nil
# and reraises all errors with ParamsParser::Error
ParamsParser.parse(input) { |x| this_can_raise_exception(x) }

# So you can handle all errors in controller with
rescue_from ParamsParser::Error, with: -> { head :bad_request }

class Model
  extend RailsStuff::SedisStorage

  self.redis_prefix = :other_prefix # default to underscored model name

  # override .dump, .load for custom serialization. Default to Marshal

  # It uses Rails.redis_pool by default. Override it with
  self.redis_pool = ConnectionPool.new { Redis.new(my_options) }
end

Model.get('key') # GET other_prefix:key
Model.get(['composite', 'key']) # GET other_prefix:composite:key
# .delete works the same way

Model.set('key', data) or Model.set(['composite', 'key'], data)
next_id = Model.set(nil, data) # auto-incremented per-model id
next_id = Model.set(['composite', nil], data) # auto-incremented per-scope id
Model.set(id, data, ex: 10) # pass options for redis
# Or set per-model options for all .set requests:
Model.redis_set_options = {ex: 10}

# generate ids:
Model.next_id or Model.next_id(['composite', 'scope'])
Model.reset_id_seq or Model.reset_id_seq(['composite', 'scope'])

params.require_permitted(:access_token, :refresh_token)
# instead of
params.permit(:access_token, :refresh_token).require(:access_token, :refresh_token)

class Project < ApplicationRecord
  # To load all files in app/models/project with require_dependency:
  require_nested
  # or pass folder explicitly:
  require_nested('lib/path/to/projects')

  # For non-rails apps use
  RailsStuff::RequireNested.require_nested
  # or call RailsStuff::RequireNested.setup to add #require_nested to Module
end

translate_action(:edit) or translate_action(:delete)
link_to 'x', url_for(resource),
  method: :delete, data: {confirm:  translate_confirmation(:delete)}
translate_confirmation(:purge_all) # Fallback to default: 'Really?'

# There are helpers for basic links, take a look on helpers/links.rb to know
# how to tune it:
link_to_edit or link_to_edit('url') or link_to_edit([:scope, resource])
link_to_destroy or link_to_destroy('url') or link_to_destroy([:scope, resource])

assert_equal({'id' => 1, 'name' => 'John'}, response.json_body)
assert_equal('John', response.json_body['name'])
assert_equal('John', response.json_body.name)

# with rspec-its
subject { get :show, id: resource.id }
its(:json_body) { should include 'id' => 1 }
its('json_body.name') { should eq 'John' }

# Setup DatabaseCleaner with basic settings:
RailsStuff::RSpec.database_cleaner

# Flush redis after suite and exampes with `flush_redis: true`:
RailsStuff::RSpec.redis

# Run debugger after failed tests:
RailsStuff::RSpec.debug

# Clear log/test.log after suite:
RailsStuff::RSpec.clear_logs

# Raise errors from threads:
RailsStuff::RSpec.thread

# Raise errors for all missing I18n translation:
RailsStuff::RSpec.i18n

# Freeze time with for group/example with `:frozen_time` metadata (requires timecop gem):
RailsStuff::RSpec.frozen_time