rails_stuff 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 82159ba1a8b42ef1cea7d901d966408ae47dc832
+  data.tar.gz: c4d212a0f28c39142139945488c73c7c5eb10eb4
+SHA512:
+  metadata.gz: 767e814c2d06cc0ec03988d0a5a510edeba5407310a3d72c1592ff6e947fb4ee58adba0ad0efa6ee2d0e33a8fbd0d58c5a250a900d2fd5bbb766c7b067028443
+  data.tar.gz: 49ce30b733a8a28ab71dcb6a7cafd496f74f391000f52ae9597be8605810564b781bfc838dff3f92ad8f60d922d6f8ecbf00a99d77390c929caf1a8d4bae3f60

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,24 @@
+AllCops:
+  RunRailsCops: true
+
+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
+Style/ClosingParenthesisIndentation: {Enabled: false}
+Style/Documentation: {Enabled: false}
+Style/DotPosition: {EnforcedStyle: trailing}
+Style/IfUnlessModifier: {Enabled: false}
+Style/ModuleFunction: {Enabled: false}
+Style/MultilineOperationIndentation: {EnforcedStyle: indented}
+Style/PredicateName: {Enabled: false}
+Style/SignalException: {EnforcedStyle: only_raise}
+Style/SpaceInsideHashLiteralBraces: {EnforcedStyle: no_space}
+Style/TrailingComma: {Enabled: false}
+
+Metrics/AbcSize: {Max: 19}
+Metrics/LineLength: {Max: 100}
+Metrics/MethodLength: {Max: 30}

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+cache: bundler
+rvm:
+  - 2.2.3
+services:
+  - redis
+notifications:
+  email: false

data/Gemfile

@@ -0,0 +1,21 @@
+source 'https://rubygems.org'
+gemspec
+
+group :development do
+  gem 'sdoc', '~> 0.4.1'
+  gem 'pry', '~> 0.10.1'
+
+  gem 'sqlite3', '~> 1.3.10'
+  gem 'database_cleaner', '~> 1.5.0'
+  gem 'pooled_redis', '~> 0.2.1'
+  gem 'activemodel_translation', '~> 0.1.0'
+  gem 'has_scope', '~> 0.6.0'
+  gem 'responders', '~> 2.1.0'
+  gem 'kaminari', '~> 0.16.3'
+
+  gem 'rspec', '~> 3.3.0'
+  gem 'rspec-its', '~> 1.1.0'
+  gem 'rspec-rails', '~> 3.3.3'
+
+  gem 'rubocop', '~> 0.33.0'
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Max Melentiev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,350 @@
+# RailsStuff
+[![Gem Version](https://badge.fury.io/rb/rails_stuff.svg)](http://badge.fury.io/rb/rails_stuff)
+[![Code Climate](https://codeclimate.com/github/printercu/rails_stuff/badges/gpa.svg)](https://codeclimate.com/github/printercu/rails_stuff)
+[![Build Status](https://travis-ci.org/printercu/rails_stuff.svg)](https://travis-ci.org/printercu/rails_stuff)
+
+Collection of useful modules for Rails.
+
+#### Controllers:
+
+- __[ResourcesController](#resourcescontroller)__
+  DRY! Keep your controllers clean.
+- __[SortScope](#sortscope)__
+  Helper for `has_scope` to sort collections safely.
+
+#### Models:
+
+- __[NullifyBlankAttrs](#nullifyblankattrs)__
+  Proxies writers to replace empty values with `nil`.
+- __[RandomUniqAttr](#randomuniqattr)__
+  You generate random values for attributes, it'll ensure they are uniq.
+- __[Statusable](#statusable)__
+  `ActiveRecord::Enum` with more features.
+- __[TypesTracker](#typestracker)__
+  Advanced descendants tracker.
+
+#### Misc:
+
+- __[ParamsParser](#paramsparser)__
+  Type-cast params outside of `ActiveRecord`.
+- __[RedisStorage](#redisstorage)__
+  Simple way to store collections in key-value storage. With scoping and
+  key generation.
+
+#### Helpers:
+
+- __TranslationHelper__
+  `translate_action`, `translate_confirmation` helpers to translate
+  action names and confirmations in the same way all over you app.
+- __LinksHelper__
+  Keep your links for basic actions consistent.
+- __Bootstrap__
+  For bootstrap-formatted flash messages.
+- __Forms__
+  `hidden_params_fields` to bypass query params in GET-forms.
+
+__[Helpers usage](#helpers)__
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rails_stuff'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rails_stuff
+
+## Usage
+
+All modules are lazy loaded, so it's ok to require whole gem at once.
+There is railtie which will include some of modules into `ActiveRecord::Base`
+and `ActionController::Base` by default. You can disable this behavior in
+initializer:
+
+```ruby
+# Disable auto-setup:
+RailsStuff.load_modules = []
+
+# Enable particular modules:
+RailsStuff.load_modules = %i(sort_scope statusable)
+```
+
+You can override base classes for controller/model with `.base_controller=`,
+`.base_model=`.
+
+Works only with ruby 2.0+, tested with Rails 4.2.
+
+There can be lack of documentation in README. Please navigate to module and
+check docs & code (press `t` on github) if you miss something.
+
+### ResourcesController
+
+Similar to [InheriteResource](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.
+
+It's main purpose is to ged rid of `@user ||= User.find params[:id]`, and keep
+controllers clean:
+
+```ruby
+class ApplicationController < ActionController::Base
+  extend RailsStuff::ResourcesController # when using without railtie
+end
+
+class UsersController < ApplicationController
+  resources_controller
+  permit_attrs :name, :email
+end
+
+class ProjectsController < ApplicationController
+  resources_controller sti: true,
+    after_save_action: :index,
+    source_relation: -> { user.projects }
+  resource_helper :user
+  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.
+
+Currently depends on `gem 'responders', '> 2.0'`.
+
+### SortScope
+
+```ruby
+# in controller
+extend RailsStuff::SortScope # when using without railtie
+
+sort_scope by: [:name, :created_at, :balance], default: [:name]
+
+# this scope will accept
+#   - `sort=name`
+#   - `sort=name&sort_desc=true`
+#   - `sort[name]&sort[created_at]`
+#   - `sort[name]&sort[created_at]=desc
+```
+
+Requires `gem 'has_scope'`.
+
+### NullifyBlankAttrs
+
+Defines proxies for writers to replace empty values with `nil`.
+
+```ruby
+# in model
+extend RailsStuff::NullifyBlankAttrs # when using without railtie
+
+nullify_blank_attrs :email, :title
+```
+
+### RandomUniqAttr
+
+Uses database's UNIQUE constraints and transactions to generate uniq random values.
+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 occurred, it keeps trying to generate new values.
+
+```ruby
+# in model
+extend RailsStuff::RandomUniqAttr # when using without railtie
+
+# Uses DEFAULT_GENERATOR which is SecureRandom(32)
+random_uniq_attr :token
+
+# Uses custom generator, which takes template from settings
+random_uniq_attr(:code) do |instance|
+  MyGenerator.generate(instance.parent.code_template)
+end
+```
+
+### Statusable
+
+```ruby
+class User < ActiveRecord::Base
+  extend RailsStuff::RandomUniqAttr # when using without railtie
+
+  STATUSES = %i(confirmed banned)
+  has_status_field # uses #status field and STATUSES as values
+
+  # Or pass everything explicitly
+  has_status_field :subscription_status, %i(expired active), prefix: :subs_
+  # :prefix is used for methods that are build
+end
+
+user = User.first
+
+# And you get:
+# Scopes
+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])
+
+# Translation & select helpers (requires activemodel_translation gem)
+User.status_name(:active)
+user.subscription_status_name # translates current status
+User.status_select_options
+User.subscription_status_select_options except: [:expired]
+
+# Accessors
+user.status = 'confirmed' or user.confirmed!
+user.status_sym # :confirmed
+user.subscription_status = :active or user.subs_active!
+user.subscription_status # 'active'
+user.banned? or user.subs_expired?
+
+# ... and inclusion validator
+```
+
+### TypesTracker
+
+```ruby
+class Project
+  extend RailsStuff::TypesTracker
+  # you can also override default list class (Array) with:
+  self.types_list_class = FilterableArray
+  # smth ...
+
+  # 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')
+end
+
+class Project::Big < Project
+  unregister_type # remove this class from types_list
+
+  # Or add options for custom list.
+  # Following will call types_list.add Project::Big, :arg, option: :example
+  register_type :arg, option: :example
+end
+
+class Project::Internal < Project::Big; end
+class Project::External < Project::Big; end
+class Project::Small < Project; end
+
+Project.types_list # [Internal, External, Small]
+```
+
+### ParamsParser
+
+Have you missed type-casting outside of `ActiveRecord::Base`? Here is it:
+
+```ruby
+ParamsParser.parse_int(params[:field]) # _float, _string, _boolean, _datetime
+ParamsParser.parse_int_array(params[:field_with_array])
+ParamsParser.parse_json(json_string)
+
+# There is basic .parse method. It runs block only if input is not nil
+# and reraises all errors with ParamsParser::Error
+ParamsParser.parse(input) { |x| this_can_raise_exception(x) }
+
+# So you can handle all errors in controller with
+rescue_from ParamsParser::Error, with: -> { head :bad_request }
+```
+
+### RedisStorage
+
+Simple module to organize data in key-value store. Uses `ConnectionPool`
+and works good in multi-threaded environments.
+Best used with [PooledRedis](https://github.com/printercu/pooled_redis).
+
+```ruby
+class Model
+  extend RailsStuff::SedisStorage
+
+  self.redis_prefix = :other_prefix # default to underscored model name
+
+  # override .dump, .load for custom serialization. Default to Marshal
+
+  # It uses Rails.redis_pool by default. Override it with
+  self.redis_pool = ConnectionPool.new { Redis.new(my_options) }
+end
+
+Model.get('key') # GET other_prefix:key
+Model.get(['composite', 'key']) # GET other_prefix:composite:key
+# .delete works the same way
+
+Model.set('key', data) or Model.set(['composite', 'key'], data)
+next_id = Model.set(nil, data) # auto-incremented per-model id
+next_id = Model.set(['composite', nil], data) # auto-incremented per-scope id
+Model.set(id, data, ex: 10) # pass options for redis
+# Or set per-model options for all .set requests:
+Model.redis_set_options = {ex: 10}
+
+# generate ids:
+Model.next_id or Model.next_id(['composite', 'scope'])
+Model.reset_id_seq or Model.reset_id_seq(['composite', 'scope'])
+```
+
+### Helpers
+
+Include helper module into `ApplicationHelper`.
+Or use `RailsStuff::Helpers::All` to include all helpers together.
+
+Add this sections to your translations ymls:
+
+```yml
+helpers:
+  actions:
+    edit: Change
+    delete: Forget about it
+  confirm: Really?
+  confirmations:
+    delete: Will you miss it?
+```
+
+And use helpers:
+
+```ruby
+translate_action(:edit) or translate_action(:delete)
+link_to 'x', url_for(resource),
+  method: :delete, data: {confirm:  translate_confirmation(:delete)}
+translate_confirmation(:purge_all) # Fallback to default: 'Really?'
+
+# There are helpers for basic links, take a look on helpers/links.rb to know
+# how to tune it:
+link_to_edit or link_to_edit('url') or link_to_edit([:scope, resource])
+link_to_destroy or link_to_destroy('url') or link_to_destroy([:scope, resource])
+```
+
+Translation helpers are cached, so there is no need to cache it by yourself in
+template if you want to decrease computations. And be aware of it if you
+switch locales while rendering single view.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies.
+Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+To release a new version, update the version number in `version.rb`,
+and then run `bundle exec rake release` to create a git tag for the version,
+push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/printercu/rails_stuff/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Implement your feature:
+  - Write failing spec for your feature
+  - Write code
+  - Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,22 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+require 'sdoc'
+RDoc::Task.new(:doc) do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+
+  rdoc.title = 'RailsStuff'
+
+  rdoc.options << '--markup' << 'markdown'
+  rdoc.options << '-e' << 'UTF-8'
+  rdoc.options << '--format' << 'sdoc'
+  rdoc.options << '--template' << 'rails'
+  rdoc.options << '--all'
+
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'rails_stuff'
+
+require 'pry'
+Pry.start

data/bin/git-hooks/pre-commit

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+pattern=$(echo -n '\.rb
+\.gemspec
+\.jbuilder
+\.rake
+config\.ru
+Gemfile
+Rakefile' | tr "\\n" '|')
+
+files=`git diff --cached --name-status | grep -E "^[AM].*($pattern)$" | cut -f2-`
+if [ -n "$files" ]; then
+  bundle exec rubocop $files --force-exclusion
+fi

data/bin/install_git_hooks

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+root = File.expand_path('../../', __FILE__)
+hooks_dir = "#{root}/bin/git-hooks"
+
+`ls -1 #{hooks_dir}`.each_line.map(&:strip).each do |file|
+  `ln -sf #{hooks_dir}/#{file} #{root}/.git/hooks/#{file}`
+end

data/bin/setup

@@ -0,0 +1,8 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+bin/install_git_hooks
+
+# Do any other automated setup that you need to do here

data/lib/net/http/debug.rb

@@ -0,0 +1,26 @@
+require 'net/http'
+
+class << Net::HTTP
+  # Redefines `.new` to set debug device for all new instances.
+  def debug!(out = $stderr)
+    return if respond_to?(:__new__)
+    class << self
+      alias_method :__new__, :new
+    end
+
+    define_singleton_method :new do |*args, &blk|
+      instance = __new__(*args, &blk)
+      instance.set_debug_output(out)
+      instance
+    end
+  end
+
+  # Restores original `.new`.
+  def disable_debug!
+    return unless respond_to?(:__new__)
+    class << self
+      alias_method :new, :__new__
+      remove_method :__new__
+    end
+  end
+end

data/lib/rails_stuff/helpers/all.rb

@@ -0,0 +1,12 @@
+module RailsStuff
+  module Helpers
+    # Collection of all helper modules.
+    module All
+      include Translation
+      include Links
+      include Bootstrap
+      include Text
+      include Forms
+    end
+  end
+end

data/lib/rails_stuff/helpers/bootstrap.rb

@@ -0,0 +1,34 @@
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/hash/transform_values'
+
+module RailsStuff
+  module Helpers
+    module Bootstrap
+      BOOTSTRAP_FLASH_TYPE = {
+        success:  'alert-success',
+        error:    'alert-danger',
+        alert:    'alert-warning',
+        notice:   'alert-info',
+      }.stringify_keys.freeze
+
+      def flash_messages
+        flash.map do |type, message|
+          content_tag :div, class: [:alert, BOOTSTRAP_FLASH_TYPE[type] || type] do
+            content_tag(:button, '×'.html_safe, class: :close, data: {dismiss: :alert}) +
+              simple_format(message)
+          end
+        end.join.html_safe
+      end
+
+      ICONS = {
+        destroy:  %(<span class='glyphicon icon-destroy'></span>),
+        edit:     %(<span class='glyphicon icon-edit'></span>),
+        new:      %(<span class='glyphicon icon-add'></span>),
+      }.tap { |x| x.transform_values!(&:html_safe) if ''.respond_to?(:html_safe) }
+
+      def basic_link_icons
+        ICONS
+      end
+    end
+  end
+end

data/lib/rails_stuff/helpers/forms.rb

@@ -0,0 +1,21 @@
+module RailsStuff
+  module Helpers
+    module Forms
+      # Returns hidden field tags for requested fields when they are present in params.
+      # Usually used to bypass params in GET-forms.
+      def hidden_params_fields(*fields)
+        inputs = fields.flat_map do |field|
+          next unless params.key?(field)
+          val = params[field]
+          if val.is_a?(Array)
+            name = "#{field}[]"
+            val.map { |str| [name, str] }
+          else
+            [[field, val]]
+          end
+        end
+        safe_join inputs.map { |(name, val)| hidden_field_tag name, val if name }
+      end
+    end
+  end
+end

data/lib/rails_stuff/helpers/links.rb

@@ -0,0 +1,38 @@
+module RailsStuff
+  module Helpers
+    # Link helpers for basic actions.
+    module Links
+      ICONS = {
+        destroy:  -> { translate_action(:destroy) },
+        edit:     -> { translate_action(:edit) },
+        new:      -> { translate_action(:new) },
+      }
+
+      def basic_link_icons
+        ICONS
+      end
+
+      def basic_link_icon(action)
+        val = basic_link_icons[action]
+        val.is_a?(Proc) ? instance_exec(&val) : val
+      end
+
+      def link_to_destroy(url, **options)
+        link_to basic_link_icon(:destroy), url, {
+          title:  translate_action(:delete),
+          method: :delete,
+          data:   {confirm: translate_confirmation(:delete)},
+        }.merge!(options)
+      end
+
+      def link_to_edit(url = nil, **options)
+        link_to basic_link_icon(:edit), (url || url_for(action: :edit)),
+          {title: translate_action(:edit)}.merge!(options)
+      end
+
+      def link_to_new(url = nil, **options)
+        link_to basic_link_icon(:new), (url || url_for(action: :new)), options
+      end
+    end
+  end
+end