pry 0.10.2-i386-mswin32 → 1.0.0.pre1-i386-mswin32

data/lib/pry/completion.rb

@@ -0,0 +1,293 @@
+# taken from irb
+
+class Pry
+
+  module BondCompleter
+    def self.call(input, options)
+      Pry.current[:pry] = options[:pry]
+      Bond.agent.call(input)
+    end
+
+    def self.start
+      Bond.start(:eval_binding => lambda{ Pry.current[:pry] && Pry.current[:pry].current_context })
+      Bond.complete(:on => /\A/) do |input|
+        Pry.commands.complete(input.line,
+                             :pry_instance => Pry.current[:pry],
+                             :target       => Pry.current[:pry].current_context,
+                             :command_set  => Pry.current[:pry].commands)
+      end
+      self
+    end
+  end
+
+  # Implements tab completion for Readline in Pry
+  module InputCompleter
+
+    def self.start
+      if Readline.respond_to?("basic_word_break_characters=")
+        Readline.basic_word_break_characters = " \t\n\"\\'`><=;|&{("
+      end
+
+      Readline.completion_append_character = nil
+      self
+    end
+
+    ReservedWords = [
+      "BEGIN", "END",
+      "alias", "and",
+      "begin", "break",
+      "case", "class",
+      "def", "defined", "do",
+      "else", "elsif", "end", "ensure",
+      "false", "for",
+      "if", "in",
+      "module",
+      "next", "nil", "not",
+      "or",
+      "redo", "rescue", "retry", "return",
+      "self", "super",
+      "then", "true",
+      "undef", "unless", "until",
+      "when", "while",
+      "yield" ]
+
+    Operators = [
+      "%", "&", "*", "**", "+",  "-",  "/",
+      "<", "<<", "<=", "<=>", "==", "===", "=~", ">", ">=", ">>",
+      "[]", "[]=", "^", "!", "!=", "!~"
+    ]
+
+    # Return a new completion proc for use by Readline.
+    # @param [Binding] target The current binding context.
+    # @param [Array<String>] commands The array of Pry commands.
+    def self.call(input, options)
+
+      custom_completions = options[:custom_completions] || []
+
+      # if there are multiple contexts e.g. cd 1/2/3
+      # get new target for 1/2 and find candidates for 3
+      path, input = build_path(input)
+
+      if path.call.empty?
+        target = options[:target]
+      else
+        target, _ = Pry::Helpers::BaseHelpers.context_from_object_path(path.call, options[:pry])
+        target = target.last
+      end
+
+      begin
+        bind = target
+
+        case input
+
+
+        # Complete stdlib symbols
+
+        when /^(\/[^\/]*\/)\.([^.]*)$/
+          # Regexp
+          receiver = $1
+          message = Regexp.quote($2)
+
+          candidates = Regexp.instance_methods.collect(&:to_s)
+          select_message(path, receiver, message, candidates)
+
+        when /^([^\]]*\])\.([^.]*)$/
+          # Array
+          receiver = $1
+          message = Regexp.quote($2)
+
+          candidates = Array.instance_methods.collect(&:to_s)
+          select_message(path, receiver, message, candidates)
+
+        when /^([^\}]*\})\.([^.]*)$/
+          # Proc or Hash
+          receiver = $1
+          message = Regexp.quote($2)
+
+          candidates = Proc.instance_methods.collect(&:to_s)
+          candidates |= Hash.instance_methods.collect(&:to_s)
+          select_message(path, receiver, message, candidates)
+
+        when /^(:[^:.]*)$/
+          # Symbol
+          if Symbol.respond_to?(:all_symbols)
+            sym        = Regexp.quote($1)
+            candidates = Symbol.all_symbols.collect{|s| ":" + s.id2name}
+
+            candidates.grep(/^#{sym}/)
+          else
+            []
+          end
+
+        when /^::([A-Z][^:\.\(]*)$/
+          # Absolute Constant or class methods
+          receiver = $1
+          candidates = Object.constants.collect(&:to_s)
+          candidates.grep(/^#{receiver}/).collect{|e| "::" + e}
+
+
+        # Complete target symbols
+
+        when /^([A-Z][A-Za-z0-9]*)$/
+          # Constant
+          message = $1
+
+          begin
+            context = target.eval("self")
+            context = context.class unless context.respond_to? :constants
+            candidates = context.constants.collect(&:to_s)
+          rescue
+            candidates = []
+          end
+          candidates = candidates.grep(/^#{message}/).collect(&path)
+
+        when /^([A-Z].*)::([^:.]*)$/
+          # Constant or class methods
+          receiver = $1
+          message = Regexp.quote($2)
+          begin
+            candidates = eval("#{receiver}.constants.collect(&:to_s)", bind)
+            candidates |= eval("#{receiver}.methods.collect(&:to_s)", bind)
+          rescue RescuableException
+            candidates = []
+          end
+          candidates.grep(/^#{message}/).collect{|e| receiver + "::" + e}
+
+        when /^(:[^:.]+)\.([^.]*)$/
+          # Symbol
+          receiver = $1
+          message = Regexp.quote($2)
+
+          candidates = Symbol.instance_methods.collect(&:to_s)
+          select_message(path, receiver, message, candidates)
+
+        when /^(-?(0[dbo])?[0-9_]+(\.[0-9_]+)?([eE]-?[0-9]+)?)\.([^.]*)$/
+          # Numeric
+          receiver = $1
+          message = Regexp.quote($5)
+
+          begin
+            candidates = eval(receiver, bind).methods.collect(&:to_s)
+          rescue RescuableException
+            candidates = []
+          end
+          select_message(path, receiver, message, candidates)
+
+        when /^(-?0x[0-9a-fA-F_]+)\.([^.]*)$/#
+          # Numeric(0xFFFF)
+          receiver = $1
+          message = Regexp.quote($2)
+
+          begin
+            candidates = eval(receiver, bind).methods.collect(&:to_s)
+          rescue RescuableException
+            candidates = []
+          end
+          select_message(path, receiver, message, candidates)
+
+        when /^(\$[^.]*)$/
+          # Global variables
+          regmessage = Regexp.new(Regexp.quote($1))
+          candidates = global_variables.collect(&:to_s).grep(regmessage)
+
+        when /^([^."].*)\.([^.]*)$/
+          # Variable
+          receiver = $1
+          message = Regexp.quote($2)
+
+          gv = eval("global_variables", bind).collect(&:to_s)
+          lv = eval("local_variables", bind).collect(&:to_s)
+          cv = eval("self.class.constants", bind).collect(&:to_s)
+
+          if (gv | lv | cv).include?(receiver) or /^[A-Z]/ =~ receiver && /\./ !~ receiver
+            # foo.func and foo is local var. OR
+            # Foo::Bar.func
+            begin
+              candidates = eval("#{receiver}.methods", bind).collect(&:to_s)
+            rescue RescuableException
+              candidates = []
+            end
+          else
+            # func1.func2
+            candidates = []
+            ObjectSpace.each_object(Module){|m|
+              begin
+                name = m.name.to_s
+              rescue RescuableException
+                name = ""
+              end
+              next if name != "IRB::Context" and
+              /^(IRB|SLex|RubyLex|RubyToken)/ =~ name
+
+              # jruby doesn't always provide #instance_methods() on each
+              # object.
+              if m.respond_to?(:instance_methods)
+                candidates.concat m.instance_methods(false).collect(&:to_s)
+              end
+            }
+            candidates.sort!
+            candidates.uniq!
+          end
+          select_message(path, receiver, message, candidates)
+
+        when /^\.([^.]*)$/
+          # Unknown(maybe String)
+          receiver = ""
+          message = Regexp.quote($1)
+
+          candidates = String.instance_methods(true).collect(&:to_s)
+          select_message(path, receiver, message, candidates)
+
+        else
+
+          candidates = eval(
+            "methods | private_methods | local_variables | " \
+              "self.class.constants | instance_variables",
+            bind
+          ).collect(&:to_s)
+
+          if eval("respond_to?(:class_variables)", bind)
+            candidates += eval("class_variables", bind).collect(&:to_s)
+          end
+          candidates = (candidates|ReservedWords|custom_completions).grep(/^#{Regexp.quote(input)}/)
+          candidates.collect(&path)
+        end
+      rescue RescuableException
+        []
+      end
+    end
+
+    def self.select_message(path, receiver, message, candidates)
+      candidates.grep(/^#{message}/).collect { |e|
+        case e
+        when /^[a-zA-Z_]/
+          path.call(receiver + "." + e)
+        when /^[0-9]/
+        when *Operators
+          #receiver + " " + e
+        end
+      }.compact
+    end
+
+    # build_path seperates the input into two parts: path and input.
+    # input is the partial string that should be completed
+    # path is a proc that takes an input and builds a full path.
+    def self.build_path(input)
+
+      # check to see if the input is a regex
+      return proc {|i| i.to_s }, input if input[/\/\./]
+
+      trailing_slash = input.end_with?('/')
+      contexts = input.chomp('/').split(/\//)
+      input = contexts[-1]
+
+      path = proc do |i|
+        p = contexts[0..-2].push(i).join('/')
+        p += '/' if trailing_slash && !i.nil?
+        p
+      end
+
+      return path, input
+    end
+  end
+end

data/lib/pry/config.rb

@@ -1,24 +1,237 @@
-class Pry::Config
-  require_relative 'config/behavior'
-  require_relative 'config/default'
-  require_relative 'config/convenience'
-  include Pry::Config::Behavior
-
-  def self.shortcuts
-    Convenience::SHORTCUTS
-  end
+require 'ostruct'
+
+class Pry
+  class Config < OpenStruct
+
+    # Get/Set the object to use for input by default by all Pry instances.
+    # Pry.config.input is an option determining the input object - the object from
+    # which Pry retrieves its lines of input. Pry accepts any object that implements the readline method.
+    # This includes IO objects, StringIO, Readline, File and custom objects.
+    # @return [#readline] The object to use for input by default by all
+    #   Pry instances.
+    # @example
+    #   Pry.config.input = StringIO.new("@x = 10\nexit")
+    attr_accessor :input
+
+    # Get/Set the object to use for output by default by all Pry instances.
+    # Pry.config.output is an option determining the output object - the object to which
+    # Pry writes its output. Pry accepts any object that implements the puts method. This
+    # includes IO objects, StringIO, File and custom objects.
+    # @return [#puts] The object to use for output by default by all
+    #   Pry instances.
+    # @example
+    #   Pry.config.output = StringIO.new
+    attr_accessor :output
+
+    # Get/Set the object to use for commands by default by all Pry instances.
+    # @return [Pry::CommandBase] The object to use for commands by default by all
+    #   Pry instances.
+    # @example
+    #   Pry.config.commands = Pry::CommandSet.new do
+    #               import_from Pry::Commands, "ls"
+    #
+    #                 command "greet" do |name|
+    #                 output.puts "hello #{name}"
+    #               end
+    #             end
+    attr_accessor :commands
+
+    # Get/Set the Proc to use for printing by default by all Pry
+    # instances.
+    # Two parameters are passed to the print Proc: these are (1) the
+    # output object for the current session and (2) the expression value to print. It is important
+    # that you write to the output object instead of just stdout so that all Pry output can be redirected if necessary.
+    # This is the 'print' component of the REPL.
+    # @return [Proc] The Proc to use for printing by default by all
+    #   Pry instances.
+    # @example
+    #   Pry.config.print = proc { |output, value| output.puts "=> #{value.inspect}" }
+    attr_accessor :print
+
+    # Pry.config.exception_handler is an option determining the exception handler object - the
+    # Proc responsible for dealing with exceptions raised by user input to the REPL.
+    # Three parameters are passed to the exception handler Proc: these
+    # are (1) the output object for the current session, (2) the
+    # exception object that was raised inside the Pry session, and (3)
+    # a reference to the associated Pry instance.
+    # @return [Proc] The Proc to use for printing exceptions by default by all
+    #   Pry instances.
+    # @example
+    #   Pry.config.exception_handler = proc do |output, exception, _|
+    #     output.puts "#{exception.class}: #{exception.message}"
+    #     output.puts "from #{exception.backtrace.first}"
+    #   end
+    attr_accessor :exception_handler
+
+    # @return [Array] The classes of exception that will not be caught by Pry.
+    # @example
+    #   Pry.config.exception_whitelist = [SystemExit, SignalException]
+    attr_accessor :exception_whitelist
+
+    # @return [Fixnum] The number of lines of context to show before and after
+    #   exceptions, etc.
+    # @example
+    #   Pry.config.default_window_size = 10
+    attr_accessor :default_window_size
 
-  #
-  # FIXME
-  # @param [Pry::Hooks] hooks
-  #
-  def hooks=(hooks)
-    if hooks.is_a?(Hash)
-      warn "Hash-based hooks are now deprecated! Use a `Pry::Hooks` object " \
-           "instead! http://rubydoc.info/github/pry/pry/master/Pry/Hooks"
-      self["hooks"] = Pry::Hooks.from_hash(hooks)
-    else
-      self["hooks"] = hooks
+    # Get/Set the `Pry::Hooks` instance that defines Pry hooks used by default by all Pry
+    # instances.
+    # @return [Pry::Hooks] The hooks used by default by all Pry instances.
+    # @example
+    #   Pry.config.hooks = Pry::Hooks.new.add_hook(:before_session,
+    #   :default) {  |output, target, _pry_| output.puts "Good morning!" }
+    attr_reader :hooks
+
+    # FIXME:
+    # This is a hack to alert people of the new API.
+    # @param [Pry::Hooks] v Only accept `Pry::Hooks` now!
+    def hooks=(v)
+      if v.is_a?(Hash)
+        warn "Hash-based hooks are now deprecated! Use a `Pry::Hooks` object instead! http://rubydoc.info/github/pry/pry/master/Pry/Hooks"
+        @hooks = Pry::Hooks.from_hash(v)
+      else
+        @hooks = v
+      end
     end
+
+    # Get the array of Procs (or single Proc) to be used for the prompts by default by
+    # all Pry instances.
+    # Three parameters are passed into the prompt procs, (1) the
+    # object that is the target of the session, (2) the current
+    # nesting level, and (3) a reference to the associated Pry instance. These objects can be used in the prompt, if desired.
+    # @return [Array<Proc>, Proc] The array of Procs to be used for the
+    #   prompts by default by all Pry instances.
+    # @example
+    #   Pry.config.prompt = proc { |obj, nest_level, _pry_| "#{obj}:#{nest_level}> " }
+    attr_accessor :prompt
+
+    # The display name that is part of the prompt.  Default is 'pry'. 
+    # You can set your own name so you can identify which project your current pry session
+    # is using.  This is useful if you have a local pryrc file in a Rails project for example.
+    # @return [String]
+    # @example 
+    #   Pry.config.prompt_name = 'my_rails_project'
+    attr_accessor :prompt_name
+    
+    # The default editor to use. Defaults to $VISUAL, $EDITOR, or a sensible fallback
+    # for the platform.
+    # If `editor` is a String then that string is used as the shell
+    # command to invoke the editor. If `editor` is callable (e.g a
+    # Proc) then `file`, `line`, and `reloading` are passed in as parameters and the
+    # return value of that callable invocation is used as the exact
+    # shell command to invoke the editor. `reloading` indicates whether Pry will be
+    # reloading code after the shell command returns. Any or all of these parameters
+    # can be omitted from the callable's signature.
+    # @example String
+    #   Pry.config.editor = "emacsclient"
+    # @example Callable
+    #   Pry.config.editor = proc { |file, line| "emacsclient #{file} +#{line}" }
+    # @example Callable waiting only if reloading
+    #   Pry.config.editor = proc { |file, line, reloading| "subl #{'--wait' if reloading} #{file}:#{line}" }
+    # @return [String, #call]
+    attr_accessor :editor
+
+    # A string that must precede all Pry commands (e.g., if command_prefix is
+    # set to "%", the "cd" command must be invoked as "%cd").
+    # @return [String]
+    attr_accessor :command_prefix
+
+    # @return [Boolean] Toggle Pry color on and off.
+    attr_accessor :color
+
+    # @return [Boolean] Toggle paging on and off.
+    attr_accessor :pager
+
+    # Determines whether the rc file (~/.pryrc) should be loaded.
+    # @return [Boolean]
+    attr_accessor :should_load_rc
+
+    # Determines whether the local rc file (./.pryrc) should be loaded.
+    # @return [Boolean]
+    attr_accessor :should_load_local_rc
+
+    # Determines whether plugins should be loaded.
+    # @return [Boolean]
+    attr_accessor :should_load_plugins
+
+    # Determines whether to load files specified with the -r flag.
+    # @return [Boolean]
+    attr_accessor :should_load_requires
+
+    # Determines whether to disable edit-method's auto-reloading behavior.
+    # @return [Boolean]
+    attr_accessor :disable_auto_reload
+
+    # Determines whether Pry should trap SIGINT and cause it to raise an
+    # Interrupt exception. This is only useful on jruby, MRI does this
+    # for us.
+    # @return [Boolean]
+    attr_accessor :should_trap_interrupts
+
+    # Config option for history.
+    # sub-options include history.file, history.load, and history.save
+    # history.file is the file to save/load history to, e.g
+    # Pry.config.history.file = "~/.pry_history".
+    # history.should_load is a boolean that determines whether history will be
+    # loaded from history.file at session start.
+    # history.should_save is a boolean that determines whether history will be
+    # saved to history.file at session end.
+    # @return [OpenStruct]
+    attr_accessor :history
+
+    # Config option for plugins:
+    # sub-options include:
+    # `plugins.strict_loading` (Boolean) which toggles whether referring to a non-existent plugin should raise an exception (defaults to `false`)
+    # @return [OpenStruct]
+    attr_accessor :plugins
+
+    # @return [Array<String>] Ruby files to be required after loading any plugins.
+    attr_accessor :requires
+
+    # @return [Integer] Amount of results that will be stored into out
+    attr_accessor :memory_size
+
+    # @return [Proc] The proc that manages ^D presses in the REPL.
+    #   The proc is passed the current eval_string and the current pry instance.
+    attr_accessor :control_d_handler
+
+    # @return [Proc] The proc that runs system commands
+    #   The proc is passed the pry output object, the command string
+    #   to eval, and a reference to the pry instance
+    attr_accessor :system
+
+    # @return [Boolean] Whether or not code should be indented
+    #  using Pry::Indent.
+    attr_accessor :auto_indent
+
+    # @return [Boolean] Whether or not indentation should be corrected
+    #   after hitting enter. This feature is not supported by all terminals.
+    attr_accessor :correct_indent
+
+    # @return [Boolean] Whether or not a warning will be displayed when
+    #   a command name collides with a method/local in the current context.
+    attr_accessor :collision_warning
+
+
+    # Config option for gist.
+    # sub-options include `gist.inspecter`,
+    # `gist.inspecter` is a callable that defines how the expression output
+    # will be displayed when using the `gist -i` command.
+    # @example Pretty inspect output
+    #   Pry.config.gist.inspecter = proc { |v| v.pretty_inspect }
+    # @example Regular inspect
+    #   Pry.config.gist.inspecter = proc &:inspect
+    # @return [OpenStruct]
+    attr_accessor :gist
+
+    # @return [Hash] Additional sticky locals (to the standard ones) to use in Pry sessions.
+    # @example Inject `random_number` sticky local into Pry session
+    #   Pry.config.extra_sticky_locals = { :random_number => proc {
+    #   rand(10) } }
+    attr_accessor :extra_sticky_locals
+
+    # @return [#build_completion_proc] A completer to use.
+    attr_accessor :completer
   end
 end
+