pry 0.10.pre.1-i386-mingw32 → 0.10.0.pre3-i386-mingw32

data/lib/pry/commands/import_set.rb

@@ -0,0 +1,22 @@
+class Pry
+  class Command::ImportSet < Pry::ClassCommand
+    match 'import-set'
+    group 'Commands'
+    # TODO: Provide a better description with examples and a general conception
+    # of this command.
+    description 'Import a Pry command set.'
+
+    banner <<-'BANNER'
+      Import a Pry command set.
+    BANNER
+
+    def process(command_set_name)
+      raise CommandError, "Provide a command set name" if command_set.nil?
+
+      set = target.eval(arg_string)
+      _pry_.commands.import set
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::ImportSet)
+end

data/lib/pry/commands/install_command.rb

@@ -0,0 +1,53 @@
+class Pry
+  class Command::InstallCommand < Pry::ClassCommand
+    match 'install-command'
+    group 'Commands'
+    description 'Install a disabled command.'
+
+    banner <<-'BANNER'
+      Usage: install-command COMMAND
+
+      Installs the gems necessary to run the given COMMAND. You will generally not
+      need to run this unless told to by an error message.
+    BANNER
+
+    def process(name)
+      require 'rubygems/dependency_installer' unless defined? Gem::DependencyInstaller
+      command = find_command(name)
+
+      unless command
+        output.puts "Command #{ text.green(name) } is not found"
+        return
+      end
+
+      if command_dependencies_met?(command.options)
+        output.puts "Dependencies for #{ text.green(name) } are met. Nothing to do"
+        return
+      end
+
+      output.puts "Attempting to install #{ text.green(name) } command..."
+      gems_to_install = Array(command.options[:requires_gem])
+
+      gems_to_install.each do |g|
+        next if Rubygem.installed?(g)
+        output.puts "Installing #{ text.green(g) } gem..."
+        Rubygem.install(g)
+      end
+
+      gems_to_install.each do |g|
+        begin
+          require g
+        rescue LoadError
+          fail_msg = "Required gem #{ text.green(g) } installed but not found."
+          fail_msg += " Aborting command installation\n"
+          fail_msg += 'Tips: 1. Check your PATH; 2. Run `bundle update`'
+          raise CommandError, fail_msg
+        end
+      end
+
+      output.puts "Installation of #{ text.green(name) } successful! Type `help #{name}` for information"
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::InstallCommand)
+end

data/lib/pry/commands/jump_to.rb

@@ -0,0 +1,29 @@
+class Pry
+  class Command::JumpTo < Pry::ClassCommand
+    match 'jump-to'
+    group 'Navigating Pry'
+    description 'Jump to a binding further up the stack.'
+
+    banner <<-'BANNER'
+      Jump to a binding further up the stack, popping all bindings below.
+    BANNER
+
+    def process(break_level)
+      break_level = break_level.to_i
+      nesting_level = _pry_.binding_stack.size - 1
+
+      case break_level
+      when nesting_level
+        output.puts "Already at nesting level #{nesting_level}"
+      when (0...nesting_level)
+        _pry_.binding_stack.slice!(break_level + 1, _pry_.binding_stack.size)
+
+      else
+        max_nest_level = nesting_level - 1
+        output.puts "Invalid nest level. Must be between 0 and #{max_nest_level}. Got #{break_level}."
+      end
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::JumpTo)
+end

data/lib/pry/commands/list_inspectors.rb

@@ -0,0 +1,35 @@
+class Pry::Command::ListInspectors < Pry::ClassCommand
+  match 'list-inspectors'
+  group 'Input and Output'
+  description 'List the inspector procs available for use.'
+  banner <<-BANNER
+    Usage: list-inspectors
+
+    List the inspector procs available to print return values. You can use
+    change-inspector to switch between them.
+  BANNER
+
+  def process
+    output.puts heading("Available inspectors") + "\n"
+    inspector_map.each do |name, inspector|
+      output.write "Name: #{text.bold(name)}"
+      output.puts selected_inspector?(inspector) ? selected_text : ""
+      output.puts inspector[:description]
+      output.puts
+    end
+  end
+
+private
+  def inspector_map
+    Pry::Inspector::MAP
+  end
+
+  def selected_text
+    text.red " (selected) "
+  end
+
+  def selected_inspector?(inspector)
+    _pry_.print == inspector[:value]
+  end
+  Pry::Commands.add_command(self)
+end

data/lib/pry/commands/list_prompts.rb

@@ -0,0 +1,35 @@
+class Pry::Command::ListPrompts < Pry::ClassCommand
+  match 'list-prompts'
+  group 'Input and Output'
+  description 'List the prompts available for use.'
+  banner <<-BANNER
+    Usage: list-prompts
+
+    List the available prompts. You can use change-prompt to switch between
+    them.
+  BANNER
+
+  def process
+    output.puts heading("Available prompts") + "\n"
+    prompt_map.each do |name, prompt|
+      output.write "Name: #{text.bold(name)}"
+      output.puts selected_prompt?(prompt) ? selected_text : ""
+      output.puts prompt[:description]
+      output.puts
+    end
+  end
+
+private
+  def prompt_map
+    Pry::Prompt::MAP
+  end
+
+  def selected_text
+    text.red " (selected) "
+  end
+
+  def selected_prompt?(prompt)
+    _pry_.prompt == prompt[:value]
+  end
+  Pry::Commands.add_command(self)
+end

data/lib/pry/commands/ls.rb

@@ -0,0 +1,114 @@
+require 'pry/commands/ls/ls_entity'
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    DEFAULT_OPTIONS = {
+      :heading_color            => :bright_blue,
+      :public_method_color      => :default,
+      :private_method_color     => :blue,
+      :protected_method_color   => :blue,
+      :method_missing_color     => :bright_red,
+      :local_var_color          => :yellow,
+      :pry_var_color            => :default,     # e.g. _, _pry_, _file_
+      :instance_var_color       => :blue,        # e.g. @foo
+      :class_var_color          => :bright_blue, # e.g. @@foo
+      :global_var_color         => :default,     # e.g. $CODERAY_DEBUG, $eventmachine_library
+      :builtin_global_color     => :cyan,        # e.g. $stdin, $-w, $PID
+      :pseudo_global_color      => :cyan,        # e.g. $~, $1..$9, $LAST_MATCH_INFO
+      :constant_color           => :default,     # e.g. VERSION, ARGF
+      :class_constant_color     => :blue,        # e.g. Object, Kernel
+      :exception_constant_color => :magenta,     # e.g. Exception, RuntimeError
+      :unloaded_constant_color  => :yellow,      # Any constant that is still in .autoload? state
+      :separator                => "  ",
+      :ceiling                  => [Object, Module, Class]
+    }
+
+
+    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 jruby?
+        opt.on :J, "all-java", "Show all the aliases for methods from java (default is to show only prettiest)"
+      end
+    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_ => _pry_
+      })
+
+      _pry_.pager.page ls_entity.entities_table
+    end
+
+    private
+
+    def error_list
+      any_args = args.any?
+      non_mod_interrogatee = !(Module === @interrogatee)
+      [
+        ['-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

data/lib/pry/commands/ls/constants.rb

@@ -0,0 +1,47 @@
+require 'pry/commands/ls/interrogatable'
+
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    class Constants < Pry::Command::Ls::Formatter
+      include Pry::Command::Ls::Interrogatable
+
+
+      def initialize(interrogatee, no_user_opts, opts, _pry_)
+        super(_pry_)
+        @interrogatee = interrogatee
+        @no_user_opts = no_user_opts
+        @default_switch = opts[:constants]
+        @verbose_switch = opts[:verbose]
+      end
+
+      def correct_opts?
+        super || (@no_user_opts && interrogating_a_module?)
+      end
+
+      def output_self
+        mod = interrogatee_mod
+        constants = WrappedModule.new(mod).constants(@verbose_switch)
+        output_section('constants', grep.regexp[format(mod, constants)])
+      end
+
+      private
+
+      def format(mod, constants)
+        constants.sort_by(&:downcase).map do |name|
+          if const = (!mod.autoload?(name) && (mod.const_get(name) || true) rescue nil)
+            if (const < Exception rescue false)
+              color(:exception_constant, name)
+            elsif (Module === mod.const_get(name) rescue false)
+              color(:class_constant, name)
+            else
+              color(:constant, name)
+            end
+          else
+            color(:unloaded_constant, name)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/pry/commands/ls/formatter.rb

@@ -0,0 +1,49 @@
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    class Formatter
+      attr_accessor :grep
+      attr_reader :_pry_
+
+      def initialize(_pry_)
+        @_pry_ = _pry_
+        @target = _pry_.current_context
+      end
+
+      def write_out
+        return false unless correct_opts?
+        output_self
+      end
+
+      private
+
+      def color(type, str)
+        Pry::Helpers::Text.send _pry_.config.ls["#{type}_color"], str
+      end
+
+      # Add a new section to the output.
+      # Outputs nothing if the section would be empty.
+      def output_section(heading, body)
+        return '' if body.compact.empty?
+        fancy_heading = Pry::Helpers::Text.bold(color(:heading, heading))
+        Pry::Helpers.tablify_or_one_line(fancy_heading, body)
+      end
+
+      def format_value(value)
+        Pry::ColorPrinter.pp(value, '')
+      end
+
+      def correct_opts?
+        @default_switch
+      end
+
+      def output_self
+        raise NotImplementedError
+      end
+
+      def grep
+        @grep || proc { |x| x }
+      end
+
+    end
+  end
+end

data/lib/pry/commands/ls/globals.rb

@@ -0,0 +1,48 @@
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    class Globals < Pry::Command::Ls::Formatter
+
+      # Taken from "puts global_variables.inspect".
+      BUILTIN_GLOBALS =
+        %w($" $$ $* $, $-0 $-F $-I $-K $-W $-a $-d $-i $-l $-p $-v $-w $. $/ $\\
+           $: $; $< $= $> $0 $ARGV $CONSOLE $DEBUG $DEFAULT_INPUT $DEFAULT_OUTPUT
+           $FIELD_SEPARATOR $FILENAME $FS $IGNORECASE $INPUT_LINE_NUMBER
+           $INPUT_RECORD_SEPARATOR $KCODE $LOADED_FEATURES $LOAD_PATH $NR $OFS
+           $ORS $OUTPUT_FIELD_SEPARATOR $OUTPUT_RECORD_SEPARATOR $PID $PROCESS_ID
+           $PROGRAM_NAME $RS $VERBOSE $deferr $defout $stderr $stdin $stdout)
+
+      # `$SAFE` and `$?` are thread-local, the exception stuff only works in a
+      # rescue clause, everything else is basically a local variable with a `$`
+      # in its name.
+      PSEUDO_GLOBALS =
+        %w($! $' $& $` $@ $? $+ $_ $~ $1 $2 $3 $4 $5 $6 $7 $8 $9
+           $CHILD_STATUS $SAFE $ERROR_INFO $ERROR_POSITION $LAST_MATCH_INFO
+           $LAST_PAREN_MATCH $LAST_READ_LINE $MATCH $POSTMATCH $PREMATCH)
+
+      def initialize(opts, _pry_)
+        super(_pry_)
+        @default_switch = opts[:globals]
+      end
+
+      def output_self
+        variables = format(@target.eval('global_variables'))
+        output_section('global variables', grep.regexp[variables])
+      end
+
+      private
+
+      def format(globals)
+        globals.map(&:to_s).sort_by(&:downcase).map do |name|
+          if PSEUDO_GLOBALS.include?(name)
+            color(:pseudo_global, name)
+          elsif BUILTIN_GLOBALS.include?(name)
+            color(:builtin_global, name)
+          else
+            color(:global_var, name)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/pry/commands/ls/grep.rb

@@ -0,0 +1,21 @@
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    class Grep
+
+      def initialize(grep_regexp)
+        @grep_regexp = grep_regexp
+      end
+
+      def regexp
+        proc { |x|
+          if x.instance_of?(Array)
+            x.grep(@grep_regexp)
+          else
+            x =~ @grep_regexp
+          end
+        }
+      end
+
+    end
+  end
+end