super-smart-mod 0.0.1

data/pry-0.16.0/lib/pry/commands/ls.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+class Pry
+  class Command
+    class Ls < Pry::ClassCommand
+      match 'ls'
+      group 'Context'
+      description 'Show the list of vars and methods in the current scope.'
+      command_options shellwords: false, interpolate: false
+
+      banner <<-'BANNER'
+        Usage: ls [-m|-M|-p|-pM] [-q|-v] [-c|-i] [Object]
+               ls [-g] [-l]
+
+        ls shows you which methods, constants and variables are accessible to Pry. By
+        default it shows you the local variables defined in the current shell, and any
+        public methods or instance variables defined on the current object.
+
+        The colours used are configurable using Pry.config.ls.*_color, and the separator
+        is Pry.config.ls.separator.
+
+        Pry.config.ls.ceiling is used to hide methods defined higher up in the
+        inheritance chain, this is by default set to [Object, Module, Class] so that
+        methods defined on all Objects are omitted. The -v flag can be used to ignore
+        this setting and show all methods, while the -q can be used to set the ceiling
+        much lower and show only methods defined on the object or its direct class.
+
+        Also check out `find-method` command (run `help find-method`).
+      BANNER
+
+      def options(opt)
+        opt.on :m, :methods, "Show public methods defined on the Object"
+        opt.on :M, "instance-methods", "Show public methods defined in a " \
+                                       "Module or Class"
+        opt.on :p, :ppp, "Show public, protected (in yellow) and private " \
+                         "(in green) methods"
+        opt.on :q, :quiet, "Show only methods defined on object.singleton_class " \
+                           "and object.class"
+        opt.on :v, :verbose, "Show methods and constants on all super-classes " \
+                             "(ignores Pry.config.ls.ceiling)"
+        opt.on :g, :globals, "Show global variables, including those builtin to " \
+                             "Ruby (in cyan)"
+        opt.on :l, :locals, "Show hash of local vars, sorted by descending size"
+        opt.on :c, :constants, "Show constants, highlighting classes (in blue), " \
+                               "and exceptions (in purple).\n" \
+                               "#{' ' * 32}Constants that are pending autoload? " \
+                               "are also shown (in yellow)"
+        opt.on :i, :ivars, "Show instance variables (in blue) and class " \
+                           "variables (in bright blue)"
+        opt.on :G, :grep, "Filter output by regular expression", argument: true
+
+        if Object.respond_to?(:deprecate_constant)
+          opt.on :d, :dconstants, "Show deprecated constants"
+        end
+
+        return unless Helpers::Platform.jruby?
+
+        opt.on :J, "all-java", "Show all the aliases for methods from java " \
+                               "(default is to show only prettiest)"
+      end
+
+      # Exclude -q, -v and --grep because they,
+      # don't specify what the user wants to see.
+      def no_user_opts?
+        !(opts[:methods] || opts['instance-methods'] || opts[:ppp] ||
+          opts[:globals] || opts[:locals] || opts[:constants] || opts[:ivars])
+      end
+
+      def process
+        @interrogatee = args.empty? ? target_self : target.eval(args.join(' '))
+        raise_errors_if_arguments_are_weird
+        ls_entity = LsEntity.new(
+          interrogatee: @interrogatee,
+          no_user_opts: no_user_opts?,
+          opts: opts,
+          args: args,
+          pry_instance: pry_instance
+        )
+
+        pry_instance.pager.page ls_entity.entities_table
+      end
+
+      private
+
+      def error_list
+        any_args = args.any?
+        # rubocop:disable Style/CaseEquality
+        non_mod_interrogatee = !(Module === @interrogatee)
+        # rubocop:enable Style/CaseEquality
+        [
+          ['-l does not make sense with a specified Object', :locals, any_args],
+          ['-g does not make sense with a specified Object', :globals, any_args],
+          ['-q does not make sense with -v', :quiet, opts.present?(:verbose)],
+          [
+            '-M only makes sense with a Module or a Class', 'instance-methods',
+            non_mod_interrogatee
+          ],
+          [
+            '-c only makes sense with a Module or a Class', :constants,
+            any_args && non_mod_interrogatee
+          ]
+        ]
+      end
+
+      def raise_errors_if_arguments_are_weird
+        error_list.each do |message, option, invalid_expr|
+          raise Pry::CommandError, message if opts.present?(option) && invalid_expr
+        end
+      end
+    end
+
+    Pry::Commands.add_command(Pry::Command::Ls)
+  end
+end

data/pry-0.16.0/lib/pry/commands/nesting.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Pry
+  class Command
+    class Nesting < Pry::ClassCommand
+      match 'nesting'
+      group 'Navigating Pry'
+      description 'Show nesting information.'
+
+      banner <<-'BANNER'
+        Show nesting information.
+      BANNER
+
+      def process
+        output.puts 'Nesting status:'
+        output.puts '--'
+        pry_instance.binding_stack.each_with_index do |obj, level|
+          if level == 0
+            output.puts "#{level}. #{Pry.view_clip(obj.eval('self'))} (Pry top level)"
+          else
+            output.puts "#{level}. #{Pry.view_clip(obj.eval('self'))}"
+          end
+        end
+      end
+    end
+
+    Pry::Commands.add_command(Pry::Command::Nesting)
+  end
+end

data/pry-0.16.0/lib/pry/commands/play.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+class Pry
+  class Command
+    class Play < Pry::ClassCommand
+      match 'play'
+      group 'Editing'
+      description 'Playback a string variable, method, line, or file as input.'
+
+      banner <<-'BANNER'
+        Usage: play [OPTIONS] [--help]
+
+        The play command enables you to replay code from files and methods as if they
+        were entered directly in the Pry REPL.
+
+        play --lines 149..153   # assumes current context
+        play -i 20 --lines 1..3 # assumes lines of the input expression at 20
+        play -o 4               # the output of an expression at 4
+        play Pry#repl -l 1..-1  # play the contents of Pry#repl method
+        play -e 2               # play from specified line until end of valid expression
+        play hello.rb           # play a file
+        play Rakefile -l 5      # play line 5 of a file
+        play -d hi              # play documentation of hi method
+        play hi --open          # play hi method and leave it open
+
+        https://github.com/pry/pry/wiki/User-Input#wiki-Play
+      BANNER
+
+      def options(opt)
+        CodeCollector.inject_options(opt)
+
+        opt.on :open, 'Plays the selected content except the last line. Useful' \
+                      ' for replaying methods and leaving the method definition' \
+                      ' "open". `amend-line` can then be used to' \
+                      ' modify the method.'
+
+        opt.on :e, :expression=, 'Executes until end of valid expression', as: Integer
+        opt.on :p, :print, 'Prints executed code'
+      end
+
+      def process
+        @cc = CodeCollector.new(args, opts, pry_instance)
+
+        perform_play
+        show_input
+      end
+
+      def perform_play
+        eval_string << content_after_options
+        run "fix-indent"
+      end
+
+      def show_input
+        return unless opts.present?(:print)
+        return unless Pry::Code.complete_expression?(eval_string)
+
+        run 'show-input'
+      end
+
+      def content_after_options
+        if opts.present?(:open)
+          restrict_to_lines(content, (0..-2))
+        elsif opts.present?(:expression)
+          content_at_expression
+        else
+          content
+        end
+      end
+
+      def content_at_expression
+        code_object.expression_at(opts[:expression])
+      end
+
+      def code_object
+        Pry::Code.new(content)
+      end
+
+      def should_use_default_file?
+        !args.first && !opts.present?(:in) && !opts.present?(:out)
+      end
+
+      def content
+        if should_use_default_file?
+          file_content
+        else
+          @cc.content
+        end
+      end
+
+      # The file to play from when no code object is specified.
+      # e.g `play --lines 4..10`
+      def default_file
+        file =
+          if target.respond_to?(:source_location)
+            target.source_location.first
+          else
+            target.eval("__FILE__")
+          end
+        file && File.expand_path(file)
+      end
+
+      def file_content
+        if !default_file || !File.exist?(default_file)
+          raise CommandError, "File does not exist! File was: #{default_file.inspect}"
+        end
+
+        @cc.restrict_to_lines(File.read(default_file), @cc.line_range)
+      end
+    end
+
+    Pry::Commands.add_command(Pry::Command::Play)
+  end
+end

data/pry-0.16.0/lib/pry/commands/pry_backtrace.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Pry
+  class Command
+    class PryBacktrace < Pry::ClassCommand
+      match 'pry-backtrace'
+      group 'Context'
+      description 'Show the backtrace for the Pry session.'
+
+      banner <<-BANNER
+        Usage: pry-backtrace [OPTIONS] [--help]
+
+        Show the backtrace for the position in the code where Pry was started. This can
+        be used to infer the behavior of the program immediately before it entered Pry,
+        just like the backtrace property of an exception.
+
+        NOTE: if you are looking for the backtrace of the most recent exception raised,
+        just type: `_ex_.backtrace` instead.
+        See: https://github.com/pry/pry/wiki/Special-Locals
+      BANNER
+
+      def process
+        text = "#{bold('Backtrace:')}\n--\n#{pry_instance.backtrace.join("\n")}"
+        pry_instance.pager.page(text)
+      end
+    end
+
+    Pry::Commands.add_command(Pry::Command::PryBacktrace)
+  end
+end

data/pry-0.16.0/lib/pry/commands/pry_version.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Pry
+  class Command
+    class Version < Pry::ClassCommand
+      match 'pry-version'
+      group 'Misc'
+      description 'Show Pry version.'
+
+      banner <<-'BANNER'
+        Show Pry version.
+      BANNER
+
+      def process
+        output.puts "Pry version: #{Pry::VERSION} on Ruby #{RUBY_VERSION}."
+      end
+    end
+
+    Pry::Commands.add_command(Pry::Command::Version)
+  end
+end

data/pry-0.16.0/lib/pry/commands/raise_up.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class Pry
+  # N.B. using a regular expression here so that "raise-up 'foo'" does the right thing.
+  class Command
+    class RaiseUp < Pry::ClassCommand
+      match(/raise-up(!?\b.*)/)
+      group 'Context'
+      description 'Raise an exception out of the current pry instance.'
+      command_options listing: 'raise-up'
+
+      banner <<-BANNER
+        Raise up, like exit, allows you to quit pry. Instead of returning a value
+        however, it raises an exception. If you don't provide the exception to be
+        raised, it will use the most recent exception (in pry `_ex_`).
+
+        When called as raise-up! (with an exclamation mark), this command raises the
+        exception through any nested prys you have created by "cd"ing into objects.
+
+        raise-up "get-me-out-of-here"
+
+        # This is equivalent to the command above.
+        raise "get-me-out-of-here"
+        raise-up
+      BANNER
+
+      def process
+        return _pry.pager.page help if captures[0] =~ /(-h|--help)\b/
+
+        # Handle 'raise-up', 'raise-up "foo"', 'raise-up RuntimeError, 'farble'
+        # in a rubyesque manner
+        target.eval("pry_instance.raise_up#{captures[0]}")
+      end
+    end
+
+    Pry::Commands.add_command(Pry::Command::RaiseUp)
+  end
+end

data/pry-0.16.0/lib/pry/commands/reload_code.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+class Pry
+  class Command
+    class ReloadCode < Pry::ClassCommand
+      match 'reload-code'
+      group 'Misc'
+      description 'Reload the source file that contains the specified code object.'
+
+      banner <<-'BANNER'
+        Reload the source file that contains the specified code object.
+
+        e.g reload-code MyClass#my_method    #=> reload a method
+            reload-code MyClass              #=> reload a class
+            reload-code my-command           #=> reload a pry command
+            reload-code self                 #=> reload the current object
+            reload-code                      #=> reload the current file or object
+      BANNER
+
+      def process
+        if !args.empty?
+          reload_object(args.join(" "))
+        elsif internal_binding?(target)
+          reload_object("self")
+        else
+          reload_current_file
+        end
+      end
+
+      private
+
+      def current_file
+        file =
+          if target.respond_to?(:source_location)
+            target.source_location.first
+          else
+            target.eval("__FILE__")
+          end
+        File.expand_path file
+      end
+
+      def reload_current_file
+        unless File.exist?(current_file)
+          raise CommandError, "Current file: #{current_file} cannot be found on disk!"
+        end
+
+        load current_file
+        output.puts "The current file: #{current_file} was reloaded!"
+      end
+
+      def reload_object(identifier)
+        code_object = Pry::CodeObject.lookup(identifier, pry_instance)
+        check_for_reloadability(code_object, identifier)
+        load code_object.source_file
+        output.puts "#{identifier} was reloaded!"
+      end
+
+      def check_for_reloadability(code_object, identifier)
+        if !code_object || !code_object.source_file
+          raise CommandError, "Cannot locate #{identifier}!"
+        end
+
+        return if File.exist?(code_object.source_file)
+
+        raise CommandError,
+              "Cannot reload #{identifier} as it has no associated file on disk. " \
+              "File found was: #{code_object.source_file}"
+      end
+    end
+
+    Pry::Commands.add_command(Pry::Command::ReloadCode)
+    Pry::Commands.alias_command 'reload-method', 'reload-code'
+  end
+end

data/pry-0.16.0/lib/pry/commands/reset.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Pry
+  class Command
+    class Reset < Pry::ClassCommand
+      match 'reset'
+      group 'Context'
+      description 'Reset the REPL to a clean state.'
+
+      banner <<-'BANNER'
+        Reset the REPL to a clean state.
+      BANNER
+
+      def process
+        output.puts 'Pry reset.'
+        exec 'pry'
+      end
+    end
+
+    Pry::Commands.add_command(Pry::Command::Reset)
+  end
+end

data/pry-0.16.0/lib/pry/commands/ri.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'stringio'
+
+class Pry
+  class Command
+    class Ri < Pry::ClassCommand
+      match 'ri'
+      group 'Introspection'
+      description 'View ri documentation.'
+
+      banner <<-'BANNER'
+        Usage: ri [spec]
+
+        View ri documentation. Relies on the "rdoc" gem being installed.
+        See also "show-doc" command.
+
+        ri Array#each
+      BANNER
+
+      def process(spec)
+        unless spec
+          return output.puts(
+            "Please provide a class, module, or method name (e.g: ri Array#push)"
+          )
+        end
+
+        # Lazily load RI
+        require 'rdoc/ri/driver'
+
+        unless defined? RDoc::RI::PryDriver
+
+          # Subclass RI so that it formats its output nicely, and uses `lesspipe`.
+          subclass = Class.new(RDoc::RI::Driver) # the hard way.
+
+          subclass.class_eval do
+            def initialize(pager, opts)
+              @pager = pager
+              super opts
+            end
+
+            def page
+              paging_text = StringIO.new
+              yield paging_text
+              @pager.page(paging_text.string)
+            end
+
+            def formatter(_io)
+              if @formatter_klass
+                @formatter_klass.new
+              else
+                RDoc::Markup::ToAnsi.new
+              end
+            end
+          end
+
+          RDoc::RI.const_set :PryDriver, subclass # hook it up!
+        end
+
+        # Spin-up an RI instance.
+        ri = RDoc::RI::PryDriver.new(
+          pry_instance.pager, use_stdout: true, interactive: false
+        )
+
+        begin
+          ri.display_names [spec] # Get the documentation (finally!)
+        rescue RDoc::RI::Driver::NotFoundError => e
+          output.puts "error: '#{e.name}' not found"
+        end
+      end
+    end
+
+    Pry::Commands.add_command(Pry::Command::Ri)
+  end
+end

data/pry-0.16.0/lib/pry/commands/save_file.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class Pry
+  class Command
+    class SaveFile < Pry::ClassCommand
+      match 'save-file'
+      group 'Input and Output'
+      description 'Export to a file using content from the REPL.'
+
+      banner <<-'BANNER'
+        Usage: save-file [OPTIONS] --to [FILE]
+
+        Export to a file using content from the REPL.
+
+        save-file my_method --to hello.rb
+        save-file -i 1..10 --to hello.rb --append
+        save-file show-method --to my_command.rb
+        save-file sample_file.rb --lines 2..10 --to output_file.rb
+      BANNER
+
+      def options(opt)
+        CodeCollector.inject_options(opt)
+
+        opt.on :to=,        "Specify the output file path"
+        opt.on :a, :append, "Append output to file"
+      end
+
+      def process
+        @cc = CodeCollector.new(args, opts, pry_instance)
+        raise CommandError, "Found no code to save." if @cc.content.empty?
+
+        if !file_name
+          display_content
+        else
+          save_file
+        end
+      end
+
+      def file_name
+        opts[:to] || nil
+      end
+
+      def save_file
+        File.open(file_name, mode) do |f|
+          f.puts @cc.content
+        end
+        output.puts "#{file_name} successfully saved"
+      end
+
+      def display_content
+        output.puts @cc.content
+        output.puts "\n\n--\nPlease use `--to FILE` to export to a file."
+        output.puts "No file saved!\n--"
+      end
+
+      def mode
+        opts.present?(:append) ? "a" : "w"
+      end
+    end
+
+    Pry::Commands.add_command(Pry::Command::SaveFile)
+  end
+end

data/pry-0.16.0/lib/pry/commands/shell_command.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+class Pry
+  class Command
+    class ShellCommand < Pry::ClassCommand
+      match(/\.(.*)/)
+      group 'Input and Output'
+      description "All text following a '.' is forwarded to the shell."
+      command_options listing: '.<shell command>', use_prefix: false,
+                      takes_block: true, state: %i[old_pwd]
+
+      banner <<-'BANNER'
+        Usage: .COMMAND_NAME
+
+        All text following a "." is forwarded to the shell.
+
+        .ls -aF
+        .uname
+      BANNER
+
+      def process(cmd)
+        if cmd =~ /^cd\s*(.*)/i
+          process_cd parse_destination(Regexp.last_match(1))
+        else
+          pass_block(cmd)
+          if command_block
+            command_block.call `#{cmd}`
+          else
+            pry_instance.config.system.call(output, cmd, pry_instance)
+          end
+        end
+      end
+
+      private
+
+      def parse_destination(dest)
+        return "~" if dest.empty?
+        return dest unless dest == "-"
+
+        state.old_pwd || raise(CommandError, "No prior directory available")
+      end
+
+      def process_cd(dest)
+        state.old_pwd = Dir.pwd
+        Dir.chdir(File.expand_path(path_from_cd_path(dest) || dest))
+      rescue Errno::ENOENT
+        raise CommandError, "No such directory: #{dest}"
+      end
+
+      def cd_path_env
+        Pry::Env['CDPATH']
+      end
+
+      def cd_path_exists?
+        cd_path_env && cd_path_env.length.nonzero?
+      end
+
+      def path_from_cd_path(dest)
+        return if !(dest && cd_path_exists?) || special_case_path?(dest)
+
+        cd_path_env.split(File::PATH_SEPARATOR).each do |path|
+          return path if File.directory?(path) && path.split(File::SEPARATOR).last == dest
+        end
+
+        nil
+      end
+
+      def special_case_path?(dest)
+        ['.', '..', '-'].include?(dest) || dest =~ /\A[#{File::PATH_SEPARATOR}~]/
+      end
+    end
+
+    Pry::Commands.add_command(Pry::Command::ShellCommand)
+  end
+end

data/pry-0.16.0/lib/pry/commands/shell_mode.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Pry
+  class Command
+    class ShellMode < Pry::ClassCommand
+      match 'shell-mode'
+      group 'Input and Output'
+      description 'Toggle shell mode. Bring in pwd prompt and file completion.'
+      command_options state: %i[disabled prev_prompt]
+
+      banner <<-'BANNER'
+        Toggle shell mode. Bring in pwd prompt and file completion.
+      BANNER
+
+      def process
+        state.disabled ^= true
+
+        if state.disabled
+          state.prev_prompt = pry_instance.prompt
+          pry_instance.prompt = Pry::Prompt[:shell]
+        else
+          pry_instance.prompt = state.prev_prompt
+        end
+      end
+    end
+
+    Pry::Commands.add_command(Pry::Command::ShellMode)
+    Pry::Commands.alias_command 'file-mode', 'shell-mode'
+  end
+end