pry 0.9.12.6-i386-mingw32 → 0.10.0-i386-mingw32

data/lib/pry/cli.rb

@@ -1,4 +1,3 @@
-
 class Pry
 
   # Manage the processing of command line options
@@ -11,7 +10,9 @@ class Pry
       # @return [Proc] The Proc defining the valid command line options.
       attr_accessor :options
 
-      # @return [Array] The Procs that process the parsed options.
+      # @return [Array] The Procs that process the parsed options. Plugins can
+      #   utilize this facility in order to add and process their own Pry
+      #   options.
       attr_accessor :option_processors
 
       # @return [Array<String>] The input array of strings to process
@@ -43,7 +44,7 @@ class Pry
       end
 
       # Add a block responsible for processing parsed options.
-      def process_options(&block)
+      def add_option_processor(&block)
         self.option_processors ||= []
         option_processors << block
 
@@ -56,14 +57,26 @@ class Pry
         self.option_processors = nil
       end
 
-      def parse_options(args=ARGV.dup)
+      def parse_options(args=ARGV)
         unless options
           raise NoOptionsError, "No command line options defined! Use Pry::CLI.add_options to add command line options."
         end
 
         self.input_args = args
 
-        opts = Slop.parse!(args, :help => true, :multiple_switches => false, &options)
+        begin
+          opts = Slop.parse!(
+            args,
+            :help => true,
+            :multiple_switches => false,
+            :strict => true,
+            &options
+          )
+        rescue Slop::InvalidOptionError
+          # Display help message on unknown switches and exit.
+          puts Slop.new(&options)
+          exit
+        end
 
         # Option processors are optional.
         if option_processors
@@ -91,19 +104,19 @@ Slop.new do
 end.parse(ARGV.dup)
 
 if Pry.config.should_load_plugins
-  Pry::CLI.add_plugin_options 
+  Pry::CLI.add_plugin_options
 end
 
 # The default Pry command line options (before plugin options are included)
 Pry::CLI.add_options do
   banner %{Usage: pry [OPTIONS]
 Start a Pry session.
-See: `https://github.com/pry` for more information.
+See http://pryrepl.org/ for more information.
 Copyright (c) 2013 John Mair (banisterfiend)
 --
 }
   on :e, :exec=, "A line of code to execute in context before the session starts" do |input|
-    exec_string << input + "\n"
+    exec_string << input << "\n"
   end
 
   on "no-pager", "Disable pager for long output" do
@@ -115,7 +128,7 @@ Copyright (c) 2013 John Mair (banisterfiend)
   end
 
   on "no-color", "Disable syntax highlighting for session" do
-    Pry.color = false
+    Pry.config.color = false
   end
 
   on :f, "Suppress loading of ~/.pryrc and ./.pryrc" do
@@ -136,11 +149,11 @@ Copyright (c) 2013 John Mair (banisterfiend)
     Pry.config.should_load_plugins = false
   end
 
-  on "installed-plugins", "List installed plugins." do
+  on "plugins", "List installed plugins." do
     puts "Installed Plugins:"
     puts "--"
     Pry.locate_plugins.each do |plugin|
-      puts "#{plugin.name}".ljust(18) + plugin.spec.summary
+      puts "#{plugin.name}".ljust(18) << plugin.spec.summary
     end
     exit
   end
@@ -149,6 +162,10 @@ Copyright (c) 2013 John Mair (banisterfiend)
     Pry.config.prompt = Pry::SIMPLE_PROMPT
   end
 
+  on "noprompt", "No prompt mode" do
+    Pry.config.prompt = Pry::NO_PROMPT
+  end
+
   on :r, :require=, "`require` a Ruby script at startup" do |file|
     Pry.config.requires << file
   end
@@ -177,7 +194,7 @@ Copyright (c) 2013 John Mair (banisterfiend)
      "Start the session in the specified context. Equivalent to `context.pry` in a session.",
      :default => "Pry.toplevel_binding"
      )
-end.process_options do |opts|
+end.add_option_processor do |opts|
 
   exit if opts.help?
 
@@ -185,7 +202,12 @@ end.process_options do |opts|
   Pry.cli = true
 
   # create the actual context
-  context = Pry.binding_for(eval(opts[:context]))
+  if opts[:context]
+    Pry.initial_session_setup
+    context = Pry.binding_for(eval(opts[:context]))
+  else
+    context = Pry.toplevel_binding
+  end
 
   if Pry::CLI.input_args.any? && Pry::CLI.input_args != ["pry"]
     full_name = File.expand_path(Pry::CLI.input_args.first)
@@ -193,10 +215,6 @@ end.process_options do |opts|
     exit
   end
 
-  if Pry.config.should_load_plugins
-    parser = Slop.new
-  end
-
   # Start the session (running any code passed with -e, if there is any)
   Pry.start(context, :input => StringIO.new(exec_string))
 end

data/lib/pry/code.rb

@@ -1,5 +1,6 @@
 require 'pry/code/loc'
 require 'pry/code/code_range'
+require 'pry/code/code_file'
 
 class Pry
   class << self
@@ -29,26 +30,6 @@ class Pry
   # arbitrary chaining of formatting methods without mutating the original
   # object.
   class Code
-
-    # List of all supported languages.
-    # @return [Hash]
-    EXTENSIONS = {
-      %w(.py)        => :python,
-      %w(.js)        => :javascript,
-      %w(.css)       => :css,
-      %w(.xml)       => :xml,
-      %w(.php)       => :php,
-      %w(.html)      => :html,
-      %w(.diff)      => :diff,
-      %w(.java)      => :java,
-      %w(.json)      => :json,
-      %w(.c .h)      => :c,
-      %w(.rhtml)     => :rhtml,
-      %w(.yaml .yml) => :yaml,
-      %w(.cpp .hpp .cc .h cxx) => :cpp,
-      %w(.rb .ru .irbrc .gemspec .pryrc) => :ruby,
-    }
-
     class << self
       include MethodSource::CodeHelpers
 
@@ -58,13 +39,9 @@ class Pry
       # @param [String] filename The name of a file, or "(pry)".
       # @param [Symbol] code_type The type of code the file contains.
       # @return [Code]
-      def from_file(filename, code_type = type_from_filename(filename))
-        code = if filename == Pry.eval_path
-                 Pry.line_buffer.drop(1)
-               else
-                 File.read(abs_path(filename))
-               end
-        new(code, 1, code_type)
+      def from_file(filename, code_type = nil)
+        code_file = CodeFile.new(filename, code_type)
+        new(code_file.code, 1, code_file.code_type)
       end
 
       # Instantiate a `Code` object containing code extracted from a
@@ -94,35 +71,6 @@ class Pry
         start_line ||= candidate.line
         new(candidate.source, start_line, :ruby)
       end
-
-      protected
-
-      # Guess the CodeRay type of a file from its extension, or nil if
-      # unknown.
-      #
-      # @param [String] filename
-      # @param [Symbol] default (:ruby) the file type to assume if none could be
-      #   detected.
-      # @return [Symbol, nil]
-      def type_from_filename(filename, default = :ruby)
-        _, type = Pry::Code::EXTENSIONS.find do |k, _|
-          k.any? { |ext| ext == File.extname(filename) }
-        end
-
-        type || default
-      end
-
-      # @param [String] filename
-      # @raise [MethodSource::SourceNotFoundError] if the +filename+ is not
-      #   readable for some reason.
-      # @return [String] absolute path for the given +filename+.
-      def abs_path(filename)
-        abs_path = [File.expand_path(filename, Dir.pwd),
-                    File.expand_path(filename, Pry::INITIAL_PWD)
-                   ].detect { |abs_path| File.readable?(abs_path) }
-        abs_path or raise MethodSource::SourceNotFoundError,
-                          "Cannot open #{filename.inspect} for reading."
-      end
     end
 
     # @return [Symbol] The type of code stored in this wrapper.
@@ -197,7 +145,7 @@ class Pry
         if start_line >= 0
           @lines.index { |loc| loc.lineno >= start_line } || @lines.length
         else
-          @lines.length + start_line
+          [@lines.length + start_line, 0].max
         end
 
       alter do
@@ -305,14 +253,22 @@ class Pry
     # @return [String] a formatted representation (based on the configuration of
     #   the object).
     def to_s
-      @lines.map { |loc|
+      print_to_output("")
+    end
+
+    # Writes a formatted representation (based on the configuration of the
+    # object) to the given output, which must respond to `#<<`.
+    def print_to_output(output, color=false)
+      @lines.each do |loc|
         loc = loc.dup
-        loc.colorize(@code_type)              if Pry.color
-        loc.add_line_number(max_lineno_width) if @with_line_numbers
+        loc.colorize(@code_type)
+        loc.add_line_number(max_lineno_width, color) if @with_line_numbers
         loc.add_marker(@marker_lineno)        if @with_marker
         loc.indent(@indentation_num)          if @with_indentation
-        loc.line
-      }.join("\n") + "\n"
+        output << loc.line
+        output << "\n"
+      end
+      output
     end
 
     # Get the comment that describes the expression on the given line number.
@@ -344,7 +300,7 @@ class Pry
     #
     # @return [String]
     def raw
-      @lines.map(&:line).join("\n") + "\n"
+      @lines.map(&:line).join("\n") << "\n"
     end
 
     # Return the number of lines stored.

data/lib/pry/code/code_file.rb

@@ -0,0 +1,103 @@
+class Pry
+  class CodeFile
+    DEFAULT_EXT = '.rb'
+
+    # List of all supported languages.
+    # @return [Hash]
+    EXTENSIONS = {
+      %w(.py)        => :python,
+      %w(.js)        => :javascript,
+      %w(.css)       => :css,
+      %w(.xml)       => :xml,
+      %w(.php)       => :php,
+      %w(.html)      => :html,
+      %w(.diff)      => :diff,
+      %w(.java)      => :java,
+      %w(.json)      => :json,
+      %w(.c .h)      => :c,
+      %w(.rhtml)     => :rhtml,
+      %w(.yaml .yml) => :yaml,
+      %w(.cpp .hpp .cc .h cxx) => :cpp,
+      %w(.rb .ru .irbrc .gemspec .pryrc) => :ruby,
+    }
+
+    # @return [Symbol] The type of code stored in this wrapper.
+    attr_reader :code_type
+
+    # @param [String] filename The name of a file with code to be detected
+    # @param [Symbol] code_type The type of code the `filename` contains
+    def initialize(filename, code_type = type_from_filename(filename))
+      @filename = filename
+      @code_type = code_type
+    end
+
+    # @return [String] The code contained in the current `@filename`.
+    def code
+      if @filename == Pry.eval_path
+        Pry.line_buffer.drop(1)
+      elsif Pry::Method::Patcher.code_for(@filename)
+        Pry::Method::Patcher.code_for(@filename)
+      elsif RbxPath.is_core_path?(@filename)
+        File.read(RbxPath.convert_path_to_full(@filename))
+      else
+        path = abs_path
+        @code_type = type_from_filename(path)
+        File.read(path)
+      end
+    end
+
+    private
+
+    # @raise [MethodSource::SourceNotFoundError] if the `filename` is not
+    #   readable for some reason.
+    # @return [String] absolute path for the given `filename`.
+    def abs_path
+      code_path.detect { |path| readable?(path) } or
+        raise MethodSource::SourceNotFoundError,
+              "Cannot open #{ @filename.inspect } for reading."
+    end
+
+    # @param [String] path
+    # @return [Boolean] if the path, with or without the default ext,
+    #   is a readable file then `true`, otherwise `false`.
+    def readable?(path)
+      File.readable?(path) && !File.directory?(path) or
+        File.readable?(path << DEFAULT_EXT)
+    end
+
+    # @return [Array] All the paths that contain code that Pry can use for its
+    #   API's. Skips directories.
+    def code_path
+      [from_pwd, from_pry_init_pwd, *from_load_path]
+    end
+
+    # @param [String] filename
+    # @param [Symbol] default (:unknown) the file type to assume if none could be
+    #   detected.
+    # @return [Symbol, nil] The CodeRay type of a file from its extension, or
+    #   `nil` if `:unknown`.
+    def type_from_filename(filename, default = :unknown)
+      _, @code_type = EXTENSIONS.find do |k, _|
+        k.any? { |ext| ext == File.extname(filename) }
+      end
+
+      code_type || default
+    end
+
+    # @return [String]
+    def from_pwd
+      File.expand_path(@filename, Dir.pwd)
+    end
+
+    # @return [String]
+    def from_pry_init_pwd
+      File.expand_path(@filename, Pry::INITIAL_PWD)
+    end
+
+    # @return [String]
+    def from_load_path
+      $LOAD_PATH.map { |path| File.expand_path(@filename, path) }
+    end
+
+  end
+end

data/lib/pry/code/code_range.rb

@@ -22,7 +22,8 @@ class Pry
 
       private
 
-      attr_reader :start_line, :end_line
+      def start_line; @start_line; end
+      def end_line; @end_line; end
 
       # If `end_line` is equal to `nil`, then calculate it from the first
       # parameter, `start_line`. Otherwise, leave it as it is.

data/lib/pry/code/loc.rb

@@ -59,9 +59,9 @@ class Pry
       #
       # @param [Integer] max_width
       # @return [void]
-      def add_line_number(max_width = 0)
+      def add_line_number(max_width = 0, color = false)
         padded = lineno.to_s.rjust(max_width)
-        colorized_lineno = Pry::Helpers::BaseHelpers.colorize_code(padded)
+        colorized_lineno = color ? Pry::Helpers::BaseHelpers.colorize_code(padded) : padded
         tuple[0] = "#{ colorized_lineno }: #{ line }"
       end
 

data/lib/pry/code_object.rb

@@ -1,4 +1,23 @@
 class Pry
+
+  # This class is responsible for taking a string (identifying a
+  # command/class/method/etc) and returning the relevant type of object.
+  # For example, if the user looks up "show-source" then  a
+  # `Pry::Command` will be returned. Alternatively, if the user passes in "Pry#repl" then
+  # a `Pry::Method` object will be returned.
+  #
+  # The `CodeObject.lookup` method is responsible for 1. figuring out what kind of
+  # object the user wants (applying precedence rules in doing so -- i.e methods
+  # get precedence over commands with the same name) and 2. Returning
+  # the appropriate object. If the user fails to provide a string
+  # identifer for the object (i.e they pass in `nil` or "") then the
+  # object looked up will be the 'current method' or 'current class'
+  # associated with the Binding.
+  #
+  # TODO: This class is a clusterfuck. We need a much more robust
+  # concept of what a "Code Object" really is. Currently
+  # commands/classes/candidates/methods and so on just share a very
+  # ill-defined interface.
   class CodeObject
     module Helpers
       # we need this helper as some Pry::Method objects can wrap Procs
@@ -33,7 +52,7 @@ class Pry
 
     attr_accessor :str
     attr_accessor :target
-    attr_accessor :pry
+    attr_accessor :_pry_
     attr_accessor :super_level
 
     def initialize(str, _pry_, options={})
@@ -42,7 +61,7 @@ class Pry
       }.merge!(options)
 
       @str = str
-      @pry = _pry_
+      @_pry_ = _pry_
       @target = _pry_.current_context
       @super_level = options[:super]
     end
@@ -50,18 +69,24 @@ class Pry
     def command_lookup
       # TODO: just make it so find_command_by_match_or_listing doesn't
       # raise?
-      pry.commands.find_command_by_match_or_listing(str) rescue nil
+      _pry_.commands.find_command_by_match_or_listing(str) rescue nil
     end
 
+    # when no paramter is given (i.e CodeObject.lookup(nil)), then we
+    # lookup the 'current object' from the binding.
     def empty_lookup
       return nil if str && !str.empty?
 
-      if internal_binding?(target)
-        mod = target_self.is_a?(Module) ? target_self : target_self.class
-        Pry::WrappedModule(mod)
-      else
-        Pry::Method.from_binding(target)
-      end
+      obj = if internal_binding?(target)
+              mod = target_self.is_a?(Module) ? target_self : target_self.class
+              Pry::WrappedModule(mod)
+            else
+              Pry::Method.from_binding(target)
+            end
+
+      # respect the super level (i.e user might have specified a
+      # --super flag to show-source)
+      lookup_super(obj, super_level)
     end
 
     # lookup variables and constants and `self` that are not modules
@@ -87,17 +112,12 @@ class Pry
     end
 
     def method_or_class_lookup
-      # we need this here because stupid Pry::Method.from_str() does a
-      # Pry::Method.from_binding when str is nil.
-      # Once we refactor Pry::Method.from_str() so it doesnt lookup
-      # from bindings, we can get rid of this check
-      return nil if str.to_s.empty?
-
-      obj = if str =~ /::(?:\S+)\Z/
-        Pry::WrappedModule.from_str(str,target) || Pry::Method.from_str(str, target)
-      else
-        Pry::Method.from_str(str,target) || Pry::WrappedModule.from_str(str, target)
-      end
+      obj = case str
+            when /\S+\(\)\z/
+              Pry::Method.from_str(str.sub(/\(\)\z/, ''),target) || Pry::WrappedModule.from_str(str, target)
+            else
+              Pry::WrappedModule.from_str(str,target) || Pry::Method.from_str(str, target)
+            end
 
       lookup_super(obj, super_level)
     end
@@ -108,7 +128,6 @@ class Pry
       [::Proc, ::Method, ::UnboundMethod].any? { |o| obj.is_a?(o) }
     end
 
-
     # Returns true if `str` looks like a method, i.e Klass#method
     # We need to consider this case because method lookups should fall
     # through to the `method_or_class_lookup()` method but a