Code Climate

Rails Console Utils

ConsoleUtils gem provides several handy tools to use in Rails Console. It includes following modules:

  1. 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 benchmark shorthands
  3. ActiveRecordUtils useful console methods for ActiveRecord::Base models
  4. 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.

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:

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:

  • 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_token - A plain string of the default token used to authorize user (default: nil)
  • 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)
  • request_auto_auth - Enable the auth automator with the exap (default: true)
  • auth_automator - Specifies a callable object, which will hook requests with credentials. There are two built-in implementations: the default one ConsoleUtils::RequestUtils::DefaultAuthAutomator and the ConsoleUtils::RequestUtils::SimpleTokenAutomator, which is useful when using the simple_token_automator gem.

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:

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

Note: The remo requester supports the auto-token feature, but still fetchs tokens from a local DB.

BenchUtils

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:

chips.("merge") { the_hash.merge(other_hash) }
chips.("merge!") { the_hash.merge!(other_hash) }# => x.report(..) { ... }

... and compare!

chips.compare! # compares two reports: "merge" and "merge!"

And add more reports after:

chips.("deep_merge") { the_hash.deep_merge(other_hash) }

... or change the existing one:

chips.("merge!") { the_hash.deep_merge!(other_hash) }

... and compare again!

chips.compare! # compare three reports: "merge", changed "merge!" and new "deep_merge"

You can remove report by a label:

chips.del("merge!")

Split to a separate Chips object:

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:

chips          # => { "merge" => proc { ... }, ... }
chips["merge"] # => proc { ... }
chips.clear    # clear all reports

ActiveRecordUtils

Includes methods to query a random record:

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 an id of some existing record

Also provides shorthand to find any user by id: usr(id)

OtherUtils

clr()

Pastel 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).

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.

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:

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.

Contributing

  1. Fork it ( https://github.com/estum/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