rails_stuff 0.5.1 → 0.6.0.rc1

data/lib/rails_stuff/statusable.rb

@@ -18,6 +18,20 @@ module RailsStuff
   # It supports mapped statuses, just provide a hash with
   # `{status_name => interna_value}` instead of array of statuses.
   module Statusable
+    autoload :Helper, 'rails_stuff/statusable/helper'
+    autoload :Builder, 'rails_stuff/statusable/builder'
+    autoload :MappedHelper, 'rails_stuff/statusable/mapped_helper'
+    autoload :MappedBuilder, 'rails_stuff/statusable/mapped_builder'
+
+    class << self
+      # Fetches statuses list from model constants. See #has_status_field.
+      def fetch_statuses(model, field)
+        const_name = "#{field.to_s.pluralize.upcase}_MAPPING"
+        const_name = field.to_s.pluralize.upcase unless model.const_defined?(const_name)
+        model.const_get(const_name)
+      end
+    end
+
     # Defines all helpers working with `field` (default to `status`).
     # List of values can be given as second argument, otherwise it'll
     # be read from consts using pluralized name of `field`
@@ -36,17 +50,48 @@ module RailsStuff
     # - `suffix`    - similar to `prefix`.
     #
     # - `validate`  - additional options for validatior. `false` to disable it.
-    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)
+    #
+    # - `helper`    - custom helper class.
+    #
+    # - `builder`   - custom methods builder class.
+    #
+    # - `mapping`   - shortcut for `statuses` param (see examples).
+    #
+    # Pass block to customize methods generation process (see Builder for available methods):
+    #
+    #   # This will define only scope with status names, but no other methods.
+    #   has_status_field do |builder|
+    #     builder.value_scopes
+    #   end
+    #
+    # Examples:
+    #
+    #   # Setup #status field, take list from STATUSES or STATUSES_MAPPING constant.
+    #   has_status_field
+    #   # Custom field, take kist from KINDS or KINDS_MAPPING:
+    #   has_status_field :kind
+    #   # Inline statuses list and options:
+    #   has_status_field :status, %i(one two), prefix: :my_
+    #   has_status_field :status, {one: 1, two: 2}, prefix: :my_
+    #   has_status_field :status, mapping: {one: 1, two: 2}, prefix: :my_
+    #   # Mapped field without options:
+    #   has_status_field :status, {one: 1, two: 2}, {}
+    #   has_status_field :status, mapping: {one: 1, two: 2}
+    #
+    def has_status_field(field = :status, statuses = nil, mapping: nil, **options)
+      statuses ||= mapping || Statusable.fetch_statuses(self, field)
+      is_mapped = statuses.is_a?(Hash)
+      helper_class = options.fetch(:helper) { is_mapped ? MappedHelper : Helper }
+      helper = helper_class.new(self, field, statuses)
+      helper.attach
+      builder_class = options.fetch(:builder) { is_mapped ? MappedBuilder : Builder }
+      if builder_class
+        builder = builder_class.new(helper, options)
+        block_given? ? yield(builder) : builder.generate
       end
-      generator = statuses.is_a?(Hash) ? MappedBuilder : Builder
-      generator.new(self, field, statuses, options).generate
     end
 
-    # Module to hold generated methods.
+    # Module to hold generated methods. Single for all status fields in model.
     def statusable_methods
       # Include generated methods with a module, not right in class.
       @statusable_methods ||= Module.new.tap do |m|
@@ -55,196 +100,5 @@ module RailsStuff
         extend m::ClassMethods
       end
     end
-
-    # 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(status_name, value)
-        field = self.field
-
-        # Shortcut to check status.
-        define_method "#{prefix}#{status_name}#{suffix}?" do
-          self[field] == value
-        end
-
-        # Shortcut to update status.
-        define_method "#{prefix}#{status_name}#{suffix}!" do
-          update_attributes!(field => value)
-        end
-      end
-
-      # 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.
-      def field_reader
-        field = self.field
-        define_method "#{field}_sym" do
-          val = send(field)
-          val && val.to_sym
-        end
-      end
-
-      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
-        end
-
-        # Translation helper.
-        define_method "#{field}_name" do
-          val = send(sym_method)
-          self.class.t(".#{field}_name.#{val}") if val
-        end
-      end
-
-      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_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.
-      # For Rails 5 it's just use `.scope`.
-      def define_scope(name, body)
-        if RailsStuff.rails4?
-          model.singleton_class.send(:define_method, name) do |*args|
-            all.scoping { instance_exec(*args, &body) } || all
-          end
-        else
-          model.scope(name, body)
-        end
-      end
-
-      def define_method(method, &block)
-        model.statusable_methods.send(:define_method, method, &block)
-      end
-
-      def generate_class_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
 end

data/lib/rails_stuff/test_helpers/concurrency.rb

@@ -1,46 +1,15 @@
-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
+      extend self
 
       # Runs block concurrently in separate threads.
       # Pass array of args arrays to run each thread with its own arguments.

data/lib/rails_stuff/test_helpers/integration_session.rb

@@ -0,0 +1,18 @@
+module RailsStuff
+  module TestHelpers
+    module IntegrationSession
+      # Return smth usable instead of status code.
+      def process(*)
+        super
+        response
+      end
+
+      # Set host explicitly, because it can change after request.
+      def default_url_options
+        super.merge(host: host)
+      end
+
+      ActionDispatch::Integration::Session.prepend(self) if defined?(ActionDispatch)
+    end
+  end
+end

data/lib/rails_stuff/test_helpers/response.rb

@@ -15,6 +15,14 @@ module RailsStuff
         end
       end
 
+      # Missing enquirers.
+      {
+        unprocessable_entity: 422,
+        no_content: 204,
+      }.each do |name, code|
+        define_method("#{name}?") { status == code }
+      end
+
       # Easy access to json bodies. It parses and return `Hashie::Mash`'es, so
       # properties can be accessed via method calls:
       #
@@ -29,6 +37,8 @@ module RailsStuff
       def inspect
         "<Response(#{status})>"
       end
+
+      ActionDispatch::TestResponse.send(:include, self) if defined?(ActionDispatch)
     end
   end
 end

data/lib/rails_stuff/test_helpers.rb

@@ -0,0 +1,50 @@
+require 'active_support/core_ext/array/wrap'
+
+module RailsStuff
+  # Collection of RSpec configurations and helpers for better experience.
+  module TestHelpers
+    extend self
+
+    def setup(only: nil, except: nil)
+      items = instance_methods.map(&:to_s) - %w(setup)
+      items -= Array.wrap(except).map(&:to_s) if except
+      if only
+        only = Array.wrap(only).map(&:to_s)
+        items &= only
+        items += only
+      end
+      items.each { |item| public_send(item) }
+    end
+
+    %w(
+      integration_session
+      response
+    ).each do |file|
+      define_method(file.tr('/', '_')) { require "rails_stuff/test_helpers/#{file}" }
+    end
+
+    # Make BigDecimal`s more readable.
+    def big_decimal
+      require 'bigdecimal'
+      BigDecimal.class_eval do
+        alias_method :inspect_orig, :inspect
+        alias_method :inspect, :to_s
+      end
+    end
+
+    # Raise errors from failed threads.
+    def thread
+      Thread.abort_on_exception = true
+    end
+
+    # Raise all translation errors, to not miss any of translations.
+    # Make sure to set `config.action_view.raise_on_missing_translations = true` in
+    # `config/environments/test.rb` yourself.
+    def i18n
+      return unless defined?(I18n)
+      I18n.config.exception_handler = ->(exception, _locale, _key, _options) do
+        raise exception.respond_to?(:to_exception) ? exception.to_exception : exception
+      end
+    end
+  end
+end

data/lib/rails_stuff/types_tracker.rb

@@ -6,7 +6,7 @@ module RailsStuff
   # Also allows to remove any of descendants from this list.
   # Useful for STI models to track all available types.
   #
-  # Railtie adds `to_prepare` callback, which will automatically load types.
+  # Use with RequireNested to preload all nested classes.
   module TypesTracker
     class << self
       def extended(base)

data/lib/rails_stuff/version.rb

@@ -5,10 +5,20 @@ module RailsStuff
 
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 5
-    TINY  = 1
-    PRE   = nil
+    MINOR = 6
+    TINY  = 0
+    PRE   = 'rc1'.freeze
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+
+    class << self
+      def to_s
+        STRING
+      end
+
+      def inspect
+        STRING.inspect
+      end
+    end
   end
 end

data/lib/rails_stuff.rb

@@ -14,8 +14,11 @@ module RailsStuff
   autoload :RedisStorage
   autoload :RequireNested
   autoload :ResourcesController
+  autoload :Responders
+  autoload :RSpecHelpers, 'rails_stuff/rspec_helpers'
   autoload :SortScope
   autoload :Statusable
+  autoload :TestHelpers, 'rails_stuff/test_helpers'
   autoload :TypesTracker
 
   module_function

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_stuff
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0.rc1
 platform: ruby
 authors:
 - Max Melentiev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-10-25 00:00:00.000000000 Z
+date: 2017-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -110,14 +110,26 @@ files:
 - 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/responders.rb
+- lib/rails_stuff/responders/turbolinks.rb
+- lib/rails_stuff/rspec_helpers.rb
+- lib/rails_stuff/rspec_helpers/concurrency.rb
+- lib/rails_stuff/rspec_helpers/groups/feature.rb
+- lib/rails_stuff/rspec_helpers/groups/request.rb
+- lib/rails_stuff/rspec_helpers/matchers/be_valid_js.rb
+- lib/rails_stuff/rspec_helpers/matchers/redirect_with_turbolinks.rb
+- lib/rails_stuff/rspec_helpers/signinable.rb
 - lib/rails_stuff/sort_scope.rb
 - lib/rails_stuff/statusable.rb
+- lib/rails_stuff/statusable/builder.rb
+- lib/rails_stuff/statusable/helper.rb
+- lib/rails_stuff/statusable/mapped_builder.rb
+- lib/rails_stuff/statusable/mapped_helper.rb
 - lib/rails_stuff/strong_parameters.rb
+- lib/rails_stuff/test_helpers.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/integration_session.rb
 - lib/rails_stuff/test_helpers/response.rb
 - lib/rails_stuff/types_tracker.rb
 - lib/rails_stuff/url_for_keeping_params.rb
@@ -138,12 +150,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Collection of useful modules for Rails

data/lib/rails_stuff/resources_controller/responder.rb

@@ -1,21 +0,0 @@
-module RailsStuff
-  module ResourcesController
-    # Default responder class.
-    class Responder < ActionController::Responder
-      include Responders::FlashResponder
-      include Responders::HttpCacheResponder
-
-      # Similar to `.to_html`. Redirect is performed via turbolinks.
-      def to_js
-        default_render
-      rescue ActionView::MissingTemplate
-        raise if get?
-        if has_errors?
-          render resource.persisted? ? :edit : :new
-        else
-          redirect_via_turbolinks_to controller.url_for(resource_location)
-        end
-      end
-    end
-  end
-end

data/lib/rails_stuff/test_helpers/configurator.rb

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

@@ -1,9 +0,0 @@
-require 'action_dispatch'
-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'