rails_stuff 0.1.0

data/lib/rails_stuff/helpers/resource_form.rb

@@ -0,0 +1,49 @@
+require 'active_support/core_ext/array/wrap'
+module RailsStuff
+  module Helpers
+    # Provides helper for SimpleForm.
+    module ResourceForm
+      # Generates `resource_form` helper to display form with basic arguments,
+      # elements, errors and options. Generated method can work without arguments
+      # in most of cases: it takes object from `resource` method.
+      #
+      # Use `namespace` to add additional path parts to form action:
+      #
+      #     # this one will use [:site, resource]
+      #     resource_form_for :site
+      #
+      # #### Options
+      #
+      # - `back_url` - default back url. Can be string with code, or hash for `url_for`.
+      # - `resource_method` - method to take resource from.
+      # - `method` - name of generated method.
+      #
+      def resource_form_for(namespace = nil, **options)
+        default_back_url =
+          case options[:back_url]
+          when Hash then "url_for(#{options[:back_url]})"
+          when String then options[:back_url]
+          else 'url_for(object)'
+          end
+        resource_method = options.fetch(:resource_method, :resource)
+        method_name = options.fetch(:method, :resource_form)
+        object_arg = (Array.wrap(namespace).map(&:inspect) + [resource_method]).join(', ')
+
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{method_name}(object = [#{object_arg}], **options)
+            back_url = options.delete(:back_url) || #{default_back_url}
+            simple_form_for object, options do |f|
+              html = ActiveSupport::SafeBuffer.new
+              msg = f.object.errors[:base].first
+              html << content_tag(:div, msg, class: 'alert alert-danger') if msg
+              html << capture { yield(f) }
+              html << f.button(:submit, class: 'btn-primary')
+              html << ' '
+              html << link_to(translate_action(:cancel), back_url, class: :btn)
+            end
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/rails_stuff/helpers/text.rb

@@ -0,0 +1,28 @@
+module RailsStuff
+  module Helpers
+    module Text
+      # Replaces blank values with cached placeholder from translations.
+      # When called with block, it'll check value for blankness, but returns
+      # block's result if value is present.
+      #
+      #     replace_blank(description)
+      #     replace_blank(tags) { tags.join(', ') }
+      #     replace_blank(order.paid_at) { |x| l x, format: :long }
+      #
+      def replace_blank(value, &block)
+        if value.blank?
+          blank_placeholder
+        else
+          block_given? ? capture(value, &block) : value
+        end
+      end
+
+      # Default placeholder value.
+      def blank_placeholder
+        @_blank_placeholder ||= content_tag :small,
+          "(#{I18n.t(:'helpers.placeholder.blank', default: '-')})",
+          class: :'text-muted'
+      end
+    end
+  end
+end

data/lib/rails_stuff/helpers/translation.rb

@@ -0,0 +1,29 @@
+module RailsStuff
+  module Helpers
+    module Translation
+      # 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}")
+        end
+        @translate_action[action]
+      end
+
+      # 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'])
+        end
+        @translate_confirmation[action]
+      end
+
+      # Translates boolean values.
+      def yes_no(val)
+        @translate_yes_no ||= Hash.new do |h, key|
+          h[key] = I18n.t("helpers.yes_no.#{key}")
+        end
+        @translate_yes_no[val.to_s]
+      end
+    end
+  end
+end

data/lib/rails_stuff/helpers.rb

@@ -0,0 +1,14 @@
+module RailsStuff
+  module Helpers
+    extend ActiveSupport::Autoload
+
+    autoload :Bootstrap
+    autoload :Forms
+    autoload :Links
+    autoload :ResourceForm
+    autoload :Text
+    autoload :Translation
+
+    autoload :All
+  end
+end

data/lib/rails_stuff/nullify_blank_attrs.rb

@@ -0,0 +1,23 @@
+require 'active_support/core_ext/object/blank'
+
+module RailsStuff
+  # Changes to `nil` assigned blank attributes.
+  #
+  #     class App
+  #       nullify_blank_attrs :site_url
+  #       # ...
+  module NullifyBlankAttrs
+    def nullify_blank_attrs(*attrs)
+      nullify_blank_attrs_methods.class_eval do
+        attrs.each do |attr|
+          define_method("#{attr}=") { |val| super(val.presence) }
+        end
+      end
+    end
+
+    # Module to store generated methods, so they can be overriden in model.
+    def nullify_blank_attrs_methods
+      @nullify_blank_attrs_methods ||= Module.new.tap { |x| prepend x }
+    end
+  end
+end

data/lib/rails_stuff/params_parser.rb

@@ -0,0 +1,121 @@
+module RailsStuff
+  # Provides parsing and type-casting functions.
+  # Reraises all ocured errors with Error class, so you can handle it together:
+  #
+  #     rescue_from RailsStuff::ParamsParser::Error, with: :render_bad_request
+  #
+  # You can define more parsing methods by extending with this module
+  # and using .parse:
+  #
+  #     # models/params_parser
+  #     module ParamsParser
+  #       extend RailsStuff::ParamsParser
+  #       extend self
+  #
+  #       def parse_money(val)
+  #         parse(val) { your_stuff(val) }
+  #       end
+  #     end
+  #
+  module ParamsParser
+    # This exceptions is wrapper for any exception occured in parser.
+    # Original exception message can be retrieved with `original_message` method.
+    class Error < ::StandardError
+      attr_reader :original_message, :value
+
+      def initialize(original_message = nil, value = nil)
+        message = "Error while parsing: #{value.inspect}"
+        @original_message = original_message || message
+        @value = value
+        super(message)
+      end
+
+      # Keeps message when passing instance to `raise`.
+      def exception(*)
+        self
+      end
+
+      # Show original messages in tests.
+      def to_s
+        "#{super} (#{original_message})"
+      end
+    end
+
+    extend self
+
+    # Parses value with specified block. Reraises occured error with Error.
+    def parse(val)
+      yield(val) unless val.nil?
+    rescue => e
+      raise Error.new(e.message, val), nil, e.backtrace
+    end
+
+    # Parses each value in array with specified block.
+    # Returns `nil` if `val` is not an array.
+    def parse_array(val)
+      parse(val) { val.map { |x| yield x unless x.nil? } } if val.is_a?(Array)
+    end
+
+    # :method: parse_int
+    # :call-seq: parse_int(val)
+    #
+    # Parse int value.
+
+    # :method: parse_int_array
+    # :call-seq: parse_int_array(val)
+    #
+    # Parses array of ints. Returns `nil` if `val` is not an array.
+
+    # :method: parse_float
+    # :call-seq: parse_float(val)
+    #
+    # Parse float value.
+
+    # :method: parse_float_array
+    # :call-seq: parse_float_array(val)
+    #
+    # Parses array of floats. Returns `nil` if `val` is not an array.
+
+    # :method: parse_string
+    # :call-seq: parse_string(val)
+    #
+    # Parse string value.
+
+    # :method: parse_string_array
+    # :call-seq: parse_string_array(val)
+    #
+    # Parses array of strings. Returns `nil` if `val` is not an array.
+
+    # Parsers for generic types, which are implemented with #to_i, #to_f & #to_s
+    # methods.
+    %w(string int float).each do |type|
+      block = :"to_#{type[0]}".to_proc
+
+      define_method "parse_#{type}" do |val|
+        parse(val, &block)
+      end
+
+      define_method "parse_#{type}_array" do |val|
+        parse_array(val, &block)
+      end
+    end
+
+    # Parse boolean using ActiveResord's parser.
+    def parse_boolean(val)
+      parse(val) do
+        @boolean_parser ||= ActiveRecord::Type::Boolean.new
+        @boolean_parser.type_cast_from_user(val)
+      end
+    end
+
+    # Parse time in current TZ using `Time.parse`.
+    def parse_datetime(val)
+      parse(val) { Time.zone.parse(val) || raise('Invalid datetime') }
+    end
+
+    # Parse JSON string.
+    def parse_json(val)
+      parse(val) { JSON.parse(val) if val.present? }
+    end
+  end
+end

data/lib/rails_stuff/railtie.rb

@@ -0,0 +1,54 @@
+require 'rails/railtie'
+
+module RailsStuff
+  MODULES = {
+    nullify_blank_attrs:  :model,
+    random_uniq_attr:     :model,
+    statusable:           :model,
+    resources_controller: [
+      :controller,
+      -> { ResourcesController.kaminari! if defined?(::Kaminari) },
+    ],
+    sort_scope: -> { defined?(::HasScope) && :controller },
+  }
+
+  class << self
+    # Set it to array of modules to load.
+    #
+    #     # config/initializers/rails_stuff.rb
+    #     RailsStuff.load_modules = [:statusable, :sort_scope]
+    attr_accessor :load_modules
+    # Override default base classes for models & controllers.
+    attr_writer :base_controller, :base_model
+
+    def base_controller
+      @base_controller || ActionController::Base
+    end
+
+    def base_model
+      @base_model || ActiveRecord::Base
+    end
+
+    # Extends base controller and model classes with modules.
+    # By default uses all modules. Use load_modules= to override this list.
+    def setup_modules!
+      modules_to_load = load_modules || MODULES.keys
+      MODULES.slice(*modules_to_load).each do |m, (type, init)|
+        m = const_get m.to_s.camelize
+        case type.respond_to?(:call) ? type.call : type
+        when :controller
+          RailsStuff.base_controller.extend m
+        when :model
+          RailsStuff.base_model.extend m
+        end
+        init.try!(:call)
+      end
+    end
+  end
+
+  class Railtie < Rails::Railtie
+    initializer :rails_stuff_setup_modules, after: :load_config_initializers do
+      RailsStuff.setup_modules!
+    end
+  end
+end

data/lib/rails_stuff/random_uniq_attr.rb

@@ -0,0 +1,48 @@
+module RailsStuff
+  # Provides save way to generate uniq random values for ActiveRecord models.
+  # You need to make field nullable and add unique index on it.
+  # The way it works:
+  #
+  # - Instance is saved as usual
+  # - If random fields are not empty, it does nothing
+  # - Generates random value and tries to update instance
+  # - If `RecordNotUnique` is occured, it keeps trying to generate new values.
+  #
+  module RandomUniqAttr
+    DEFAULT_GENERATOR = ->(*) { SecureRandom.hex(32) }
+
+    class << self
+      # Made from `Devise.firendly_token` with increased length.
+      def friendly_token(length = 32)
+        SecureRandom.urlsafe_base64(length).tr('lIO0', 'sxyz')
+      end
+    end
+
+    # Generates necessary methods and setups on-create callback for the `field`.
+    # You can optionally pass custom generator function:
+    #
+    #     random_uniq_attr(:code) { |instance| my_random(instance) }
+    #
+    def random_uniq_attr(field, &block)
+      set_method = :"set_#{field}"
+      generate_method = :"generate_#{field}"
+
+      after_create set_method, unless: :"#{field}?"
+
+      # def self.generate_key
+      define_singleton_method generate_method, &(block || DEFAULT_GENERATOR)
+
+      # def set_key
+      define_method(set_method) do
+        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
+          retry
+        end
+      end
+    end
+  end
+end

data/lib/rails_stuff/redis_storage.rb

@@ -0,0 +1,119 @@
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/module/remove_method'
+require 'active_support/core_ext/object/blank'
+
+module RailsStuff
+  # Provides methods to store data in redis. Can be easily integrated into
+  # ActiveRecor or other class.
+  #
+  # Redis is accessed via with_redis method which uses redis_pool
+  # (default to `Rails.redis_pool`, see `pooled_redis` gem) to checkout connection.
+  # Basic methods are #get, #delete and #set.
+  #
+  # Redis keys are generated from requested key and redis_prefix
+  # (default to underscored class name). You can pass an array as a key and all the
+  # parts will be concatenated with `:`. #set automalically generates
+  # sequential keys, if given key is `nil` (last element of array is `nil`).
+  #
+  # It uses `dump` and `load` methods to encode values
+  # (by default delegated to `Marshal`).
+  module RedisStorage
+    # Serializers
+    delegate :dump, :load, to: Marshal
+
+    # Redis connections pool. Default to `Rails.redis_pool`.
+    # Override this method to change it.
+    def redis_pool
+      Rails.redis_pool
+    end
+
+    # Options to use in SET command. Use to set EX, or smth.
+    def redis_set_options
+      {}
+    end
+
+    # :method: redis_pool=
+    # :call-seq: redis_pool=
+    #
+    # Set redis_pool.
+
+    # :method: redis_set_options=
+    # :call-seq: redis_set_options=
+    #
+    # Set redis_set_options.
+
+    # Setters that overrides methods, so new values are inherited without recursive `super`.
+    [:redis_pool, :redis_set_options].each do |name|
+      define_method "#{name}=" do |val|
+        singleton_class.class_eval do
+          remove_possible_method(name)
+          define_method(name) { val }
+        end
+      end
+    end
+
+    # Checkout connection & run block with it.
+    def with_redis(&block)
+      redis_pool.with(&block)
+    end
+
+    # Prefix that used in every key for a model. Default to pluralized model name.
+    def redis_prefix
+      @redis_prefix ||= name.underscore
+    end
+
+    # Override default redis_prefix.
+    attr_writer :redis_prefix
+
+    # Generates key for given `id`(s) prefixed with #redis_prefix.
+    # Multiple ids are joined with `:`.
+    def redis_key_for(id)
+      "#{redis_prefix}:#{Array(id).join(':')}"
+    end
+
+    # Generates key to store current maximum id. Examples:
+    #
+    #     users_id_seq
+    #     user_id_seq:eu
+    def redis_id_seq_key(id = [])
+      postfix = Array(id).join(':')
+      "#{redis_prefix}_id_seq#{":#{postfix}" if postfix.present?}"
+    end
+
+    # Generate next ID. It stores counter separately and uses
+    # it to retrieve next id.
+    def next_id(*args)
+      with_redis { |redis| redis.incr(redis_id_seq_key(*args)) }
+    end
+
+    # Reset ID counter.
+    def reset_id_seq(*args)
+      with_redis { |redis| redis.del(redis_id_seq_key(*args)) }
+    end
+
+    # Saves value to redis. If `id` is `nil`, it's generated with #next_id.
+    # Returns last part of id / generated id.
+    def set(id, value, options = {})
+      id = Array(id)
+      id.push(nil) if id.empty?
+      id[id.size - 1] ||= next_id(id[0..-2])
+      with_redis do |redis|
+        redis.set(redis_key_for(id), dump(value), redis_set_options.merge(options))
+      end
+      id.last
+    end
+
+    # Reads value from redis.
+    def get(id)
+      return unless id
+      with_redis { |redis| redis.get(redis_key_for(id)).try { |data| load(data) } }
+    end
+
+    # Remove record from redis.
+    def delete(id)
+      return true unless id
+      with_redis { |redis| redis.del(redis_key_for(id)) }
+      true
+    end
+  end
+end

data/lib/rails_stuff/resources_controller/actions.rb

@@ -0,0 +1,31 @@
+module RailsStuff
+  module ResourcesController
+    # Basic actions for resources controller.
+    module Actions
+      def new
+        build_resource
+      end
+
+      def create(options = {})
+        if create_resource
+          options[:location] = after_save_url
+        end
+        respond_with(resource, options)
+      end
+
+      def update(options = {})
+        if update_resource
+          options[:location] = after_save_url
+        end
+        respond_with(resource, options)
+      end
+
+      def destroy(options = {})
+        resource.destroy
+        options[:location] = after_destroy_url
+        flash_errors!
+        respond_with(resource, options)
+      end
+    end
+  end
+end

data/lib/rails_stuff/resources_controller/basic_helpers.rb

@@ -0,0 +1,161 @@
+module RailsStuff
+  module ResourcesController
+    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
+      end
+
+      module ClassMethods
+        attr_writer :resource_class,
+                    :resource_param_name,
+                    :permitted_attrs
+
+        # Defines action to redirect after resource was saved. Default to `:show`.
+        attr_accessor :after_save_action
+
+        # Resource class for controller. Default to class, based on
+        # demodulized controller name.
+        def resource_class
+          @resource_class ||=
+            Object.const_get(name.to_s.demodulize.sub(/Controller$/, '').singularize)
+        end
+
+        # Key to lookup for resource attributes in `params`.
+        # Default to class'es `param_key`.
+        def resource_param_name
+          @resource_param_name ||= resource_class.model_name.param_key
+        end
+
+        # Class-level permitted attributes.
+        #
+        # `attr_reader`, default to `[]`.
+        def permitted_attrs
+          @permitted_attrs ||= []
+        end
+
+        # Concats `@permitted_attrs` variable with given attrs.
+        def permit_attrs(*attrs)
+          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'
+        end
+      end
+
+      protected
+
+      # Accesss resources collection.
+      def collection
+        @_collection ||= source_for_collection
+      end
+
+      # End-point relation to be used as source for `collection`.
+      def source_for_collection
+        source_relation
+      end
+
+      # Relation which is used to find and build resources.
+      def source_relation
+        self.class.resource_class
+      end
+
+      # Resource found by `params[:id]`
+      def resource
+        @_resource ||= source_relation.find params[:id]
+      end
+
+      # Instantiate resource with attrs from `resource_params`.
+      def build_resource(attrs = resource_params)
+        @_resource = source_relation.new(attrs)
+      end
+
+      # Builds and saves resource.
+      def create_resource
+        build_resource
+        resource.save
+      end
+
+      # Updates resource with `resource_params`.
+      def update_resource(attrs = resource_params)
+        resource.update_attributes(attrs)
+      end
+
+      # Flashes errors in a safe way. Joins `full_messages` and truncates
+      # result to avoid cookies overflow.
+      def flash_errors!(errors = resource.errors, max_length = 100)
+        flash[:error] = errors.full_messages.join("\n").truncate(max_length) if errors.any?
+      end
+
+      # URL to be used in `Location` header & to redirect to after
+      # resource was created/updated. Default uses `self.class.after_save_action`.
+      def after_save_url
+        action = self.class.after_save_action
+        if action == :index
+          url_for action: :index
+        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.
+      def after_destroy_url
+        url_for action: :index
+      end
+
+      # Override it to return permited params. By default it returns params
+      # using `self.class.resource_param_name` and `permitted_attrs` methods.
+      def resource_params
+        @_resource_params ||= begin
+          key = self.class.resource_param_name
+          params.permit(key => permitted_attrs)[key] || {}
+        end
+      end
+
+      # Default permitted attributes are taken from class method. Override it
+      # to implement request-based permitted attrs.
+      def permitted_attrs
+        self.class.permitted_attrs
+      end
+
+      # Default authorization implementation.
+      # Uses `#authorize!` method which is not implemented here
+      # (use CanCan or other implementation).
+      def authorize_resource!
+        action = action_name.to_sym
+        target =
+          case action
+          when :index, :create, :new then self.class.resource_class.new
+          else resource
+          end
+        authorize!(action, target)
+      end
+    end
+  end
+end