rails_stuff 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b4d05c4a1131bbc5cf6e653451d50aa7f09a2902
-  data.tar.gz: 7463af96e7f8c64b3399fb6ce6e9c701b852533a
+  metadata.gz: 0a6bd04d2e9f8e71c29e7b70748e3f1529715e0c
+  data.tar.gz: fa5c7003161e787b1886de2b3c6e10955c812728
 SHA512:
-  metadata.gz: 51871432200910ce3c7e71f4cad3f4112a87c5ddba4bae34a773b179192333e6e1ace524337f8ae23fc9a22d51eaf03c3efca4b202e019f55cb2d294c6c0770e
-  data.tar.gz: 439fa7ded29c96cf88db521c40c6a60039d8f6db7e74fe961cbebe97c9e907f9e8f875ec5369eb1abba3e0d1f5de6ec04f4298c7943e5b0f709814769a3c6660
+  metadata.gz: fa5e2a577b9de17bab80c9caf6e6e323d9637969f135e701042745271c9b60422d627a27c07311355feae66c2d29d4918ae498f5db542db1c0a50713a7c09c90
+  data.tar.gz: a70871bf1a0814cd0551a6ad8a7f596b0912751925c04a5353920fdafcd55234344d7e8bb8a0e90c467455fcd3223cf0e3060b0d3c45bd0e21fc57be72d2632d

data/.rubocop.yml

@@ -1,23 +1,31 @@
 AllCops:
-  RunRailsCops: true
+  Exclude:
+    - lib/rails_stuff/generators/*/templates/*.rb
+    - tmp/**/*
+Rails: {Enabled: true}
 
+Style/Alias: {Enabled: false}
 Style/AlignParameters:
   # Disable, till rubocop supports combination of styles.
   # Use one of this styles where appropriate, keep it clean, compact and readable.
   Enabled: false
-  EnforcedStyle:
-  - aligned
-  - with_fixed_indentation
+  # EnforcedStyle:
+  # - with_first_parameter
+  # - with_fixed_indentation
 Style/ClosingParenthesisIndentation: {Enabled: false}
 Style/Documentation: {Enabled: false}
 Style/DotPosition: {EnforcedStyle: trailing}
 Style/IfUnlessModifier: {Enabled: false}
+Style/Lambda: {Enabled: false}
 Style/ModuleFunction: {Enabled: false}
+Style/MultilineMethodCallIndentation: {EnforcedStyle: indented}
 Style/MultilineOperationIndentation: {EnforcedStyle: indented}
+Style/NestedParenthesizedCalls: {Enabled: false}
 Style/PredicateName: {Enabled: false}
 Style/SignalException: {EnforcedStyle: only_raise}
 Style/SpaceInsideHashLiteralBraces: {EnforcedStyle: no_space}
-Style/TrailingComma: {Enabled: false}
+Style/TrailingCommaInArguments: {Enabled: false}
+Style/TrailingCommaInLiteral: {EnforcedStyleForMultiline: comma}
 
 Metrics/AbcSize: {Max: 21}
 Metrics/LineLength: {Max: 100}

data/CHANGELOG.md

@@ -1,3 +1,34 @@
+## Unreleased
+
+### Controllers
+
+- `belongs_to`.
+- `resource_helper` generates enquirer method.
+- `resources_controller kaminari: false` to skip kaminari for the only controller.
+- `has_sort_scope` can use custom order method.
+- Fix: removed source_for_collection from action_methods.
+
+### Models
+
+- Statusable supports mappings (store status as integer) and suffixes.
+- AssociationWriter to override `#field=` & `#field_id=` in single instruction.
+- Limit retries count for RandomUniqAttr (default to 10).
+
+### Helpers
+
+- `Helpers::Translation` methods can raise errors on missing translations.
+  It respects app's `raise_on_missing_translations`, and can be configured manually.
+
+### Tests
+
+- Concurrency helper.
+- RSpec configurator.
+
+Misc
+
+- RequireNested to require all files in subdirectory.
+- `rails g concern %parent%/%module%` generator for concerns.
+
 ## 0.4.0
 
 - TypesTracker defines scopes for every type.

data/Gemfile

@@ -18,7 +18,7 @@ group :development do
   gem 'rspec-its', '~> 1.1.0'
   gem 'rspec-rails', '~> 3.3.3'
 
-  gem 'rubocop', '~> 0.33.0'
+  gem 'rubocop', '~> 0.37.2'
 
   gem 'coveralls', '~> 0.8.2', require: false
 end

data/README.md

@@ -16,6 +16,8 @@ Collection of useful modules for Rails.
 
 - __[NullifyBlankAttrs](#nullifyblankattrs)__
   Proxies writers to replace empty values with `nil`.
+- __[AssociationWriter](#associationwriter)__
+  Override both writers with single instruction.
 - __[RandomUniqAttr](#randomuniqattr)__
   You generate random values for attributes, it'll ensure they are uniq.
 - __[Statusable](#statusable)__
@@ -34,6 +36,9 @@ Collection of useful modules for Rails.
   `require_permitted` helper.
 - __UrlFor__
   `#url_for_keeping_params` merges passed options with request's query params.
+- __[RequireNested](#requirenested)__
+  helper to load files in subdirectory.
+- `rails g concern %parent%/%module%` generator for concerns.
 
 #### Helpers:
 
@@ -53,6 +58,10 @@ __[Helpers usage](#helpers-usage)__
 
 - __Response__
   `#json_body` to test json responses.
+- __Configurator__
+  Provides useful basic configuration for RSpec.
+- __Concurrency__
+  Helpers for testing with concurrent requests.
 
 __[Test helpers usage](#test-helpers-usage)__
 
@@ -104,7 +113,7 @@ check docs & code (press `t` on github) if you miss something.
 
 ### ResourcesController
 
-Similar to [InheriteResource](https://github.com/josevalim/inherited_resources)
+Similar to [InheritedResource](https://github.com/josevalim/inherited_resources)
 but much simpler. It adds implementations for basic actions and
 accessors for collection and resource. There is no options for almost everything,
 but it's easy to extend.
@@ -127,14 +136,20 @@ class ProjectsController < ApplicationController
     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
 ```
 
-There is built-in support for pagination with Kaminari.
-It's enabled automatically if `kaminari` gem is loaded.
+There is built-in support for `has_scope` gem and pagination with Kaminari.
 
 Currently depends on `gem 'responders', '> 2.0'`.
 
@@ -144,7 +159,7 @@ Currently depends on `gem 'responders', '> 2.0'`.
 # in controller
 extend RailsStuff::SortScope # when using without railtie
 
-sort_scope by: [:name, :created_at, :balance], default: [:name]
+has_sort_scope by: [:name, :created_at, :balance], default: [:name]
 
 # this scope will accept
 #   - `sort=name`
@@ -166,6 +181,17 @@ extend RailsStuff::NullifyBlankAttrs # when using without railtie
 nullify_blank_attrs :email, :title
 ```
 
+### AssociationWriter
+
+ActiveRecord's association can be updated with object and by object id.
+Owerwrite this both writers with single instruction:
+
+```ruby
+association_writer :product do |val|
+  super(val).tap { update_price if product }
+end
+```
+
 ### RandomUniqAttr
 
 Uses database's UNIQUE constraints and transactions to generate uniq random values.
@@ -194,8 +220,9 @@ end
 
 ```ruby
 class User < ActiveRecord::Base
-  extend RailsStuff::RandomUniqAttr # when using without railtie
+  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
 
@@ -204,6 +231,12 @@ class User < ActiveRecord::Base
   # :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:
@@ -212,6 +245,8 @@ 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.status_name(:active)
@@ -240,9 +275,7 @@ class Project
 
   # If you want to show all available descendants in development
   # (ex. in dropdown/select), you definitely want this:
-  eager_load_types! # will load all files in app/models/project
-  # or pass folder explicitly:
-  eager_load_types!('lib/path/to/projects')
+  require_nested # will load all .rb files in app/models/project
 end
 
 class Project::Big < Project
@@ -324,6 +357,21 @@ params.require_permitted(:access_token, :refresh_token)
 params.permit(:access_token, :refresh_token).require(:access_token, :refresh_token)
 ```
 
+### RequireNested
+
+```ruby
+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
+```
+
 ### Helpers usage
 
 Include helper module into `ApplicationHelper`.
@@ -380,6 +428,21 @@ Note that `hashie` conflicts with `Hash` methods, so `.json_body.key` or
 `.json_body.hash` will not work as expected (or at all).
 Use `json_body['key']` instead.
 
+There is `Configurator` with useful RSpec configs:
+
+```ruby
+RSpec.configure do |config|
+  RailsStuff::TestHelpers::Configurator.tap do |configurator|
+    # Setup DatabaseCleaner with basic settings:
+    configurator.database_cleaner(config)
+    # Flush redis after suite and exampes with `flush_redis: true`:
+    configurator.redis(config)
+    # Run debugger after failed tests:
+    configurator.debug(config)
+  end
+end
+```
+
 ### PluginManager
 
 Provides simple way to create jQuery plugins. Create class and PluginManager

data/lib/rails_stuff/association_writer.rb

@@ -0,0 +1,15 @@
+module RailsStuff
+  # ActiveRecord's association can be updated with object and by object id.
+  # Owerwrite this both writers with single instruction:
+  #
+  #   association_writer :product do |val|
+  #     super(val).tap { update_price if product }
+  #   end
+  #
+  module AssociationWriter
+    def association_writer(name, &block)
+      define_method("#{name}=", &block)
+      define_method("#{name}_id=", &block)
+    end
+  end
+end

data/lib/rails_stuff/engine.rb

@@ -1,13 +1,15 @@
 require 'rails/railtie'
 
 module RailsStuff
-  MODULES = {
+  MODULES = { # rubocop:disable MutableConstant
+    require_nested:       [:require, -> { RequireNested.setup }],
+    association_writer:   :model,
     nullify_blank_attrs:  :model,
     random_uniq_attr:     :model,
     statusable:           :model,
     resources_controller: [
       :controller,
-      -> { ResourcesController.kaminari! if defined?(::Kaminari) },
+      -> { ResourcesController.use_kaminari! if defined?(::Kaminari) },
     ],
     sort_scope: -> { defined?(::HasScope) && :controller },
     strong_parameters: -> { defined?(ActionController::Parameters) && :require },
@@ -53,5 +55,9 @@ module RailsStuff
     initializer :rails_stuff_setup_modules, after: :load_config_initializers do
       RailsStuff.setup_modules!
     end
+
+    generators do
+      require 'rails_stuff/generators/concern/concern_generator'
+    end
   end
 end

data/lib/rails_stuff/generators/concern/USAGE

@@ -0,0 +1,11 @@
+Description:
+    Generates concern for the class.
+
+Example:
+    `rails generate concern User::Authentication`
+
+        create  app/models/user/authentication.rb
+
+    `rails generate concern admin_controller/localized`
+
+        create  app/controllers/admin_controller/localized.rb

data/lib/rails_stuff/generators/concern/concern_generator.rb

@@ -0,0 +1,26 @@
+require 'rails/generators'
+
+module RailsStuff
+  module Generators
+    class ConcernGenerator < Rails::Generators::NamedBase # :nodoc:
+      argument :base,
+        type: :string,
+        required: false,
+        banner: 'Base dir with the class',
+        description: 'Use it when class is not inside app/models or app/controllers.'
+
+      namespace 'rails:concern'
+      source_root File.expand_path('../templates', __FILE__)
+
+      def create_concern_files
+        template 'concern.rb', File.join(base_path, "#{file_path}.rb")
+      end
+
+      private
+
+      def base_path
+        base || file_path.include?('_controller/') ? 'app/controllers' : 'app/models'
+      end
+    end
+  end
+end

data/lib/rails_stuff/generators/concern/templates/concern.rb

@@ -0,0 +1,14 @@
+module <%= class_name %>
+  extend ActiveSupport::Concern
+
+  included do
+  end
+
+  module ClassMethods
+    def class_method
+    end
+  end
+
+  def instance_method
+  end
+end

data/lib/rails_stuff/helpers/links.rb

@@ -2,7 +2,7 @@ module RailsStuff
   module Helpers
     # Link helpers for basic actions.
     module Links
-      ICONS = {
+      ICONS = { # rubocop:disable MutableConstant
         destroy:  -> { translate_action(:destroy) },
         edit:     -> { translate_action(:edit) },
         new:      -> { translate_action(:new) },

data/lib/rails_stuff/helpers/translation.rb

@@ -1,10 +1,18 @@
 module RailsStuff
   module Helpers
     module Translation
+      class << self
+        def i18n_raise
+          @i18n_raise ||= defined?(Rails) && ActionView::Base.raise_on_missing_translations
+        end
+
+        attr_writer :i18n_raise
+      end
+
       # Translates & caches actions within `helpers.actions` scope.
       def translate_action(action)
         @translate_action ||= Hash.new do |h, key|
-          h[key] = I18n.t("helpers.actions.#{key}")
+          h[key] = I18n.t("helpers.actions.#{key}", raise: Translation.i18n_raise)
         end
         @translate_action[action]
       end
@@ -12,7 +20,10 @@ module RailsStuff
       # Translates & caches confirmations within `helpers.confirmations` scope.
       def translate_confirmation(action)
         @translate_confirmation ||= Hash.new do |h, key|
-          h[key] = I18n.t("helpers.confirmations.#{key}", default: [:'helpers.confirm'])
+          h[key] = I18n.t("helpers.confirmations.#{key}",
+            default: [:'helpers.confirm'],
+            raise: Translation.i18n_raise,
+          )
         end
         @translate_confirmation[action]
       end
@@ -20,7 +31,7 @@ module RailsStuff
       # Translates boolean values.
       def yes_no(val)
         @translate_yes_no ||= Hash.new do |h, key|
-          h[key] = I18n.t("helpers.yes_no.#{key}")
+          h[key] = I18n.t("helpers.yes_no.#{key}", raise: Translation.i18n_raise)
         end
         @translate_yes_no[val.to_s]
       end

data/lib/rails_stuff/random_uniq_attr.rb

@@ -10,6 +10,7 @@ module RailsStuff
   #
   module RandomUniqAttr
     DEFAULT_GENERATOR = ->(*) { SecureRandom.hex(32) }
+    MAX_ATTEMPTS = 10
 
     class << self
       # Made from `Devise.firendly_token` with increased length.
@@ -23,9 +24,10 @@ module RailsStuff
     #
     #     random_uniq_attr(:code) { |instance| my_random(instance) }
     #
-    def random_uniq_attr(field, &block)
+    def random_uniq_attr(field, **options, &block)
       set_method = :"set_#{field}"
       generate_method = :"generate_#{field}"
+      max_attempts = options.fetch(:max_attempts) { MAX_ATTEMPTS }
 
       after_create set_method, unless: :"#{field}?"
 
@@ -34,12 +36,15 @@ module RailsStuff
 
       # def set_key
       define_method(set_method) do
+        attempt = 0
         begin
           raise 'Available only for persisted record' unless persisted?
           transaction(requires_new: true) do
             update_column field, self.class.send(generate_method, self)
           end
         rescue ActiveRecord::RecordNotUnique
+          attempt += 1
+          raise if attempt > max_attempts
           retry
         end
       end

data/lib/rails_stuff/require_nested.rb

@@ -0,0 +1,22 @@
+require 'active_support/dependencies'
+
+module RailsStuff
+  module RequireNested
+    class << self
+      # Make #require_nested available in module.
+      def setup
+        Module.include(self)
+      end
+    end
+
+    module_function
+
+    # Requires nested modules with `require_dependency`.
+    # Pass custom directory to require its content.
+    # By default uses caller's filename with stripped `.rb` extension from.
+    def require_nested(dir = 0)
+      dir = caller_locations(dir + 1, 1)[0].path.sub(/\.rb$/, '') if dir.is_a?(Integer)
+      Dir["#{dir}/*.rb"].each { |file| require_dependency file }
+    end
+  end
+end

data/lib/rails_stuff/resources_controller/basic_helpers.rb

@@ -3,16 +3,6 @@ module RailsStuff
     module BasicHelpers
       extend ActiveSupport::Concern
 
-      class << self
-        # Make source_for_collection use Kaminari-style scopes
-        # to paginate relation.
-        def kaminari!
-          define_method(:source_for_collection) do
-            source_relation.page(params[:page]).per(params[:per])
-          end
-        end
-      end
-
       included do
         helper_method :resource, :collection
         self.after_save_action = :show
@@ -51,17 +41,6 @@ module RailsStuff
           permitted_attrs.concat attrs
         end
 
-        # This method overrides default `has_scope`. It calls default implementation
-        # and overrides `collection` to use `apply_scope`.
-        def has_scope(*)
-          super.tap do
-            define_method :collection do
-              @_collection ||= apply_scopes(source_for_collection)
-            end
-            protected :collection
-          end
-        end
-
         # Prevent CanCan's implementation.
         def authorize_resource
           raise 'use `before_action :authorize_resource!` instead'
@@ -117,15 +96,21 @@ module RailsStuff
       def after_save_url
         action = self.class.after_save_action
         if action == :index
-          url_for action: :index
+          index_url
         else
           url_for action: action, id: resource
         end
       end
 
       # URL to be used in `Location` header & to redirect after
-      # resource was destroyed. Default to `:index` action.
+      # resource was destroyed. Default to #index_url.
       def after_destroy_url
+        index_url
+      end
+
+      # Extracted from #after_save_url and #after_destroy_url because they use
+      # same value. It's easier to override this urls in one place.
+      def index_url
         url_for action: :index
       end
 
@@ -134,7 +119,7 @@ module RailsStuff
       def resource_params
         @_resource_params ||= begin
           key = self.class.resource_param_name
-          params.permit(key => permitted_attrs)[key] || {}
+          params.permit(key => permitted_attrs)[key] || params.class.new
         end
       end
 

data/lib/rails_stuff/resources_controller/belongs_to.rb

@@ -0,0 +1,35 @@
+module RailsStuff
+  module ResourcesController
+    module BelongsTo
+      class << self
+        # Builds lambda to use as `#source_relation`.
+        def source_relation(subject, collection, optional: false, **)
+          check_subject = :"#{subject}?"
+          lambda do
+            if optional && !send(check_subject)
+              super()
+            else
+              send(subject).public_send(collection)
+            end
+          end
+        end
+
+        # Builds lambda to use as `#index_url`
+        def index_url(subject, *, field: nil, param: nil)
+          field ||= :"#{subject}_id"
+          param ||= field
+          -> { url_for action: :index, param => resource.public_send(field) }
+        end
+      end
+
+      # Defines resource helper and source relation
+      def resource_belongs_to(subject, resource_helper: true, urls: true, **options)
+        resource_helper(subject) if resource_helper
+        collection = options[:collection] || resource_class.model_name.plural
+        source_relation_proc = BelongsTo.source_relation(subject, collection, options)
+        protected define_method(:source_relation, &source_relation_proc)
+        protected define_method(:index_url, &BelongsTo.index_url(subject, urls)) if urls
+      end
+    end
+  end
+end

data/lib/rails_stuff/resources_controller/has_scope_helpers.rb

@@ -0,0 +1,20 @@
+module RailsStuff
+  module ResourcesController
+    module HasScopeHelpers
+      # This method overrides default `has_scope` so it include helpers from
+      # InstanceMethods only when this method is called.
+      def has_scope(*)
+        super.tap { include InstanceMethods }
+      end
+
+      module InstanceMethods
+        protected
+
+        # Applies `has_scope` scopes to original source.
+        def source_for_collection
+          apply_scopes(super)
+        end
+      end
+    end
+  end
+end

data/lib/rails_stuff/resources_controller/kaminari_helpers.rb

@@ -0,0 +1,22 @@
+module RailsStuff
+  module ResourcesController
+    module KaminariHelpers
+      protected
+
+      # Make source_for_collection use Kaminari-style scopes to paginate relation.
+      def source_for_collection
+        super.page(params[:page]).per(params[:per])
+      end
+
+      module ConfigMethods
+        def use_kaminari!(val = true)
+          @use_kaminari = val
+        end
+
+        def use_kaminari?
+          @use_kaminari
+        end
+      end
+    end
+  end
+end

data/lib/rails_stuff/resources_controller/resource_helper.rb

@@ -15,15 +15,21 @@ module RailsStuff
       # - `class` - class name, default to `resource_name.classify`
       # - `param` - param name, default to `resource_name.foreign_key`
       def resource_helper(resource_name, **options)
-        helper_method resource_name
+        helper_method resource_name, :"#{resource_name}?"
         resource_name = resource_name.to_s
+        class_name = options[:class] || resource_name.classify
+        param_key = options[:param] || resource_name.foreign_key
 
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          protected
+
           def #{resource_name}
-            @#{resource_name} ||= #{options[:class] || resource_name.classify}.
-              find params[:#{options[:param] || resource_name.foreign_key}]
+            @#{resource_name} ||= #{class_name}.find(params[:#{param_key}])
+          end
+
+          def #{resource_name}?
+            params.key?(:#{param_key})
           end
-          protected :#{resource_name}
         RUBY
       end
     end

data/lib/rails_stuff/resources_controller.rb

@@ -7,34 +7,46 @@ module RailsStuff
   module ResourcesController
     extend ActiveSupport::Autoload
 
-    class << self
-      delegate :kaminari!, to: 'RailsStuff::ResourcesController::BasicHelpers'
-    end
-
     autoload :Actions
     autoload :BasicHelpers
+    autoload :BelongsTo
+    autoload :HasScopeHelpers
+    autoload :KaminariHelpers
+    autoload :ResourceHelper
     autoload :Responder
     autoload :StiHelpers
-    autoload :ResourceHelper
+
+    extend KaminariHelpers::ConfigMethods
+
+    class << self
+      def inject(base, **options)
+        base.include BasicHelpers
+        base.include KaminariHelpers if options.fetch(:kaminari) { use_kaminari? }
+        base.include StiHelpers if options[:sti]
+        base.include Actions
+        base.extend HasScopeHelpers
+        base.extend ResourceHelper
+        base.extend BelongsTo
+      end
+    end
 
     # Setups basic actions and helpers in resources controller.
     #
     # #### Options
     #
     # - `sti` - include STI helpers
+    # - `kaminari` - include Kaminari helpers
     # - `after_save_action` - action to use for `after_save_url`
     # - `source_relation` - override `source_relation`
     def resources_controller(**options)
-      include BasicHelpers
-      include StiHelpers if options[:sti]
-      include Actions
-      extend ResourceHelper
+      ResourcesController.inject(self, **options)
 
       respond_to :html
       self.responder = Responder
       self.after_save_action = options[:after_save_action] || after_save_action
 
-      if options[:source_relation] # rubocop:disable GuardClause
+      resource_belongs_to(*options[:belongs_to]) if options[:belongs_to]
+      if options[:source_relation]
         protected define_method(:source_relation, &options[:source_relation])
       end
     end

data/lib/rails_stuff/sort_scope.rb

@@ -23,7 +23,8 @@ module RailsStuff
     #
     # - `by` - array of available fields to sort by,
     # - `default` - default sort expression,
-    # - `only` - bypassed to `has_scope` to limit actions (default to `:index`).
+    # - `only` - bypassed to `has_scope` to limit actions (default to `:index`),
+    # - `order_method` - use custom method to sort instead of `.order`.
     #
     # rubocop:disable ClassVars
     def has_sort_scope(config = {})
@@ -31,6 +32,7 @@ module RailsStuff
       default = config[:default] || :id
       allowed = Array.wrap(config[:by]).map(&:to_s)
       only_actions = config.fetch(:only, :index)
+      order_method = config.fetch(:order_method, :order)
       # Counter added into scope name to allow to define multiple scopes in same controller.
       has_scope("sort_#{@@_sort_scope_id += 1}",
         as:           :sort,
@@ -39,7 +41,8 @@ module RailsStuff
         only:         only_actions,
         type:         :any,
       ) do |c, scope, val|
-        scope.order(SortScope.filter_param(val, c.params, allowed, default))
+        sort_args = SortScope.filter_param(val, c.params, allowed, default)
+        scope.public_send(order_method, sort_args)
       end
     end
     # rubocop:enable ClassVars

data/lib/rails_stuff/statusable.rb

@@ -15,10 +15,13 @@ module RailsStuff
   # - `#status_sym`
   # - `status_select_options` helper.
   #
+  # It supports mapped statuses, just provide a hash with
+  # `{status_name => interna_value}` instead of array of statuses.
   module Statusable
     # Defines all helpers working with `field` (default to `status`).
     # List of values can be given as second argument, otherwise it'll
-    # be read from const with pluralized name of `field` (eg. default to STATUSES).
+    # be read from consts using pluralized name of `field`
+    # (eg. default to `STATUSES_MAPPING`, `STATUSES`).
     #
     # #### Options
     #
@@ -28,29 +31,19 @@ module RailsStuff
     #         has_status_field :delivery_status, %i(shipped delivered)
     #
     #         # this defines #delivery_shipped?, #delivery_shipped! methods
-    #         has_status_field :delivery_status, %i(shipped delivered), prefix: :delivery
+    #         has_status_field :delivery_status, %i(shipped delivered), prefix: :delivery_
+    #
+    # - `suffix`    - similar to `prefix`.
     #
     # - `validate`  - additional options for validatior. `false` to disable it.
-    def has_status_field(field = :status, statuses = nil, **options) # rubocop:disable AbcSize
-      statuses ||= const_get(field.to_s.pluralize.upcase)
-      prefix = options[:prefix]
-
-      if options[:validate] != false
-        validates_inclusion_of field,
-          {in: statuses.map(&:to_s)}.merge!(options.fetch(:validate, {}))
-      end
-
-      statusable_methods.generate_field_methods field, statuses
-
-      # Scope with given status. Useful for has_scope.
-      scope "with_#{field}", ->(status) { where(field => status) }
-
-      statuses.map(&:to_s).each do |status_name|
-        # Scopes for every status.
-        scope "#{prefix}#{status_name}", -> { where(field => status_name) }
-        scope "not_#{prefix}#{status_name}", -> { where.not(field => status_name) }
-        statusable_methods.status_accessor field, status_name, prefix
+    def has_status_field(field = :status, statuses = nil, **options)
+      unless statuses
+        const_name = "#{field.to_s.pluralize.upcase}_MAPPING"
+        const_name = field.to_s.pluralize.upcase unless const_defined?(const_name)
+        statuses = const_get(const_name)
       end
+      generator = statuses.is_a?(Hash) ? MappedBuilder : Builder
+      generator.new(self, field, statuses, options).generate
     end
 
     # Module to hold generated methods.
@@ -58,49 +51,94 @@ module RailsStuff
       # Include generated methods with a module, not right in class.
       @statusable_methods ||= Module.new.tap do |m|
         m.const_set :ClassMethods, Module.new
-        m.extend MethodsGenerator
         include m
         extend m::ClassMethods
       end
     end
 
-    # Generates methods.
-    module MethodsGenerator
-      # Generates all methods for the `field`.
-      def generate_field_methods(field, statuses)
-        field_accessor field
-        translation_helpers field
-        select_options_helper field, statuses
+    # Generates methods and scopes.
+    class Builder
+      attr_reader :model, :field, :statuses, :options, :prefix, :suffix
+      alias_method :statuses_list, :statuses
+
+      def initialize(model, field, statuses, **options)
+        @model = model
+        @field = field
+        @statuses = statuses
+        @options = options
+        @prefix = options[:prefix]
+        @suffix = options[:suffix]
+      end
+
+      def generate
+        validations unless options[:validate] == false
+        field_reader
+        field_writer
+        select_options_helper
+        translation_helpers
+        field_scope
+        value_methods
+      end
+
+      def validations
+        model.validates_inclusion_of field,
+          {in: statuses.map(&:to_s)}.merge!(options.fetch(:validate, {}))
+      end
+
+      # Scope with given status. Useful for has_scope.
+      def field_scope
+        field = self.field
+        define_scope "with_#{field}", ->(status) { where(field => status) }
+      end
+
+      def value_methods
+        field = self.field
+        statuses.map(&:to_s).each do |status_name|
+          # Scopes for every status.
+          define_scope "#{prefix}#{status_name}#{suffix}",
+            -> { where(field => status_name) }
+          define_scope "not_#{prefix}#{status_name}#{suffix}",
+            -> { where.not(field => status_name) }
+          status_accessor status_name, status_name
+        end
       end
 
       # Generates methods for specific value.
-      def status_accessor(field, status_name, prefix = nil)
+      def status_accessor(status_name, value)
+        field = self.field
+
         # Shortcut to check status.
-        define_method "#{prefix}#{status_name}?" do
-          self[field] == status_name
+        define_method "#{prefix}#{status_name}#{suffix}?" do
+          self[field] == value
         end
 
         # Shortcut to update status.
-        define_method "#{prefix}#{status_name}!" do
-          update_attributes!(field => status_name)
+        define_method "#{prefix}#{status_name}#{suffix}!" do
+          update_attributes!(field => value)
         end
       end
 
-      def field_accessor(field)
-        # Make field accept sympbols.
+      # Make field accept sympbols.
+      def field_writer
         define_method "#{field}=" do |val|
           val = val.to_s if val.is_a?(Symbol)
           super(val)
         end
+      end
 
-        # Status as symbol.
+      # Status as symbol.
+      def field_reader
+        field = self.field
         define_method "#{field}_sym" do
-          val = self[field]
+          val = send(field)
           val && val.to_sym
         end
       end
 
-      def translation_helpers(field)
+      def translation_helpers
+        field = self.field
+        sym_method = "#{field}_sym"
+
         # Class-level translation helper.
         generate_class_method "#{field}_name" do |status|
           t(".#{field}_name.#{status}") if status
@@ -108,22 +146,99 @@ module RailsStuff
 
         # Translation helper.
         define_method "#{field}_name" do
-          val = send field
+          val = send(sym_method)
           self.class.t(".#{field}_name.#{val}") if val
         end
       end
 
-      def select_options_helper(field, statuses)
+      def select_options_helper
+        statuses_list = self.statuses_list
         translation_method = :"#{field}_name"
         # Returns array compatible with select_options helper.
         generate_class_method "#{field}_select_options" do |args = {}|
-          filtered_statuses = statuses - Array.wrap(args[:except])
+          filtered_statuses = statuses_list - Array.wrap(args[:except])
           filtered_statuses.map { |x| [send(translation_method, x), x] }
         end
       end
 
+      # Rails 4 doesn't use `instance_exec` for scopes, so we do it manually.
+      def define_scope(name, body)
+        model.singleton_class.send(:define_method, name) do |*args|
+          all.scoping { instance_exec(*args, &body) } || all
+        end
+      end
+
+      def define_method(method, &block)
+        model.statusable_methods.send(:define_method, method, &block)
+      end
+
       def generate_class_method(method, &block)
-        const_get(:ClassMethods).send(:define_method, method, &block)
+        model.statusable_methods::ClassMethods.send(:define_method, method, &block)
+      end
+    end
+
+    # Generates methods and scopes when status names are mapped to internal values.
+    class MappedBuilder < Builder
+      attr_reader :mapping, :statuses_list
+
+      def initialize(*)
+        super
+        @mapping = statuses.with_indifferent_access
+        @statuses_list = statuses.keys
+      end
+
+      def validations
+        model.validates_inclusion_of field,
+          {in: statuses.values}.merge!(options.fetch(:validate, {}))
+      end
+
+      # Scope with given status. Useful for has_scope.
+      def field_scope
+        field = self.field
+        mapping = self.mapping
+        define_scope "with_#{field}", ->(status) do
+          values = Array.wrap(status).map { |x| mapping.fetch(x, x) }
+          where(field => values)
+        end
+      end
+
+      def value_methods
+        field = self.field
+        statuses.each do |status_name, value|
+          # Scopes for every status.
+          define_scope "#{prefix}#{status_name}#{suffix}", -> { where(field => value) }
+          define_scope "not_#{prefix}#{status_name}#{suffix}", -> { where.not(field => value) }
+          status_accessor status_name, value
+        end
+      end
+
+      def field_reader
+        field = self.field
+        inverse_mapping = statuses.stringify_keys.invert
+
+        # Returns status name.
+        define_method field do |mapped = false|
+          val = super()
+          return val unless mapped && val
+          mapped = inverse_mapping[val]
+          raise "Missing mapping for value #{val.inspect}" unless mapped
+          mapped
+        end
+
+        # Status as symbol.
+        define_method "#{field}_sym" do
+          val = public_send(field, true)
+          val && val.to_sym
+        end
+      end
+
+      def field_writer
+        mapping = self.mapping
+        # Make field accept sympbols.
+        define_method "#{field}=" do |val|
+          val = val.to_s if val.is_a?(Symbol)
+          super(mapping.fetch(val, val))
+        end
       end
     end
   end

data/lib/rails_stuff/test_helpers/concurrency.rb

@@ -0,0 +1,71 @@
+require 'active_support/concern'
+require 'active_support/core_ext/array/wrap'
+
+module RailsStuff
+  module TestHelpers
+    module Concurrency
+      extend ActiveSupport::Concern
+
+      class << self
+        # Default threads count
+        attr_accessor :threads_count
+      end
+      @threads_count = 3
+
+      module ClassMethods
+        # Defines subject which runs parent's value in multiple threads concurrently.
+        # Define `thread_args` or `threads_count` with `let` to configure it.
+        def concurrent_subject!
+          metadata[:concurrent] = true
+          subject do
+            super_proc = super()
+            args = defined?(thread_args) && thread_args
+            args ||= defined?(threads_count) && threads_count
+            -> { concurrently(args, &super_proc) }
+          end
+        end
+
+        # Runs given block in current context and nested context with concurrent subject.
+        #
+        #     subject { -> { increment_value_once } }
+        #     # This will create 2 examples. One for current contex, and one
+        #     # for current context where subject will run multiple times concurrently.
+        #     check_concurrent do
+        #       it { should change { value }.by(1) }
+        #     end
+        def check_concurrent(&block)
+          instance_eval(&block)
+          context 'running multiple times concurrently' do
+            concurrent_subject!
+            instance_eval(&block)
+          end
+        end
+      end
+
+      # Runs block concurrently in separate threads.
+      # Pass array of args arrays to run each thread with its own arguments.
+      # Or pass Integer to run specified threads count with same arguments.
+      # Default is to run Concurrency.threads_count threads.
+      #
+      #    concurrently { do_something }
+      #    concurrently(5) { do_something }
+      #    concurrently([[1, opt: true], [2, opt: false]]) do |arg, **options|
+      #      do_something(arg, options)
+      #    end
+      #    # It'll automatically wrap single args into Array:
+      #    concurrently(1, 2, {opt: true}, {opt: false}, [1, opt: false]) { ... }
+      #
+      def concurrently(thread_args = nil)
+        thread_args ||= Concurrency.threads_count
+        threads =
+          case thread_args
+          when Integer
+            Array.new(thread_args) { Thread.new { yield } }
+          else
+            thread_args.map { |args| Thread.new { yield(*Array.wrap(args)) } }
+          end
+        threads.each(&:join)
+      end
+    end
+  end
+end

data/lib/rails_stuff/test_helpers/configurator.rb

@@ -0,0 +1,60 @@
+module RailsStuff
+  module TestHelpers
+    # Collection of useful RSpec configurations.
+    #
+    #     RailsStuff::TestHelpers::Configurator.tap do |configurator|
+    #       configurator.database_cleaner(config)
+    #       # ...
+    #     end
+    #
+    module Configurator
+      module_function
+
+      # Setups database cleaner to use strategy depending on metadata.
+      # By default it uses `:transaction` for all examples and `:truncation`
+      # for features and examples with `concurrent: true`.
+      #
+      # Other types can be tuned with `config.cleaner_strategy` hash &
+      # `config.cleaner_strategy.default`.
+      def database_cleaner(config)
+        config.use_transactional_fixtures = false
+        config.add_setting :cleaner_strategy
+        config.cleaner_strategy = {feature: :truncation}
+        config.cleaner_strategy.default = :transaction
+        config.around do |ex|
+          strategy = ex.metadata[:concurrent] && :truncation
+          strategy ||= config.cleaner_strategy[ex.metadata[:type]]
+          options = strategy == :truncation ? {except: %w(spatial_ref_sys)} : {}
+          DatabaseCleaner.strategy = strategy, options
+          DatabaseCleaner.cleaning { ex.run }
+        end
+      end
+
+      # Setups redis to flush db after suite and before each example with
+      # `flush_redis: :true`. `Rails.redis` client is used by default.
+      # Can be tuned with `config.redis`.
+      def redis(config)
+        config.add_setting :redis
+        config.redis = Rails.redis if defined?(Rails.redis)
+        config.before { |ex| config.redis.flushdb if ex.metadata[:flush_redis] }
+        config.after(:suite) { config.redis.flushdb }
+      end
+
+      # Runs debugger after each failed example. Uses `pry` by default and
+      # runs only for examples with `:debug` tag. This can be configured
+      # with `:debugger` and `:filter` options respectively:
+      #
+      #   configurator.debug(config, filter: {my_tag: :val}, debugger: true)
+      #   # to disable filter:
+      #   configurator.debug(config, filter: nil)
+      def debug(config, filter: {debug: true}, debugger: :pry)
+        config.after(filter) do |ex|
+          if ex.exception
+            debugger == :pry ? binding.pry : self.debugger # rubocop:disable Debugger
+            ex.exception # noop
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_stuff/test_helpers/rails.rb

@@ -4,3 +4,6 @@ require 'rails_stuff/test_helpers/response'
 ActionDispatch::TestResponse.class_eval do
   include RailsStuff::TestHelpers::Response
 end
+
+require 'rails_stuff/test_helpers/concurrency'
+require 'rails_stuff/test_helpers/configurator'

data/lib/rails_stuff/types_tracker.rb

@@ -1,4 +1,5 @@
 require 'active_support/core_ext/class/attribute'
+require 'active_support/deprecation'
 
 module RailsStuff
   # Adds `types_list` method which tracks all descendants.
@@ -29,7 +30,7 @@ module RailsStuff
       else
         types_list << self
       end
-      if types_tracker_base.respond_to?(:scope) && # rubocop:disable GuardClause
+      if types_tracker_base.respond_to?(:scope) &&
           !types_tracker_base.respond_to?(model_name.element)
         type_name = name
         types_tracker_base.scope model_name.element, -> { where(type: type_name) }
@@ -44,10 +45,13 @@ module RailsStuff
 
     # Shortcut to eager load all descendants.
     def eager_load_types!(dir = nil)
-      dir ||= "#{Rails.root}/app/models/#{to_s.underscore}"
-      Dir["#{dir}/*.rb"].each { |file| require_dependency file }
+      RequireNested.require_nested(dir || 2) # skip 1 more because of deprecation
     end
 
+    ActiveSupport::Deprecation.deprecate_methods self,
+      deprecator: ActiveSupport::Deprecation.new('0.6', 'RailsStuff'),
+      eager_load_types!: 'Use RequireNested.require_nested instead'
+
     # Tracks all descendants automatically.
     def inherited(base)
       super

data/lib/rails_stuff/version.rb

@@ -5,7 +5,7 @@ module RailsStuff
 
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 4
+    MINOR = 5
     TINY  = 0
     PRE   = nil
 

data/lib/rails_stuff.rb

@@ -6,13 +6,15 @@ module RailsStuff
   extend ActiveSupport::Autoload
 
   autoload :Helpers
+  autoload :AssociationWriter
   autoload :NullifyBlankAttrs
   autoload :ParamsParser
   autoload :RandomUniqAttr
   autoload :RedisStorage
+  autoload :RequireNested
   autoload :ResourcesController
-  autoload :Statusable
   autoload :SortScope
+  autoload :Statusable
   autoload :TypesTracker
 end
 

data/rails_stuff.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |spec|
   spec.name          = 'rails_stuff'
   spec.version       = RailsStuff::VERSION::STRING
   spec.authors       = ['Max Melentiev']
-  spec.email         = ['m.melentiev@corp.mail.ru']
+  spec.email         = ['melentievm@gmail.com']
 
   spec.summary       = 'Collection of useful modules for Rails'
   spec.homepage      = 'https://github.com/printercu/rails_stuff'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_stuff
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Max Melentiev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-01 00:00:00.000000000 Z
+date: 2016-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -54,7 +54,7 @@ dependencies:
         version: '10.0'
 description: 
 email:
-- m.melentiev@corp.mail.ru
+- melentievm@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -76,7 +76,11 @@ files:
 - lib/assets/stylesheets/rails_stuff/_media_queries.scss
 - lib/net/http/debug.rb
 - lib/rails_stuff.rb
+- lib/rails_stuff/association_writer.rb
 - lib/rails_stuff/engine.rb
+- lib/rails_stuff/generators/concern/USAGE
+- lib/rails_stuff/generators/concern/concern_generator.rb
+- lib/rails_stuff/generators/concern/templates/concern.rb
 - lib/rails_stuff/helpers.rb
 - lib/rails_stuff/helpers/all.rb
 - lib/rails_stuff/helpers/bootstrap.rb
@@ -89,15 +93,21 @@ files:
 - lib/rails_stuff/params_parser.rb
 - lib/rails_stuff/random_uniq_attr.rb
 - lib/rails_stuff/redis_storage.rb
+- lib/rails_stuff/require_nested.rb
 - lib/rails_stuff/resources_controller.rb
 - lib/rails_stuff/resources_controller/actions.rb
 - lib/rails_stuff/resources_controller/basic_helpers.rb
+- lib/rails_stuff/resources_controller/belongs_to.rb
+- lib/rails_stuff/resources_controller/has_scope_helpers.rb
+- lib/rails_stuff/resources_controller/kaminari_helpers.rb
 - lib/rails_stuff/resources_controller/resource_helper.rb
 - lib/rails_stuff/resources_controller/responder.rb
 - lib/rails_stuff/resources_controller/sti_helpers.rb
 - lib/rails_stuff/sort_scope.rb
 - lib/rails_stuff/statusable.rb
 - lib/rails_stuff/strong_parameters.rb
+- lib/rails_stuff/test_helpers/concurrency.rb
+- lib/rails_stuff/test_helpers/configurator.rb
 - lib/rails_stuff/test_helpers/rails.rb
 - lib/rails_stuff/test_helpers/response.rb
 - lib/rails_stuff/types_tracker.rb
@@ -124,9 +134,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Collection of useful modules for Rails
 test_files: []
-has_rdoc: