console_utils 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e5dbc7f627c5c02f9c9075f44a1146e7d35e2039
+  data.tar.gz: ecc4433de0aaebbf0b7a3bae68939a1773cb8ac5
+SHA512:
+  metadata.gz: 2fd7b962b54208e49932a4e9ff4caf4005443a10562bc8cac0efab42cabad1d766e2b032f469e39d3d9a22f3d14a066566c1bc4df3486c432d14fe8aa9284332
+  data.tar.gz: fb9aeb8c86251d0abac713e2e0a61cd103fb6aa2590556eb65200a6f52df6e13badf72f635cd982407915a06089dee0e728e6918c5239554479b4b11aecc29d3

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.1

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rails-console-utils.gemspec
+gemspec
+
+gem "rails", "~> 4.2"
+gem "pry"
+gem "rspec"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Anton
+
+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,238 @@
+# Rails Console Utils
+
+ConsoleUtils gem provides several handy tools to use in Rails Console. It includes following modules:
+
+1. **[RequestUtils](#requestutils)**  
+   the collection of methods to make either local or remote JSON API requests. 
+   Provides response body formatting and auto-token authentication feature 
+   (currently supports only params tokens).
+2. **[BenchUtils](#benchutils)**  
+   benchmark shorthands
+3. **[ActiveRecordUtils](#activerecordutils)**   
+   useful console methods for ActiveRecord::Base models
+4. **[OtherUtils](#otherutils)**  
+   uncategorized methods
+
+The gem was collected from several **very *(very-very)* raw** modules used in different projects in different time. The code was refactored, but currently there are no specs or complete docs (sowwy ^_^), but they are *coming soon*.
+
+## Installation
+
+Add this lines to your application's Gemfile.  
+**Note**: when using with `pry-rails` gem, make sure to depend it before this gem.
+
+```ruby
+group :development do
+  \## to enable inspecting procs' sources, uncomment next lines:
+  \# gem 'term-ansicolor', '1.1.5'
+  \# gem 'sourcify', '~> 0.6.0.rc4', require: false
+  
+  \## when using `pry-rails`, it should be somewhere here:
+  # gem 'pry-rails'
+  
+  gem 'console_utils'
+end
+```
+
+And then execute:
+
+    $ bundle
+
+## Configuration
+
+Parameters are changable by the `config.console_utils` key inside the app's configuration block. It is also available as `ConsoleUtils.configure(&block)` in the custom initializer file.
+
+Example part of `config/environments/development.rb`:
+
+```ruby
+Rails.application.configure do
+  # ...
+  if config.console_utils
+    config.console_utils.json_formatter = :jq
+    config.console_utils.remote_endpoint = Settings.base_url
+  end
+end
+```
+
+### Options:
+
+* `auto_token` - Enable auto-fetch of user's auth token in requests (default: `true`)
+* `curl_bin` - Binary path to curl (using in remote requests). (default: `"curl"`)
+* `curl_silence` - Disable print out generated curl command with remote requests. (default: `false`)
+* `default_uid` - ID of the user which will be used by default in requests (default: `1`)
+* `disabled_modules` - An array of disabled modules' names (default: `[]`)
+* `jq_command` - Command for jq json formatter (default: `"jq . -C"`)
+* `json_formatter` - JSON formatter used in API request helpers (:default or :jq)
+* `logger` - Output logger (Rails.logger by default)
+* `remote_endpoint` - Remote endpoint used in remote API request helpers (default: `"http://example.com"`)
+* `token_param` - A name of the request parameter used to authorize user by a token (default: `:token`)
+* `user_model_name` - A name of user's model (default: `:User`)
+* `user_primary_key` - A primary key of user's model (default: `:id`)
+* `user_token_column` - A column name with a user's token. Using by request tools. (default: `:auth_token`)
+
+## RequestUtils
+
+Includes requesters to a local (`exap`) or a remote (`remo`) project's API. There are many customizable settings in configuration, so it's better to check them before playing with this feature.
+
+The following examples are actual to both of requesters - just swap `exap` to `remo` and it will work.
+
+Appends auth token of default user to params, makes request and prints formatted response:
+
+```ruby
+exap.get("api/posts.json").preview
+```
+
+Authorize user #42, also copy formatted response to the pasteboard:
+
+```ruby
+exap.get("api/posts.json", 42).preview(&:pbcopy)
+```
+
+Authorize random user:
+
+```ruby
+exap.get("api/comments.json", :any).preview
+```
+
+Use additional request params (skip the second parameter to use default user), don't print response body:
+
+```ruby
+exap.put("api/account.json", 42, user: { name: "Anton" })
+```
+
+Skip auto-fetching user's token:
+
+```ruby
+exap.post("api/signup.json", nil, user: { name: "Guest" }).preview
+```
+
+**Note:** The `remo` requester supports the auto-token feature, but still fetchs tokens from a local DB.
+
+## BetchUtils
+
+Access to globally shared Benchmark.ips object, which works out of a block and allows to change the stack “on the fly” and to keep the result during the work.
+
+Just add reports:
+
+```ruby
+chips.("merge") { the_hash.merge(other_hash) }
+chips.("merge!") { the_hash.merge!(other_hash) }
+\# => x.report(..) { ... }
+```
+
+... and compare!
+
+```ruby
+chips.compare! # compares two reports: "merge" and "merge!"
+```
+
+And add more reports after:
+
+```ruby
+chips.("deep_merge") { the_hash.deep_merge(other_hash) }
+```
+
+... or change the existing one:
+
+```ruby
+chips.("merge!") { the_hash.deep_merge!(other_hash) }
+```
+
+... and compare again!
+
+```ruby
+chips.compare! # compare three reports: "merge", changed "merge!" and new "deep_merge"
+```
+
+You can remove report by a label:
+
+```ruby
+chips.del("merge!")
+```
+
+Split to a separate `Chips` object:
+
+```ruby
+other_chips = chips.split!("deep_merge") # split reports to separate hash
+```
+
+Well, to be honest, it is just a delegator of a reports hash, so:
+
+```ruby
+chips          # => { "merge" => proc { ... }, ... }
+chips["merge"] # => proc { ... }
+chips.clear    # clear all reports
+```
+
+## ActiveRecordUtils
+
+Includes methods to query a random record:
+
+```ruby
+User.random         # => reorder("RANDOM()")
+User.anyone         # get a random record (like [].sample method)
+User.active.anyone  # works under a scope - get a random active record
+User.anyid	          # get random id of an existing record
+```
+
+Also provides shorthand to find any user by id: `usr(id)`
+
+## OtherUtils
+
+#### clr()
+Term::ANSIColor shorthand
+
+#### shutting(:engine_key[, to: logger_level]) {}
+Shuts up the logger of a specified Rails engine for a given key (`:rails`, `:record`, `:controller` or `:view`).
+
+```ruby
+shutting(:view, to: :warn) do
+  ActionView.logger.info("not printed")
+  ActionView.logger.warn("printed")
+  Rails.logger.info("printed")
+end
+
+shutting(:rails, to: Logger::INFO) { ... }
+shutting(:record, to: 1) { ... }
+```
+
+## Array#to_proc
+
+> Oh no, core class extension!
+
+Converts array to proc with chained calls of items. Every item can be either a method name or an array containing a method name and args.
+
+```ruby
+the_hash = { :one => "One", :two => "Two", :three => 3, :four => nil }
+the_hash.select(&[[:[], 1], [:is_a?, String]])
+\# => { :one => "One", :two => "Two" }
+```
+
+Pretty good, huh? ;)
+
+See again:
+
+```ruby
+mapping = { "one" => "1", "two" => "2", "" => "0" }
+the_hash.values.map(&[:to_s, :downcase, [:sub, /one|two|$^/, mapping]])
+\# => ["1", "2", "3", "0"]
+```
+
+Avoid to use it in production, seriously.
+
+## AwesomePrint::Proc
+
+Just prints proc's source when inspecting proc. `Sourcify` is required, see the **Installation** section for notes.
+
+## 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/[my-github-username]/console_utils/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. 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,10 @@
+require "bundler/gem_tasks"
+
+require 'rdoc/task'
+
+RDoc::Task.new do |rdoc|
+  rdoc.main = "README.md"
+  rdoc.rdoc_dir = "doc"
+  rdoc.rdoc_files.include("README.md", "lib/**/*.rb")
+  rdoc.options = ["--no-dcov", "--visibility=protected"]
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "console_utils"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start
+
+# require "irb"
+# IRB.start

data/bin/setup

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

data/console_utils.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'console_utils/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "console_utils"
+  spec.version       = ConsoleUtils::VERSION
+  spec.authors       = ["Anton"]
+  spec.email         = ["anton.estum@gmail.com"]
+
+  spec.summary       = %q{Groovy tools for Rails Console.}
+  spec.description   = %q{Console Utils provides several handy tools to use in Rails Console.}
+  spec.homepage      = "https://github.com/estum/console_utils"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rails", ">= 4.1", "< 5"
+  spec.add_dependency "term-ansicolor"
+  spec.add_dependency "awesome_print"
+  spec.add_dependency "benchmark-ips"
+  # spec.add_dependency 'sourcify', '~> 0.6.0.rc4'
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rdoc"
+end

data/lib/awesome_print/proc.rb

@@ -0,0 +1,42 @@
+#:nodoc: all
+
+begin
+  require "sourcify"
+rescue LoadError
+end
+
+module AwesomePrint
+  module Proc
+    #:startdoc:
+    def self.included(base)
+      base.send :alias_method, :cast_without_proc, :cast
+      base.send :alias_method, :cast, :cast_with_proc
+    end
+
+    # Add Proc class to the dispatcher pipeline.
+    def cast_with_proc(obj, type)
+      if (type == :proc || obj.is_a?(::Proc)) && obj.respond_to?(:to_source)
+        :proc
+      else
+        cast_without_proc(obj, type)
+      end
+    end
+
+    private
+
+    # Format Proc object.
+    def awesome_proc(obj)
+      if !@options[:raw] && (/\A(?<kw>proc)\s*(?<block_source>.+?)\z/ =~ obj.to_source)
+        kw = "->" if obj.lambda?
+        sprintf("%s %s", colorize(kw, :keyword), colorize(block_source, :string))
+      else
+        awesome_object(obj)
+      end
+    end
+    #:enddoc:
+  end
+end
+
+if defined?(Sourcify) && Sourcify::VERSION >= "0.6.0.rc4"
+  AwesomePrint::Formatter.include(AwesomePrint::Proc)
+end

data/lib/console_utils.rb

@@ -0,0 +1,164 @@
+require "active_support"
+require "active_support/rails"
+require 'term/ansicolor'
+require 'console_utils/core_ext/array_to_proc'
+require "console_utils/version"
+
+begin
+  require "awesome_print"
+rescue LoadError
+end
+
+require "awesome_print/proc" if defined?(AwesomePrint)
+
+# = Rails Console Utils
+# Collection of utilities to use in Rails Console.
+#
+# == Modules
+#
+# [ActiveRecordUtils]
+#
+#     useful console methods for <tt>ActiveRecord::Base</tt> models
+#
+# [BenchUtils]
+#
+#     benchmark shorthands
+#
+# [RequestUtils]
+#
+#     tools to make local and remote JSON API requests with
+#     json response body formatting and automatic auth
+#     (currently supports only token auth).
+#
+# [OtherUtils]
+#
+#     uncategorized collection of methods
+#
+# == Configuration
+# Parameters are changable by the <tt>config.console_utils</tt> key inside
+# the app's configuration block. It is also available as
+# <tt>ConsoleUtils.configure(&block)</tt> in the custom initializer.
+module ConsoleUtils
+  extend ActiveSupport::Autoload
+
+  MODULES = [
+    :ActiveRecordUtils,
+    :RequestUtils,
+    :BenchUtils,
+    :OtherUtils
+  ]
+
+  MODULES.each { |mod| autoload mod }
+
+  JSON_FORMATTERS = %i(default jq)
+
+  # :section: Configuration
+
+  ##
+  # :attr:
+  # An array with disabled modules (default: <tt>[]</tt>)
+  mattr_accessor(:disabled_modules) { [] }
+  ##
+  # :attr:
+  # Enable the auto-fetching of user's auth token in requests
+  # (default: <tt>true</tt>)
+  mattr_accessor(:auto_token) { true }
+  ##
+  # :attr:
+  # ID of the user which will be used by default in requests
+  # (default: <tt>1</tt>)
+  mattr_accessor(:default_uid) { 1 }
+  ##
+  # :attr:
+  # A name of user's model (default: <tt>:User</tt>)
+  mattr_accessor(:user_model_name) { :User }
+  ##
+  # :attr:
+  # A primary key of user's model (default: <tt>:id</tt>)
+  mattr_accessor(:user_primary_key) { :id }
+  ##
+  # :attr:
+  # A column name with a user's token. Using by request tools.
+  # (default: <tt>:auth_token</tt>)
+  mattr_accessor(:user_token_column) { :auth_token }
+  ##
+  # :attr:
+  # A name of the request parameter used to authorize user by a token
+  # (default: <tt>:token</tt>)
+  mattr_accessor(:token_param) { :token }
+  ##
+  # :attr:
+  # JSON formatter used in API request helpers
+  # (<tt>:default</tt> or <tt>:jq</tt>)
+  mattr_accessor(:json_formatter) { :default }
+  ##
+  # :attr:
+  # Command for +jq+ json formatter (default: <tt>"jq . -C"</tt>)
+  mattr_accessor(:jq_command) { "jq . -C" }
+  ##
+  # :attr:
+  # Binary path to +curl+ (using in remote requests). (default: <tt>"curl"</tt>)
+  mattr_accessor(:curl_bin) { "curl" }
+  ##
+  # :attr:
+  # Don't print generated curl command with remote requests.
+  # (default: <tt>false</tt>)
+  mattr_accessor(:curl_silence) { false }
+  ##
+  # :attr:
+  # Remote endpoint used in remote API request helpers
+  # (default: <tt>"http://example.com"</tt>)
+  mattr_accessor(:remote_endpoint) { "http://example.com" }
+  ##
+  # :attr:
+  # Output logger (<tt>Rails.logger</tt> by default)
+  mattr_accessor :logger
+
+
+  # :section: Class Methods
+
+  class << self
+    def config
+      self
+    end
+    private :config
+
+    # :method: self.configure
+    def configure
+      yield(config)
+    end
+
+    # Returns User's class set in the <tt>:user_class_name</tt>
+    def user_model
+      Object.const_get(user_model_name)
+    end
+    alias_method :user_class, :user_model
+
+    # Finds +user_model+ by +user_primary_key+
+    def find_user(id, scope: nil)
+      (scope || user_model).where(user_primary_key => id).first!
+    end
+
+    def enabled_modules
+      ConsoleUtils::MODULES - disabled_modules
+    end
+
+    # Yields each enabled module with a given block
+    def each_enabled_module
+      enabled_modules.each { |mod| yield const_get(mod) }
+    end
+
+    # Setup enabled modules by extending given context
+    def setup_modules_to(context = nil)
+      context = yield() if block_given?
+      puts "Console instance: #{context.inspect}" if ENV["CONSOLE_UTILS_DEBUG"]
+      each_enabled_module { |mod| context.send(:extend, mod) }
+    end
+  end
+
+  ActiveSupport.run_load_hooks(:console_utils, self)
+end
+
+if defined? Rails
+  require "console_utils/railtie"
+end

data/lib/console_utils/active_record_utils.rb

@@ -0,0 +1,19 @@
+module ConsoleUtils #:nodoc:
+  module ActiveRecordUtils
+    extend ActiveSupport::Autoload
+
+    autoload :RandomRecord
+
+    def self.extended(mod)
+      ActiveSupport.on_load(:active_record) do
+        ActiveRecord::Relation.send(:include, RandomRecord::FinderMethods)
+        ActiveRecord::Base.send(:extend, RandomRecord::Querying)
+      end
+    end
+
+    # Shortcut to <tt>ConsoleUtils.find_user(id)</tt>
+    def usr(id)
+      ConsoleUtils.find_user(id)
+    end
+  end
+end

data/lib/console_utils/active_record_utils/random_record.rb

@@ -0,0 +1,21 @@
+module ConsoleUtils::ActiveRecordUtils  #:nodoc:
+  module RandomRecord #:nodoc:
+    module FinderMethods
+      def random
+        reorder('RANDOM()')
+      end
+
+      def anyone
+        random.first
+      end
+
+      def anyid
+        anyone.id
+      end
+    end
+
+    module Querying
+      delegate :random, :anyone, :anyid, to: :all
+    end
+  end
+end

data/lib/console_utils/bench_utils.rb

@@ -0,0 +1,46 @@
+module ConsoleUtils #:nodoc:
+
+  # = Benchmark utils
+  #
+  # Provides the collection of tools for benchmarking
+
+  module BenchUtils
+    extend ActiveSupport::Autoload
+
+    autoload :Chips
+
+    # :call-seq:
+    #   chips[ .("report") {} | .compare! {} | ... ]
+    #
+    # Access to globally shared <tt>Benchmark.ips</tt> object, which
+    # works out of a block and allows to change the stack "on the fly"
+    # and to keep the result during the work.
+    #
+    # ==== Examples
+    #
+    #     chips.("merge") { the_hash.merge(other_hash) }
+    #     chips.("merge!") { the_hash.merge!(other_hash) }
+    #     # => x.report(..) { ... }
+    #
+    #     chips.compare! # compare two reports
+    #
+    #     # add more reports:
+    #     chips.("deep_merge") { the_hash.deep_merge(other_hash) }
+    #
+    #     # change an existing:
+    #     chips.("merge!") { the_hash.deep_merge!(other_hash) }
+    #
+    #     chips.compare! # compare three reports
+    #
+    #     # remove report labeled as "merge!":
+    #     chips.del("merge!")
+    #
+    #     # it is just a delegator of the hash:
+    #     chips          # => { "merge" => #<Proc:...>, ... }
+    #     chips["merge"] # => #<Proc:...>
+    #     chips.clear    # clear procs
+    def chips
+      Chips.shared
+    end
+  end
+end

data/lib/console_utils/bench_utils/chips.rb

@@ -0,0 +1,62 @@
+require "benchmark/ips"
+
+module ConsoleUtils::BenchUtils #:nodoc:
+  class Chips < SimpleDelegator
+    class << self
+      # The globally shared +Chips+ object
+      def shared
+        @shared ||= new
+      end
+
+      def method_missing(meth, *args, &blk)
+        shared.respond_to?(meth) ? shared.send(meth, *args, &blk) : super
+      end
+
+      def respond_to_missing?(*args)
+        shared.respond_to?(*args) || super
+      end
+    end
+
+    attr_reader :results
+
+    # Creates Chips context using a given hash of reports.
+    def initialize(reports = nil)
+      super(reports.to_h)
+      @results = []
+    end
+
+    # Executes <tt>Benchmark.ips {|x| ...; x.compare! }</tt> using
+    # the given hash of procs as reports and push the result to
+    # <tt>results</tt> stack.
+    def compare!
+      results << begin
+        Benchmark.ips do |x|
+          each_pair {|name, proc| x.report(name, &proc) }
+          x.compare!
+        end
+      end
+    end
+
+    # :call-seq:
+    #   call("label") { ...things to bench... }
+    #
+    # Adds a labeled report block. The same as <tt>x.report(label) { ... }</tt>.
+    def call(name, &block)
+      self[name] = block.to_proc
+    end
+
+    # Get a recent result
+    def recent
+      results.last
+    end
+
+    # Splits reports to a new context
+    def split!(*args)
+      Chips.new(__getobj__.split!(*args))
+    end
+
+    def del(*args)
+      __getobj__.delete(*args)
+    end
+  end
+end

data/lib/console_utils/core_ext/array_to_proc.rb

@@ -0,0 +1,30 @@
+unless Array.method_defined?(:to_proc)
+  class Array
+    # :call-seq:
+    #   [].to_proc
+    #   &[chain, [:of_calls, and, args], ...]
+    #
+    # Converts array to proc with chained calls of items.
+    # Every item can be either a method name or an array containing
+    # a method name and args.
+    #
+    # ==== Examples
+    #
+    #     the_hash = { :one => "One", :two => "Two", :three => 3, :four => nil }
+    #     mapping = { "one" => "1", "two" => "2", "" => "0" }
+    #
+    #     the_hash.select(&[[:[], 1], [:is_a?, String]])
+    #     # => { :one => "One", :two => "Two" }
+    #
+    #     the_hash.values.map(&[:to_s, :downcase, [:sub, /one|two|$^/, mapping]])
+    #     # => ["1", "2", "3", "0"]
+    def to_proc
+      proc do |*obj|
+        obj = obj.shift if obj.size == 1
+        reduce(obj) do |chain, sym|
+          chain.public_send(*Array(sym).flatten)
+        end
+      end
+    end
+  end
+end

data/lib/console_utils/other_utils.rb

@@ -0,0 +1,56 @@
+module ConsoleUtils #:nodoc:
+  module OtherUtils
+    # <tt>Term::ANSIColor</tt> shorthand
+    def clr
+      Term::ANSIColor
+    end
+
+    # :call-seq:
+    #   shutting(:engine_key[, to: logger_level]) {}
+    #
+    # Shuts up logger of Rails engine by a given key (<tt>:rails</tt>, <tt>:record</tt>,
+    # <tt>:controller</tt> or <tt>:view</tt>).
+    #
+    #     shutting(:view, to: :warn) do
+    #       ActionView.logger.info("not printed")
+    #       ActionView.logger.warn("printed")
+    #       Rails.logger.info("printed")
+    #     end
+    #
+    #     shutting(:rails, to: Logger::INFO) { ... }
+    #     shutting(:record, to: 1) { ... }
+    #
+    def shutting(*args, &block)
+      Shutting.(*args, &block)
+    end
+
+    class Shutting
+      ENGINES_KEYS_MAP = {
+        :rails      => "Rails",
+        :record     => "ActiveRecord::Base",
+        :controller => "ActionController::Base",
+        :view       => "ActionView::Base"
+      }
+
+      def self.call(*args, &block)
+        new(*args).call(&block)
+      end
+
+      def initialize(key, to: Logger::WARN)
+        @key = key
+        @level = to
+        @level = Logger.const_get(@level.upcase) unless @level.is_a?(Numeric)
+      end
+
+      def call(&block)
+        with_logger { |logger| logger.silence(@level, &block) }
+      end
+
+      # Yields engine's logger for a given key.
+      def with_logger
+        const_get(ENGINES_KEYS_MAP[@key]).
+          logger.tap { |logger| yield(logger) unless logger.nil? }
+      end
+    end
+  end
+end

data/lib/console_utils/railtie.rb

@@ -0,0 +1,35 @@
+require "rails/railtie"
+
+module ConsoleUtils
+  ##
+  # Console Utils Railtie
+  class Railtie < ::Rails::Railtie
+    #:nodoc: all
+    config.console_utils = ActiveSupport::OrderedOptions.new
+
+    initializer 'console_utils.logger' do
+      ActiveSupport.on_load(:console_utils) { self.logger = ::Rails.logger }
+    end
+
+    initializer "console_utils.set_configs" do |app|
+      options = app.config.console_utils
+
+      options.disabled_modules ||= ConsoleUtils.disabled_modules
+      options.disabled_modules << :ActiveRecordUtils unless defined?(ActiveRecord)
+
+      ActiveSupport.on_load(:console_utils) do
+        options.each { |k,v| send(:"#{k}=", v) }
+      end
+    end
+
+    console do |app|
+      ConsoleUtils.setup_modules_to do
+        if defined?(Pry)
+          TOPLEVEL_BINDING.eval('self')
+        else
+          Rails.application.config.console::ExtendCommandBundle
+        end
+      end
+    end
+  end
+end

data/lib/console_utils/request_utils.rb

@@ -0,0 +1,77 @@
+module ConsoleUtils #:nodoc:
+
+  # = Request Utils
+  # Provides the collection of tools to make JSON API requests and get formatted output.
+  # To use system-installed +jq+ utility to format json, change +json_formatter+
+  # option in the config.
+
+  module RequestUtils
+    extend ActiveSupport::Autoload
+
+    autoload :Requester
+    autoload :Exap
+    autoload :Remo
+
+    # :call-seq:
+    #   autoken(id)
+    #   autoken(:any)
+    #
+    # Returns user's token by primary key. Use <tt>:any</tt> to get random user.
+    def autoken(id)
+      user = id == :any ? user_scope.anyone : ConsoleUtils.find_user(id, scope: user_scope)
+      puts "User #{user.public_send(ConsoleUtils.user_primary_key)}" if id == :any
+      user.public_send(ConsoleUtils.user_token_column)
+    end
+
+    # :call-seq:
+    #   exap(.get|.post|.put|...)(url, user_id = nil, **params)
+    #
+    # Local API requester context.
+    # See also: <tt>ConsoleUtils::RequestUtils::Exap</tt>
+    #
+    # ==== Examples:
+    #
+    # Appends auth token of default user to params, makes request and prints formatted response:
+    #
+    #     exap.get("api/posts.json").preview
+    #
+    # Authorize user #42, also copy formatted response to the pasteboard:
+    #
+    #     exap.get("api/posts.json", 42).preview(&:pbcopy)
+    #
+    # Authorize random user:
+    #
+    #     exap.get("api/comments.json", :any).preview
+    #
+    # Use additional request params (skip the second parameter to use default user),
+    # don't print response body:
+    #
+    #     exap.put("api/account.json", 42, user: { name: "Anton" })
+    #
+    # Skip auto-fetching user's token:
+    #
+    #     exap.post("api/signup.json", nil, user: { name: "Guest" }).preview
+
+    def exap
+      Exap.new(self)
+    end
+
+    # :call-seq:
+    #   remo(.get|.post|.put|...)(url, user_id = nil, **params)
+    #
+    # Remote API requester context.
+    # See also: <tt>ConsoleUtils::RequestUtils::Remo</tt>
+    #
+    # ==== Examples:
+    # See +exap+ examples.
+    def remo
+      Remo.new(self)
+    end
+
+    private
+
+    def user_scope
+      ConsoleUtils.user_model.select([:id, :auth_token])
+    end
+  end
+end

data/lib/console_utils/request_utils/exap.rb

@@ -0,0 +1,31 @@
+require "console_utils/request_utils/requester"
+
+module ConsoleUtils::RequestUtils #:nodoc:
+  class Exap < Requester
+    INSPECT_FORMAT = "<Local: %s (%s)>".freeze
+
+    REQUEST_METHODS.each do |reqm|
+      define_method(reqm) { |*args| resp_wrap(reqm, *args) }
+    end
+
+    def to_s
+      response.try(:body)
+    end
+
+    def inspect
+      format INSPECT_FORMAT, request.path, response.status
+    end
+
+    private
+
+    delegate :controller, to: :app, prefix: true, allow_nil: true
+    delegate :request, :response, to: :app_controller, allow_nil: true
+
+    def resp_wrap(meth, url, *args)
+      @url, @_args = url, args
+      p args
+      app.send(meth, url, *normalize_args)
+      self
+    end
+  end
+end

data/lib/console_utils/request_utils/remo.rb

@@ -0,0 +1,59 @@
+require 'uri'
+require "console_utils/request_utils/requester"
+
+module ConsoleUtils::RequestUtils #:nodoc:
+  class Remo < Requester
+    OUT_FORMAT      = "\n%{size_download}\n%{time_total}".freeze
+    INSPECT_FORMAT  = "<Remote: %s in %s ms>".freeze
+    INSPECT_NOTHING = "<Remote: nothing>".freeze
+
+    attr_reader :request_method
+
+    REQUEST_METHODS.each do |reqm|
+      define_method(reqm) do |url, *args|
+        @_args = args
+        @url   = urlify(url, *normalize_args)
+        @request_method = reqm.to_s.upcase
+        perform
+      end
+    end
+
+    def inspect
+      if @url && @_time
+        format(INSPECT_FORMAT, @url, @_time)
+      else
+        INSPECT_NOTHING
+      end
+    end
+
+    def to_s
+      @_body
+    end
+
+    protected
+
+    def perform
+      IO.popen(curl_command, "r+") { |io| set_payload!(io.readlines) }
+    end
+
+    private
+
+    def set_payload!((*body_lines, size, time))
+      @_body = body_lines.join
+      @_size = size.to_f
+      @_time = time.tr(?,, ?.).to_f
+      self
+    end
+
+    def curl_command
+      %W(#{ConsoleUtils.curl_bin} --silent --write-out #{OUT_FORMAT} -X #{request_method} #{url}).
+        tap { |cmd| puts "# #{cmd.shelljoin.inspect}" unless ConsoleUtils.curl_silence }
+    end
+
+    def urlify(*args)
+      options = args.extract_options!
+      URI.join(ConsoleUtils.remote_endpoint, *args).
+        tap { |uri| uri.query = options.to_query }.to_s
+    end
+  end
+end

data/lib/console_utils/request_utils/requester.rb

@@ -0,0 +1,125 @@
+require 'json'
+require 'active_support/core_ext/numeric'
+
+module ConsoleUtils::RequestUtils #:nodoc:
+  class Requester < SimpleDelegator
+    REQUEST_METHODS = %i(get post put delete patch).freeze
+
+    attr_reader :url
+
+    def to_h
+      JSON.parse(to_s)
+    end
+
+    def to_body
+      JSON.pretty_generate(to_h)
+    rescue JSON::GeneratorError
+      to_s
+    end
+
+    NO_RESPONSE = Term::ANSIColor.red(" \u27A7 Empty response's body.").freeze
+
+    def preview(mth = nil)
+      if output = to_s.presence
+        case ConsoleUtils.json_formatter
+        when :default then puts to_body
+        when :jq      then puts jq(output)
+        end
+
+        show_complete_in!
+        show_transfered!
+
+        yield(self) if block_given?
+      else
+        puts NO_RESPONSE
+      end
+    end
+
+    INFO_FORMAT = "%#-.50{url} | %#10{human_size} | %#10{human_time}\n".freeze
+
+    def print_info
+      tap { printf(INFO_FORMAT, to_info_hash) }
+    end
+
+    INFO_HASH_FIELDS = %i(url size time human_size human_time)
+
+    def to_info_hash
+      INFO_HASH_FIELDS.zip(INFO_HASH_FIELDS.map(&method(:public_send))).to_h
+    end
+
+    def size_downloaded
+      size.to_s(:human_size)
+    end
+
+    alias_method :human_size, :size_downloaded
+
+    def time_ms
+      time.to_s(:human, units: { unit: 'ms' })
+    end
+
+    alias_method :human_time, :time_ms
+
+    def size
+      @_size.bytes
+    end
+
+    def time
+      @_time.in_milliseconds
+    end
+
+    protected
+
+    AUTOAUTH_FORMAT = %('ID: %s' %p\n).freeze
+
+    def normalize_args
+      if ConsoleUtils.auto_token
+        uid = (@_args[0].is_a?(Hash) || @_args.empty?) ? ConsoleUtils.default_uid : @_args.shift
+
+        if uid.present?
+          printf(AUTOAUTH_FORMAT, uid, @_args)
+          opts = @_args.extract_options!
+          @_args.unshift(opts.tap { |x| x[ConsoleUtils.token_param] ||= __getobj__.autoken(uid) })
+        end
+      end
+
+      @_args
+    end
+
+
+    private
+
+    PBCOPY_MESSAGE = Term::ANSIColor.green(" \u27A4 Response body copied to pasteboard\n").freeze
+
+    # Copies to pasteboard
+    def pbcopy(content)
+      IO.popen('pbcopy', 'w') { |io| io << content.to_s }
+      puts PBCOPY_MESSAGE
+    end
+
+    COMPLETE_IN = Term::ANSIColor.green("Complete in %s").freeze
+
+    def show_complete_in!(reset = true)
+      return if @_time.nil?
+      puts "=> #{COMPLETE_IN % [time_ms]}"
+      @_time = nil
+    end
+
+    TRANSFERED = Term::ANSIColor.cyan("Transfered: %s").freeze
+
+    def show_transfered!(reset = true)
+      return if @_size.nil?
+      puts "=> #{TRANSFERED % [size_downloaded]}"
+      @_size = nil
+    end
+
+    private_constant :REQUEST_METHODS, :AUTOAUTH_FORMAT, :DEFAULT_UID,
+                     :PBCOPY_MESSAGE, :NO_RESPONSE, :COMPLETE_IN, :TRANSFERED,
+                     :INFO_FORMAT
+    # -
+
+    # Pretty formats json
+    def jq(raw)
+     IO.popen(ConsoleUtils.jq_command, 'r+') { |io| (io << raw).tap(&:close_write).read }
+    end
+  end
+end

data/lib/console_utils/version.rb

@@ -0,0 +1,3 @@
+module ConsoleUtils
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: console_utils
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Anton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: term-ansicolor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Console Utils provides several handy tools to use in Rails Console.
+email:
+- anton.estum@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- console_utils.gemspec
+- lib/awesome_print/proc.rb
+- lib/console_utils.rb
+- lib/console_utils/active_record_utils.rb
+- lib/console_utils/active_record_utils/random_record.rb
+- lib/console_utils/bench_utils.rb
+- lib/console_utils/bench_utils/chips.rb
+- lib/console_utils/core_ext/array_to_proc.rb
+- lib/console_utils/other_utils.rb
+- lib/console_utils/railtie.rb
+- lib/console_utils/request_utils.rb
+- lib/console_utils/request_utils/exap.rb
+- lib/console_utils/request_utils/remo.rb
+- lib/console_utils/request_utils/requester.rb
+- lib/console_utils/version.rb
+homepage: https://github.com/estum/console_utils
+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: Groovy tools for Rails Console.
+test_files: []
+has_rdoc: