rails_stuff 0.5.1 → 0.6.0.rc1

data/lib/rails_stuff/rspec_helpers.rb

@@ -0,0 +1,123 @@
+require 'active_support/core_ext/array/wrap'
+require 'active_support/dependencies/autoload'
+
+module RailsStuff
+  # Collection of RSpec configurations and helpers for better experience.
+  module RSpecHelpers
+    autoload :Signinable, 'rails_stuff/rspec_helpers/signinable'
+
+    extend self
+
+    # Single endpoint for multiple seups. Use `:only` and `:except` options
+    # to filter actions.
+    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.uniq.each { |item| public_send(item) }
+    end
+
+    %w(
+      concurrency
+      groups/request
+      groups/feature
+      matchers/be_valid_js
+      matchers/redirect_with_turbolinks
+    ).each do |file|
+      define_method(file) { require "rails_stuff/rspec_helpers/#{file}" }
+    end
+
+    # Setup all TestHelpers.
+    def test_helpers
+      TestHelpers.setup
+    end
+
+    # 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 # rubocop:disable AbcSize
+      return unless defined?(DatabaseCleaner)
+      ::RSpec.configure do |config|
+        if config.respond_to?(:use_transactional_fixtures=)
+          config.use_transactional_fixtures = false
+        end
+        config.add_setting :database_cleaner_strategy
+        config.database_cleaner_strategy = {feature: :truncation}
+        config.database_cleaner_strategy.default = :transaction
+        config.add_setting :database_cleaner_options
+        config.database_cleaner_options = {truncation: {except: %w(spatial_ref_sys)}}
+        config.add_setting :database_cleaner_args
+        config.database_cleaner_args = ->(ex) do
+          strategy = ex.metadata[:concurrent] && :truncation
+          strategy ||= config.database_cleaner_strategy[ex.metadata[:type]]
+          options = config.database_cleaner_options[strategy] || {}
+          [strategy, options]
+        end
+        config.around do |ex|
+          DatabaseCleaner.strategy = config.database_cleaner_args.call(ex)
+          DatabaseCleaner.cleaning { ex.run }
+        end
+      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
+      ::RSpec.configure do |config|
+        config.add_setting :redis
+        config.redis = Rails.redis if defined?(Rails.redis)
+        config.add_setting :flush_redis_proc
+        config.flush_redis_proc = ->(*) { Array.wrap(config.redis).each(&:flushdb) }
+        config.before(flush_redis: true) { instance_exec(&config.flush_redis_proc) }
+        config.after(:suite) { instance_exec(&config.flush_redis_proc) }
+      end
+    end
+
+    # Runs debugger after each failed example with `:debug` tag.
+    # Uses `pry` by default, this can be configured `config.debugger=`.
+    def debug
+      ::RSpec.configure do |config|
+        config.add_setting :debugger_proc
+        config.debugger_proc = ->(ex) do
+          exception = ex.exception
+          defined?(Pry) ? binding.pry : debugger # rubocop:disable Debugger
+        end
+        config.after(debug: true) do |ex|
+          instance_exec(ex, &config.debugger_proc) if ex.exception
+        end
+      end
+    end
+
+    # Clear logs `tail -f`-safely.
+    def clear_logs
+      ::RSpec.configure do |config|
+        config.add_setting :clear_log_file
+        config.clear_log_file = Rails.root.join('log', 'test.log') if defined?(Rails.root)
+        config.add_setting :clear_log_file_proc
+        config.clear_log_file_proc = ->(file) do
+          next unless file && File.exist?(file)
+          FileUtils.cp(file, "#{file}.last")
+          File.open(file, 'w').close
+        end
+        config.after(:suite) do
+          instance_exec(config.clear_log_file, &config.clear_log_file_proc) unless ENV['KEEP_LOG']
+        end
+      end
+    end
+
+    # Freeze time for specs with `:frozen_time` metadata.
+    def frozen_time
+      ::RSpec.configure do |config|
+        config.around(frozen_time: true) { |ex| Timecop.freeze { ex.run } }
+      end
+    end
+  end
+end

data/lib/rails_stuff/sort_scope.rb

@@ -30,6 +30,7 @@ module RailsStuff
     def has_sort_scope(config = {})
       @@_sort_scope_id ||= 0
       default = config[:default] || :id
+      default = default.is_a?(Hash) ? default.stringify_keys : default.to_s
       allowed = Array.wrap(config[:by]).map(&:to_s)
       only_actions = config.fetch(:only, :index)
       order_method = config.fetch(:order_method, :order)
@@ -42,12 +43,30 @@ module RailsStuff
         type:         :any,
       ) do |c, scope, val|
         sort_args = SortScope.filter_param(val, c.params, allowed, default)
+        c.instance_variable_set(:@current_sort_scope, sort_args)
         scope.public_send(order_method, sort_args)
       end
     end
     # rubocop:enable ClassVars
 
+    # It does not use `ClassMethods` similar to `ActiveSupport::Concern`
+    # due to backward compatibility (SortScope extends controller class).
+    module InstanceMethods
+      protected
+
+      def current_sort_scope
+        @current_sort_scope ||= {}
+      end
+    end
+
     class << self
+      def extended(base)
+        base.class_eval do
+          include InstanceMethods
+          helper_method :current_sort_scope if respond_to?(:helper_method)
+        end
+      end
+
       # Filters value with whitelist of allowed fields to sort by.
       #
       # rubocop:disable CyclomaticComplexity, PerceivedComplexity, BlockNesting

data/lib/rails_stuff/statusable/builder.rb

@@ -0,0 +1,114 @@
+module RailsStuff
+  module Statusable
+    # Basic builder for statuses list. Generates methods and scopes.
+    class Builder
+      attr_reader :helper, :options, :prefix, :suffix
+      delegate :model, :field, :list, to: :helper
+      delegate :define_scope, :define_method, :define_class_method, to: :helper
+
+      def initialize(helper, **options)
+        @helper = helper
+        @options = options
+        @prefix = options[:prefix]
+        @suffix = options[:suffix]
+      end
+
+      def generate
+        validations if options.fetch(:validate, true)
+        field_accessor
+        field_scope
+        value_scopes
+        value_accessors
+        translation_helpers
+      end
+
+      def validations
+        model.validates_inclusion_of field,
+          {in: valid_list}.merge!(options.fetch(:validate, {}))
+      end
+
+      # Field reader returns string, so we stringify list for validation.
+      def valid_list
+        list.map(&:to_s)
+      end
+
+      # Yields every status with it's database value into block.
+      def each_status
+        list.each { |x| yield x, x.to_s }
+      end
+
+      # Wraps status name with prefix and suffix.
+      def status_method_name(status)
+        "#{prefix}#{status}#{suffix}"
+      end
+
+      # Scope with given status. Useful for has_scope.
+      def field_scope
+        field = self.field
+        define_scope "with_#{field}", ->(status) { where(field => status) }
+      end
+
+      # Status accessors for every status.
+      def value_accessors
+        each_status do |status, value|
+          value_accessor status, value
+        end
+      end
+
+      # Scopes for every status.
+      def value_scopes
+        field = self.field
+        each_status do |status, value|
+          define_scope status_method_name(status), -> { where(field => value) }
+          define_scope "not_#{status_method_name(status)}", -> { where.not(field => value) }
+        end
+      end
+
+      # Generates methods for specific value.
+      def value_accessor(status, value)
+        field = self.field
+
+        # Shortcut to check status.
+        define_method "#{status_method_name(status)}?" do
+          # Access raw value, 'cause reader can be overriden.
+          self[field] == value
+        end
+
+        # Shortcut to update status.
+        define_method "#{status_method_name(status)}!" do
+          update!(field => value)
+        end
+      end
+
+      def field_accessor
+        field_reader
+        field_writer
+      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 = self[field]
+          val && val.to_sym
+        end
+      end
+
+      def translation_helpers
+        field = self.field
+        define_method "#{field}_name" do
+          val = send(field)
+          self.class.t(".#{field}_name.#{val}") if val
+        end
+      end
+    end
+  end
+end

data/lib/rails_stuff/statusable/helper.rb

@@ -0,0 +1,64 @@
+module RailsStuff
+  module Statusable
+    # Class to hold helper methods for statusable field.
+    #
+    #   Order.has_status_field :status, %i(pending complete)
+    #   Order.statuses.list # => %(pending complete)
+    #   # ...
+    class Helper
+      attr_reader :model, :field, :list
+
+      def initialize(model, field, statuses)
+        @model = model
+        @field = field.freeze
+        @list = statuses.freeze
+      end
+
+      def translate(status)
+        model.t(".#{field}_name.#{status}") if status
+      end
+
+      alias_method :t, :translate
+
+      # Returns array compatible with select_options helper.
+      def select_options(only: nil, except: nil)
+        only ||= list
+        only -= except if except
+        only.map { |x| [translate(x), x] }
+      end
+
+      # Generate class method in model to access helper.
+      def attach(method_name = field.to_s.pluralize)
+        helper = self
+        define_class_method(method_name) { helper }
+      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)
+        methods_module.send(:define_method, method, &block)
+      end
+
+      def define_class_method(method, &block)
+        methods_module::ClassMethods.send(:define_method, method, &block)
+      end
+
+      protected
+
+      # Module to hold generated methods.
+      def methods_module
+        model.statusable_methods
+      end
+    end
+  end
+end

data/lib/rails_stuff/statusable/mapped_builder.rb

@@ -0,0 +1,48 @@
+module RailsStuff
+  module Statusable
+    # Generates methods and scopes when status names are mapped to internal values.
+    class MappedBuilder < Statusable::Builder
+      delegate :mapping, :inverse_mapping, to: :helper
+
+      # Field reader returns mapped value, so we don't need to stringify list.
+      alias_method :valid_list, :list
+
+      def each_status(&block)
+        mapping.each(&block)
+      end
+
+      # Scope with given status. Useful for has_scope.
+      def field_scope
+        field = self.field
+        helper = self.helper
+        define_scope "with_#{field}", ->(status) { where(field => helper.map(status)) }
+      end
+
+      def field_reader
+        field = self.field
+        helper = self.helper
+
+        # Returns status name.
+        define_method field do |original = false|
+          val = super()
+          original || !val ? val : helper.unmap(val)
+        end
+
+        # Status as symbol.
+        define_method "#{field}_sym" do
+          val = public_send(field)
+          val && val.to_sym
+        end
+      end
+
+      def field_writer
+        helper = self.helper
+        # Make field accept sympbols.
+        define_method "#{field}=" do |val|
+          val = val.to_s if val.is_a?(Symbol)
+          super(helper.map(val))
+        end
+      end
+    end
+  end
+end

data/lib/rails_stuff/statusable/mapped_helper.rb

@@ -0,0 +1,46 @@
+module RailsStuff
+  module Statusable
+    # Helper to hold
+    class MappedHelper < Helper
+      attr_reader :mapping, :inverse_mapping, :indifferent_mapping
+
+      def initialize(*)
+        super
+        @mapping = @list
+        @indifferent_mapping = mapping.with_indifferent_access
+        @list = mapping.keys.freeze
+        @inverse_mapping = mapping.invert.freeze
+      end
+
+      def select_options(original: false, only: nil, except: nil)
+        return super(only: only, except: except) unless original
+        only ||= mapping_values
+        only -= except if except
+        only.map { |x| [translate(inverse_mapping.fetch(x)), x] }
+      end
+
+      def mapping_values
+        @mapping_values ||= mapping.values
+      end
+
+      def map(val)
+        map_with(indifferent_mapping, val)
+      end
+
+      def unmap(val)
+        map_with(inverse_mapping, val)
+      end
+
+      protected
+
+      # Maps single value or array with given map.
+      def map_with(map, val)
+        if val.is_a?(Array)
+          val.map { |x| map.fetch(x, x) }
+        else
+          map.fetch(val, val)
+        end
+      end
+    end
+  end
+end