super-smart-box 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ff967adc39cbfc311e3bcc9edb8b1be379b27c2c4146d3d82bdfb5ca4f6d8f8d
+  data.tar.gz: 94ef320d715588bcced1fb32863cb083cdbdb0c71fd5a2c04c76ce0b25138327
+SHA512:
+  metadata.gz: b8a4e4d437f283760131cfa37f96cd43b54f528bb40e600bc7e79e271316a842da6f9bbfa5ded694fcb167eb140354cc0bc8d5ae1e89cdaafa41de402312e7e4
+  data.tar.gz: 2166d451ed1abf3f5761199bd659d04946765c79fe0fbbccd0274a1402bda429a185827d6a99b9d8ca974b5d15c395aa44973bcc19a77133bfe1c3d6a92c6536

data/pry-rails-0.3.11/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in pry-rails.gemspec
+gemspec

data/pry-rails-0.3.11/LICENCE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Robin Wenglewski
+
+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/pry-rails-0.3.11/Rakefile

@@ -0,0 +1,44 @@
+require "rubygems"
+require "bundler/setup"
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "appraisal"
+
+Rake::TestTask.new do |t|
+  t.libs.concat %w(pry-rails spec)
+  t.pattern = "spec/*_spec.rb"
+end
+
+desc 'Start the Rails server'
+task :server => :development_env do
+  require 'rails/commands/server'
+  Rails::Server.start(
+    :server => 'WEBrick',
+    :environment => 'development',
+    :Host => '0.0.0.0',
+    :Port => 3000,
+    :config => 'config/config.ru'
+  )
+end
+
+desc 'Start the Rails console'
+task :console => :development_env do
+  if (Rails::VERSION::MAJOR == 5 && Rails::VERSION::MINOR >= 1) ||
+      Rails::VERSION::MAJOR >= 6
+    require 'rails/command'
+    require 'rails/commands/console/console_command'
+  else
+    require 'rails/commands/console'
+  end
+
+  Rails::Console.start(Rails.application)
+end
+
+task :development_env do
+  ENV['RAILS_ENV'] = 'development'
+  require File.expand_path('../spec/config/environment', __FILE__)
+  Dir.chdir(Rails.application.root)
+end
+
+# Must invoke indirectly, using `rake appraisal`.
+task :default => [:test]

data/pry-rails-0.3.11/Readme.md

@@ -0,0 +1,136 @@
+	This project is not actively maintained and looking for a maintainer!
+
+
+# Description
+
+Avoid repeating yourself, use pry-rails instead of copying the initializer to every rails project.
+This is a small gem which causes `rails console` to open [pry](https://pry.github.io/). It therefore depends on *pry*.
+
+# Prerequisites
+
+- A Rails >= 3.0 Application
+- Ruby >= 1.9
+
+# Installation
+
+Add this line to your gemfile:
+
+	gem 'pry-rails', :group => :development
+
+`bundle install` and enjoy pry.
+
+# Usage
+
+```
+$ rails console
+[1] pry(main)> show-routes
+     pokemon POST   /pokemon(.:format)      pokemons#create
+ new_pokemon GET    /pokemon/new(.:format)  pokemons#new
+edit_pokemon GET    /pokemon/edit(.:format) pokemons#edit
+             GET    /pokemon(.:format)      pokemons#show
+             PUT    /pokemon(.:format)      pokemons#update
+             DELETE /pokemon(.:format)      pokemons#destroy
+        beer POST   /beer(.:format)         beers#create
+    new_beer GET    /beer/new(.:format)     beers#new
+   edit_beer GET    /beer/edit(.:format)    beers#edit
+             GET    /beer(.:format)         beers#show
+             PUT    /beer(.:format)         beers#update
+             DELETE /beer(.:format)         beers#destroy
+[2] pry(main)> show-routes --grep beer
+        beer POST   /beer(.:format)         beers#create
+    new_beer GET    /beer/new(.:format)     beers#new
+   edit_beer GET    /beer/edit(.:format)    beers#edit
+             GET    /beer(.:format)         beers#show
+             PUT    /beer(.:format)         beers#update
+             DELETE /beer(.:format)         beers#destroy
+[3] pry(main)> show-routes --grep new
+ new_pokemon GET    /pokemon/new(.:format)  pokemons#new
+    new_beer GET    /beer/new(.:format)     beers#new
+[4] pry(main)> show-models
+Beer
+  id: integer
+  name: string
+  type: string
+  rating: integer
+  ibu: integer
+  abv: integer
+  created_at: datetime
+  updated_at: datetime
+  belongs_to hacker
+Hacker
+  id: integer
+  social_ability: integer
+  created_at: datetime
+  updated_at: datetime
+  has_many pokemons
+  has_many beers
+Pokemon
+  id: integer
+  name: string
+  caught: binary
+  species: string
+  abilities: string
+  created_at: datetime
+  updated_at: datetime
+  belongs_to hacker
+  has_many beers through hacker
+```
+
+## Custom Rails prompt
+
+If you want to permanently include the current Rails environment and project name
+in the Pry prompt, put the following lines in your project's `.pryrc`:
+
+```ruby
+Pry.config.prompt = Pry::Prompt[:rails]
+```
+
+If `.pryrc` could be loaded without pry-rails being available or installed,
+guard against setting `Pry.config.prompt` to `nil`:
+
+```ruby
+if Pry::Prompt[:rails]
+  Pry.config.prompt = Pry::Prompt[:rails]
+end
+```
+
+Check out `change-prompt --help` for information about temporarily
+changing the prompt for the current Pry session.
+
+## Disabling pry-rails
+
+If pry-rails is included in your application but you would prefer not to use it, you may run the following command to set the appropriate environment variable to disable initialization and fall back to the default IRB console:
+```shell
+DISABLE_PRY_RAILS=1 rails console
+```
+
+Note that you may need to run `spring stop` first.
+
+# Developing and Testing
+
+This repo uses [Roadshow] to generate a [Docker Compose] file for each
+supported version of Rails (with a compatible version of Ruby for each one).
+
+To run specs across all versions, you can either [get the Roadshow tool] and
+run `roadshow run`, or use Docker Compose directly:
+
+```
+$ for fn in scenarios/*.docker-compose.yml; do docker-compose -f $fn run --rm scenario; done
+```
+
+You can also manually run the Rails console and server on each version with
+`roadshow run rake console` and `roadshow run rake server`, or run them on a
+specific version with, e.g., `roadshow run -s rails40 rake console`.
+
+To update the set of scenarios, edit `scenarios.yml` and run `roadshow
+generate`, although the Gemfiles in the `scenarios` directory need to be
+maintained manually.
+
+[Roadshow]: https://github.com/rf-/roadshow
+[Docker Compose]: https://docs.docker.com/compose/
+[get the Roadshow tool]: https://github.com/rf-/roadshow/releases
+
+# Alternative
+
+If you want to enable pry everywhere, make sure to check out
+[pry everywhere](http://lucapette.me/pry-everywhere).

data/pry-rails-0.3.11/lib/pry-rails/commands/find_route.rb

@@ -0,0 +1,84 @@
+class PryRails::FindRoute < Pry::ClassCommand
+  match 'find-route'
+  group 'Rails'
+  description 'See which URLs match a given Controller.'
+  banner <<-BANNER
+    Usage: find-route <controller>
+
+    Returns the URL(s) that match a given controller or controller action.
+
+    find-route MyController#show  #=> The URL that matches the MyController show action
+    find-route MyController       #=> All the URLs that hit MyController
+    find-route Admin              #=> All the URLs that hit the Admin namespace
+    find-route Com                #=> All the URLS whose controller regex matches /Comm/, e.g CommentsController
+  BANNER
+
+  def process(controller)
+    controller_string = controller.to_s
+    if single_action?(controller_string)
+      single_action(controller_string)
+    else
+      all_actions(controller_string)
+    end
+  end
+
+  private
+
+  def single_action(controller)
+    show_routes { |route| route.defaults == controller_and_action_from(controller) }
+  end
+
+  def all_actions(controller)
+    show_routes do |route|
+      route.defaults[:controller].to_s =~ /#{normalize_controller_name(controller)}/
+    end
+  end
+
+  def controller_and_action_from(controller_and_action)
+    controller, action = controller_and_action.split("#")
+    {controller: normalize_controller_name(controller), action: action}
+  end
+
+  def routes
+    Rails.application.routes.routes
+  end
+
+  def normalize_controller_name(controller)
+    controller.underscore.chomp('_controller')
+  end
+
+  def show_routes(&block)
+    all_routes = routes.select(&block)
+    if all_routes.any?
+      grouped_routes = all_routes.group_by { |route| route.defaults[:controller] }
+      result = grouped_routes.each_with_object("") do |(controller, routes), res|
+        res << "Routes for " + bold(controller.to_s.camelize + "Controller") + "\n"
+        res << "--\n"
+        routes.each do |route|
+          spec = route.path.is_a?(String) ? route.path : route.path.spec
+          res << "#{route.defaults[:action]} #{bold(verb_for(route))} #{spec}  #{route_helper(route.name)}" + "\n"
+        end
+        res << "\n"
+      end
+      stagger_output result
+    else
+      output.puts "No routes found."
+    end
+  end
+
+  def route_helper(name)
+    name && "[#{name}]"
+  end
+
+  def verb_for(route)
+    %w(GET PUT POST PATCH DELETE).find { |v| route.verb === v }
+  end
+
+  def single_action?(controller)
+    controller =~ /#/
+  end
+
+  PryRails::Commands.add_command(self)
+end
+
+PryRails::Commands.alias_command "find-routes", "find-route"

data/pry-rails-0.3.11/lib/pry-rails/commands/recognize_path.rb

@@ -0,0 +1,35 @@
+class PryRails::RecognizePath < Pry::ClassCommand
+  match 'recognize-path'
+  group 'Rails'
+  description 'See which route matches a URL.'
+  command_options argument_required: true
+  banner <<-BANNER
+    Usage: recognize-path <path> [-m|--method METHOD]
+
+    Verifies that a given path is mapped to the right controller and action.
+
+    recognize-path example.com
+    recognize-path example.com -m post
+  BANNER
+
+  def options(opt)
+    opt.on :m, :method, "Methods", :argument => true
+  end
+
+  def process(path)
+    method = (opts.m? ? opts[:m] : :get)
+    routes = Rails.application.routes
+
+    begin
+      info = routes.recognize_path("http://#{path}", :method => method)
+    rescue ActionController::UnknownHttpMethod
+      output.puts "Unknown HTTP method: #{method}"
+    rescue ActionController::RoutingError => e
+      output.puts e
+    end
+
+    output.puts Pry::Helpers::BaseHelpers.colorize_code(info)
+  end
+
+  PryRails::Commands.add_command(self)
+end

data/pry-rails-0.3.11/lib/pry-rails/commands/show_middleware.rb

@@ -0,0 +1,71 @@
+class PryRails::ShowMiddleware < Pry::ClassCommand
+  match 'show-middleware'
+  group 'Rails'
+  description 'Show all middleware (that Rails knows about).'
+  banner <<-BANNER
+    Usage: show-middleware [-G]
+
+    show-middleware shows the Rails app's middleware.
+
+    If this pry REPL is attached to a Rails server, the entire middleware
+    stack is displayed.  Otherwise, only the middleware Rails knows about is
+    printed.
+  BANNER
+
+  def options(opt)
+    opt.on :G, "grep", "Filter output by regular expression", :argument => true
+  end
+
+  def process
+    # Assumes there is only one Rack::Server instance.
+    # TODO: Figure out what replaced Rack::Server so that we can show the
+    # entire middleware stack on recent Rails versions.
+    server = nil
+    if defined?(Rack::Server)
+      ObjectSpace.each_object(Rack::Server) do |object|
+        server = object
+      end
+    end
+
+    middlewares = []
+
+    if server
+      stack = server.instance_variable_get("@wrapped_app")
+      middlewares << stack.class.to_s
+
+      while stack.instance_variable_defined?("@app") do
+        stack = stack.instance_variable_get("@app")
+        # Rails 3.0 uses the Application class rather than the application
+        # instance itself, so we grab the instance.
+        stack = Rails.application  if stack == Rails.application.class
+        middlewares << stack.class.to_s  if stack != Rails.application
+      end
+    else
+      middleware_names = Rails.application.middleware.map do |middleware|
+        # After Rails 3.0, the middleware are wrapped in a special class
+        # that responds to #name.
+        if middleware.respond_to?(:name)
+          middleware.name
+        else
+          middleware.inspect
+        end
+      end
+      middlewares.concat middleware_names
+    end
+    middlewares << Rails.application.class.to_s
+    print_middleware middlewares.grep(Regexp.new(opts[:G] || "."))
+  end
+
+  def print_middleware(middlewares)
+    middlewares.each do |middleware|
+      string = if middleware == Rails.application.class.to_s
+        "run #{middleware}.routes"
+      else
+        "use #{middleware}"
+      end
+      output.puts string
+    end
+  end
+
+  PryRails::Commands.add_command(self)
+end

data/pry-rails-0.3.11/lib/pry-rails/commands/show_model.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+
+class PryRails::ShowModel < Pry::ClassCommand
+  match "show-model"
+  group "Rails"
+  description "Show the given model."
+
+  def options(opt)
+    opt.banner unindent <<-USAGE
+      Usage: show-model <model name>
+
+      show-model displays one model from the current Rails app.
+    USAGE
+  end
+
+  def process
+    Rails.application.eager_load!
+
+    if args.empty?
+      output.puts opts
+      return
+    end
+
+    begin
+      model = Object.const_get(args.first)
+    rescue NameError
+      output.puts "Couldn't find model #{args.first}!"
+      return
+    end
+
+    formatter = PryRails::ModelFormatter.new
+
+    case
+    when defined?(ActiveRecord::Base) && model < ActiveRecord::Base
+      output.puts formatter.format_active_record(model)
+    when defined?(Mongoid::Document) && model < Mongoid::Document
+      output.puts formatter.format_mongoid(model)
+    else
+      output.puts "Don't know how to show #{model}!"
+    end
+  end
+end
+
+PryRails::Commands.add_command PryRails::ShowModel

data/pry-rails-0.3.11/lib/pry-rails/commands/show_models.rb

@@ -0,0 +1,84 @@
+# encoding: UTF-8
+
+class PryRails::ShowModels < Pry::ClassCommand
+  match "show-models"
+  group "Rails"
+  description "Show all models."
+
+  def options(opt)
+    opt.banner unindent <<-USAGE
+      Usage: show-models
+
+      show-models displays the current Rails app's models.
+    USAGE
+
+    opt.on :G, "grep", "Filter output by regular expression", :argument => true
+  end
+
+  def process
+    Rails.application.eager_load!
+
+    @formatter = PryRails::ModelFormatter.new
+
+    display_activerecord_models
+    display_mongoid_models
+  end
+
+  def display_activerecord_models
+    return unless defined?(ActiveRecord::Base)
+
+    models = ActiveRecord::Base.descendants
+
+    models.sort_by(&:to_s).each do |model|
+      print_unless_filtered @formatter.format_active_record(model)
+    end
+  end
+
+  def display_mongoid_models
+    return unless defined?(Mongoid::Document)
+
+    models = []
+
+    ObjectSpace.each_object do |o|
+      # If this is deprecated, calling any methods on it will emit a warning,
+      # so just back away slowly.
+      next if ActiveSupport::Deprecation::DeprecationProxy === o
+
+      is_model = false
+
+      begin
+        is_model = o.class == Class && o.ancestors.include?(Mongoid::Document)
+      rescue
+        # If it's a weird object, it's not what we want anyway.
+      end
+
+      models << o if is_model
+    end
+
+    models.sort_by(&:to_s).each do |model|
+      print_unless_filtered @formatter.format_mongoid(model)
+    end
+  end
+
+  def print_unless_filtered(str)
+    if opts.present?(:G)
+      return unless str =~ grep_regex
+      str = colorize_matches(str) # :(
+    end
+    output.puts str
+  end
+
+  def colorize_matches(string)
+    if Pry.color
+      string.to_s.gsub(grep_regex) { |s| "\e[7m#{s}\e[27m" }
+    else
+      string
+    end
+  end
+
+  def grep_regex
+    @grep_regex ||= Regexp.new(opts[:G], Regexp::IGNORECASE)
+  end
+end
+
+PryRails::Commands.add_command PryRails::ShowModels

data/pry-rails-0.3.11/lib/pry-rails/commands/show_routes.rb

@@ -0,0 +1,92 @@
+class PryRails::ShowRoutes < Pry::ClassCommand
+  match 'show-routes'
+  group 'Rails'
+  description 'Show all routes in match order.'
+  banner <<-BANNER
+    Usage: show-routes [-G]
+    show-routes displays the current Rails app's routes.
+  BANNER
+
+  def options(opt)
+    opt.on :G, "grep", "Filter output by regular expression",
+           :argument => true,
+           :as => Array
+  end
+
+  def process
+    Rails.application.reload_routes!
+    all_routes = Rails.application.routes.routes
+
+    formatted =
+      if Rails::VERSION::MAJOR >= 6
+        process_rails_6_and_higher(all_routes)
+      elsif Rails::VERSION::MAJOR == 4 || Rails::VERSION::MAJOR == 5
+        process_rails_4_and_5(all_routes)
+      elsif Rails::VERSION::MAJOR >= 3 && Rails::VERSION::MINOR >= 2
+        process_rails_3_2(all_routes)
+      else
+        process_rails_3_0_and_3_1(all_routes)
+      end
+
+    output.puts grep_routes(formatted).join("\n")
+  end
+
+  # Takes an array of lines. Returns a list filtered by the conditions in
+  # `opts[:G]`.
+  def grep_routes(formatted)
+    return formatted unless opts[:G]
+    grep_opts = opts[:G]
+
+    grep_opts.reduce(formatted) do |lines, pattern|
+      lines.grep(Regexp.new(pattern))
+    end
+  end
+
+  # Cribbed from https://github.com/rails/rails/blob/3-1-stable/railties/lib/rails/tasks/routes.rake
+  def process_rails_3_0_and_3_1(all_routes)
+    routes = all_routes.collect do |route|
+      reqs = route.requirements.dup
+      reqs[:to] = route.app unless route.app.class.name.to_s =~ /^ActionDispatch::Routing/
+        reqs = reqs.empty? ? "" : reqs.inspect
+
+      {:name => route.name.to_s, :verb => route.verb.to_s, :path => route.path, :reqs => reqs}
+    end
+
+    # Skip the route if it's internal info route
+    routes.reject! { |r| r[:path] =~ %r{/rails/info/properties|^/assets} }
+
+    name_width = routes.map{ |r| r[:name].length }.max
+    verb_width = routes.map{ |r| r[:verb].length }.max
+    path_width = routes.map{ |r| r[:path].length }.max
+
+    routes.map do |r|
+      "#{r[:name].rjust(name_width)} #{r[:verb].ljust(verb_width)} #{r[:path].ljust(path_width)} #{r[:reqs]}"
+    end
+  end
+
+  def process_rails_3_2(all_routes)
+    require 'rails/application/route_inspector'
+
+    Rails::Application::RouteInspector.new.format(all_routes)
+  end
+
+  def process_rails_4_and_5(all_routes)
+    require 'action_dispatch/routing/inspector'
+
+    ActionDispatch::Routing::RoutesInspector.
+      new(all_routes).
+      format(ActionDispatch::Routing::ConsoleFormatter.new).
+      split(/\n/)
+  end
+
+  def process_rails_6_and_higher(all_routes)
+    require 'action_dispatch/routing/inspector'
+
+    ActionDispatch::Routing::RoutesInspector.
+      new(all_routes).
+      format(ActionDispatch::Routing::ConsoleFormatter::Sheet.new).
+      split(/\n/)
+  end
+
+  PryRails::Commands.add_command(self)
+end

data/pry-rails-0.3.11/lib/pry-rails/commands.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+PryRails::Commands = Pry::CommandSet.new
+
+command_glob = File.expand_path('../commands/*.rb', __FILE__)
+
+Dir[command_glob].each do |command|
+  require command
+end
+
+Pry.commands.import PryRails::Commands

data/pry-rails-0.3.11/lib/pry-rails/console.rb

@@ -0,0 +1,7 @@
+# encoding: UTF-8
+
+require 'pry-rails/version'
+
+if defined?(Rails)
+  require 'pry-rails/railtie'
+end