rails_stuff 0.1.0

data/lib/rails_stuff/resources_controller/resource_helper.rb

@@ -0,0 +1,31 @@
+module RailsStuff
+  module ResourcesController
+    # Defines resource helper and finder method.
+    module ResourceHelper
+      # Defines protected helper method. Ex. for `:user`
+      #
+      #     helper_method :user
+      #
+      #     def user
+      #       @user ||= User.find params[:user_id]
+      #     end
+      #
+      # #### Options
+      #
+      # - `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
+        resource_name = resource_name.to_s
+
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{resource_name}
+            @#{resource_name} ||= #{options[:class] || resource_name.classify}.
+              find params[:#{options[:param] || resource_name.foreign_key}]
+          end
+          protected :#{resource_name}
+        RUBY
+      end
+    end
+  end
+end

data/lib/rails_stuff/resources_controller/responder.rb

@@ -0,0 +1,21 @@
+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/resources_controller/sti_helpers.rb

@@ -0,0 +1,62 @@
+require 'active_record/errors'
+
+module RailsStuff
+  module ResourcesController
+    # Helper methods for controllers which works with STI models.
+    module StiHelpers
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Returns hash which is used to get subclass for requested type.
+        #
+        # By default it uses `.types_list` or `.descendants` to get list of
+        # classes and indexes them by class names.
+        def resource_class_by_type
+          @resource_class_by_type ||= begin
+            if resource_class.respond_to?(:types_list)
+              resource_class.types_list
+            else
+              resource_class.descendants
+            end.index_by(&:name)
+          end
+        end
+
+        # Class-level accessor to permitted attributes for specisic class.
+        def permitted_attrs_for
+          @permitted_attrs_for ||= Hash.new { |h, k| h[k] = [] }
+        end
+
+        # Permits attrs only for specific class.
+        def permit_attrs_for(klass, *attrs)
+          permitted_attrs_for[klass].concat attrs
+        end
+      end
+
+      protected
+
+      # Returns model class depending on `type` attr in params.
+      # If resource is requested by id, it returns its class.
+      def class_from_request
+        @class_from_request ||=
+          if params.key?(:id)
+            resource.class
+          else
+            name = params.require(self.class.resource_param_name).
+              permit(:type)[:type]
+            self.class.resource_class_by_type[name] ||
+              raise(ActiveRecord::RecordNotFound)
+          end
+      end
+
+      # Instantiates object using class_from_request.
+      def build_resource
+        @_resource = super.becomes!(class_from_request)
+      end
+
+      # Merges default attrs with attrs for specific class.
+      def permitted_attrs
+        super + self.class.permitted_attrs_for[class_from_request]
+      end
+    end
+  end
+end

data/lib/rails_stuff/resources_controller.rb

@@ -0,0 +1,42 @@
+require 'responders'
+
+module RailsStuff
+  # InheritedResources on diet.
+  # Tiny and simple implementation. Feel free to change/extend it right in you
+  # application. Or just use separate modules.
+  module ResourcesController
+    extend ActiveSupport::Autoload
+
+    class << self
+      delegate :kaminari!, to: 'RailsStuff::ResourcesController::BasicHelpers'
+    end
+
+    autoload :Actions
+    autoload :BasicHelpers
+    autoload :Responder
+    autoload :StiHelpers
+    autoload :ResourceHelper
+
+    # Setups basic actions and helpers in resources controller.
+    #
+    # #### Options
+    #
+    # - `sti` - include STI 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
+
+      respond_to :html
+      self.responder = Responder
+      self.after_save_action = options[:after_save_action] || after_save_action
+
+      if options[:source_relation] # rubocop:disable GuardClause
+        protected define_method(:source_relation, &options[:source_relation])
+      end
+    end
+  end
+end

data/lib/rails_stuff/sort_scope.rb

@@ -0,0 +1,71 @@
+require 'has_scope'
+
+module RailsStuff
+  # Provides safe and flexible way to sort collections by user's input.
+  # Uses `has_scope` gem.
+  #
+  # Supports different input format, and limits requested fields
+  # to allowed subset.
+  module SortScope
+    # Register type for has_scop that accepts stings, hashes & arrays.
+    HasScope::ALLOWED_TYPES[:any] = [[String, Hash, Array, Symbol]]
+
+    # Setups has_scope to order collection by allowed columns.
+    # Sort column is filtered by SortScope.filter_param method.
+    # Accepts params:
+    #
+    # - `sort=name`
+    # - `sort=name&sort_desc=true`
+    # - `sort[name]&sort[order]`
+    # - `sort[name]&sort[order]=desc
+    #
+    # #### Options
+    #
+    # - `by` - array of available fields to sort by,
+    # - `default` - default sort expression,
+    # - `only` - bypassed to `has_scope` to limit actions (default to `:index`).
+    #
+    # rubocop:disable ClassVars
+    def has_sort_scope(config = {})
+      @@_sort_scope_id ||= 0
+      default = config[:default] || :id
+      allowed = Array.wrap(config[:by]).map(&:to_s)
+      only_actions = config.fetch(:only, :index)
+      # Counter added into scope name to allow to define multiple scopes in same controller.
+      has_scope("sort_#{@@_sort_scope_id += 1}",
+        as:           :sort,
+        default:      nil,
+        allow_blank:  true,
+        only:         only_actions,
+        type:         :any,
+      ) do |c, scope, val|
+        scope.order(SortScope.filter_param(val, c.params, allowed, default))
+      end
+    end
+    # rubocop:enable ClassVars
+
+    class << self
+      # Filters value with whitelist of allowed fields to sort by.
+      #
+      # rubocop:disable CyclomaticComplexity, PerceivedComplexity, BlockNesting
+      def filter_param(val, params, allowed, default = nil)
+        val ||= default
+        unless val == default
+          val =
+            if val.is_a?(Hash)
+              val.each_with_object({}) do |(key, dir), h|
+                h[key] = (dir == 'desc' ? :desc : :asc) if allowed.include?(key)
+              end
+            else
+              allowed.include?(val) ? val : default
+            end
+        end
+        if val && !val.is_a?(Hash)
+          val = {val => ParamsParser.parse_boolean(params[:sort_desc]) ? :desc : :asc}
+        end
+        val
+      end
+      # rubocop:enable CyclomaticComplexity, PerceivedComplexity, BlockNesting
+    end
+  end
+end

data/lib/rails_stuff/statusable.rb

@@ -0,0 +1,130 @@
+module RailsStuff
+  # Basic helpers to work with `status`-like field.
+  #
+  # For every status value it provides:
+  #
+  # - scopes with status name (eg. `.rejected`, '.not_rejected')
+  # - inquiry method to check status (eg. `#rejected?`)
+  # - bang method to update status (eg. `#rejected!`)
+  #
+  # It also provides:
+  #
+  # - translation helpers (`acttivemodel_translation` gem required)
+  # - inclusion validator
+  # - string/symbol agnostic `#status=`
+  # - `#status_sym`
+  # - `status_select_options` helper.
+  #
+  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).
+    #
+    # #### Options
+    #
+    # - `prefix`    - used to prefix value-named helpers.
+    #
+    #         # this defines #shipped?, #shipped! methods
+    #         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
+    #
+    # - `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
+      end
+    end
+
+    # Module to hold generated methods.
+    def statusable_methods
+      # 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
+      end
+
+      # Generates methods for specific value.
+      def status_accessor(field, status_name, prefix = nil)
+        # Shortcut to check status.
+        define_method "#{prefix}#{status_name}?" do
+          self[field] == status_name
+        end
+
+        # Shortcut to update status.
+        define_method "#{prefix}#{status_name}!" do
+          update_attributes!(field => status_name)
+        end
+      end
+
+      def field_accessor(field)
+        # Make field accept sympbols.
+        define_method "#{field}=" do |val|
+          val = val.to_s if val.is_a?(Symbol)
+          super(val)
+        end
+
+        # Status as symbol.
+        define_method "#{field}_sym" do
+          val = self[field]
+          val && val.to_sym
+        end
+      end
+
+      def translation_helpers(field)
+        # 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 field
+          self.class.t(".#{field}_name.#{val}") if val
+        end
+      end
+
+      def select_options_helper(field, statuses)
+        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.map { |x| [send(translation_method, x), x] }
+        end
+      end
+
+      def generate_class_method(method, &block)
+        const_get(:ClassMethods).send(:define_method, method, &block)
+      end
+    end
+  end
+end

data/lib/rails_stuff/test_helpers/rails.rb

@@ -0,0 +1,6 @@
+require 'action_dispatch'
+require 'rails_stuff/test_helpers/response'
+
+ActionDispatch::TestResponse.class_eval do
+  include RailsStuff::TestHelpers::Response
+end

data/lib/rails_stuff/test_helpers/response.rb

@@ -0,0 +1,34 @@
+require 'hashie'
+
+module RailsStuff
+  module TestHelpers
+    module Response
+      class << self
+        # Return `Hashie::Mash` for a given object. When `Array` is given
+        # it is mapped to mash recursievly.
+        def prepare_json_object(object)
+          case object
+          when Hash then Hashie::Mash.new(object)
+          when Array then object.map(&method(__callee__))
+          else object
+          end
+        end
+      end
+
+      # Easy access to json bodies. It parses and return `Hashie::Mash`'es, so
+      # properties can be accessed via method calls:
+      #
+      #     response.json_body.order.items.id
+      #     # note that hash methods are still present:
+      #     response.json_body.order[:key] # instead of order.key
+      def json_body
+        @json_body ||= Response.prepare_json_object(JSON.parse(body))
+      end
+
+      # Makes it easier to debug failed specs.
+      def inspect
+        "<Response(#{status})>"
+      end
+    end
+  end
+end

data/lib/rails_stuff/types_tracker.rb

@@ -0,0 +1,50 @@
+require 'active_support/core_ext/class/attribute'
+
+module RailsStuff
+  # Adds `types_list` method which tracks all descendants.
+  # 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.
+  module TypesTracker
+    class << self
+      def extended(base)
+        base.class_attribute :types_list, instance_accessor: false
+        base.types_list = types_list_class.new
+      end
+
+      # Class for `types_list`. Default to `Array`. You can override it
+      # for all models, or assign new value to specific model
+      # via `lypes_list=` right after extending.
+      attr_accessor :types_list_class
+    end
+
+    self.types_list_class = Array
+
+    # Add `self` to `types_list`.
+    def register_type(*args)
+      if types_list.respond_to?(:add)
+        types_list.add self, *args
+      else
+        types_list << self
+      end
+    end
+
+    # Remove `self` from `types_list`.
+    def unregister_type
+      types_list.delete self
+    end
+
+    # 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 }
+    end
+
+    # Tracks all descendants automatically.
+    def inherited(base)
+      super
+      base.register_type
+    end
+  end
+end

data/lib/rails_stuff/version.rb

@@ -0,0 +1,14 @@
+module RailsStuff
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+  end
+end

data/lib/rails_stuff.rb

@@ -0,0 +1,19 @@
+require 'rails_stuff/version'
+require 'active_support/dependencies/autoload'
+
+# Useful stuff for Rails.
+module RailsStuff
+  extend ActiveSupport::Autoload
+
+  autoload :Helpers
+  autoload :NullifyBlankAttrs
+  autoload :ParamsParser
+  autoload :RandomUniqAttr
+  autoload :RedisStorage
+  autoload :ResourcesController
+  autoload :Statusable
+  autoload :SortScope
+  autoload :TypesTracker
+end
+
+require 'rails_stuff/railtie' if defined?(Rails::Railtie)

data/rails_stuff.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rails_stuff/version'
+
+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.summary       = 'Collection of useful modules for Rails'
+  spec.homepage      = 'https://github.com/printercu/rails_stuff'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(spec)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'rails', '~> 4.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.8'
+  spec.add_development_dependency 'rake', '~> 10.0'
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: rails_stuff
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Max Melentiev
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-09-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 
+email:
+- m.melentiev@corp.mail.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/git-hooks/pre-commit
+- bin/install_git_hooks
+- bin/setup
+- lib/net/http/debug.rb
+- lib/rails_stuff.rb
+- lib/rails_stuff/helpers.rb
+- lib/rails_stuff/helpers/all.rb
+- lib/rails_stuff/helpers/bootstrap.rb
+- lib/rails_stuff/helpers/forms.rb
+- lib/rails_stuff/helpers/links.rb
+- lib/rails_stuff/helpers/resource_form.rb
+- lib/rails_stuff/helpers/text.rb
+- lib/rails_stuff/helpers/translation.rb
+- lib/rails_stuff/nullify_blank_attrs.rb
+- lib/rails_stuff/params_parser.rb
+- lib/rails_stuff/railtie.rb
+- lib/rails_stuff/random_uniq_attr.rb
+- lib/rails_stuff/redis_storage.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/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/test_helpers/rails.rb
+- lib/rails_stuff/test_helpers/response.rb
+- lib/rails_stuff/types_tracker.rb
+- lib/rails_stuff/version.rb
+- rails_stuff.gemspec
+homepage: https://github.com/printercu/rails_stuff
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Collection of useful modules for Rails
+test_files: []