pry 0.10.pre.1-i386-mingw32 → 0.10.0.pre3-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,13 +57,31 @@ class Pry
         self.option_processors = nil
       end
 
-      def parse_options(args=ARGV.dup)
-        raise NoOptionsError, "No command line options defined! Use Pry::CLI.add_options to add command line options." if !options
+      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)
-        option_processors.each { |processor| processor.call(opts) } if option_processors # option processors are optional
+        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
+          option_processors.each { |processor| processor.call(opts) }
+        end
 
         self
       end
@@ -73,18 +92,32 @@ class Pry
   end
 end
 
+
+# String that is built to be executed on start (created by -e and -exec switches)
+exec_string = ""
+
 # Bring in options defined by plugins
-Pry::CLI.add_plugin_options
+Slop.new do
+  on "no-plugins" do
+    Pry.config.should_load_plugins = false
+  end
+end.parse(ARGV.dup)
+
+if Pry.config.should_load_plugins
+  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.
-Copyright (c) 2011 John Mair (banisterfiend)
+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", :argument => true
+  on :e, :exec=, "A line of code to execute in context before the session starts" do |input|
+    exec_string << input << "\n"
+  end
 
   on "no-pager", "Disable pager for long output" do
     Pry.config.pager = false
@@ -95,20 +128,20 @@ Copyright (c) 2011 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" do
-    # load ~/.pryrc, if not suppressed with -f option
+  on :f, "Suppress loading of ~/.pryrc and ./.pryrc" do
     Pry.config.should_load_rc = false
+    Pry.config.should_load_local_rc = false
   end
 
-  on :s, "select-plugin", "Only load specified plugin (and no others).", :argument => true do |plugin_name|
+  on :s, "select-plugin=", "Only load specified plugin (and no others)." do |plugin_name|
     Pry.config.should_load_plugins = false
     Pry.plugins[plugin_name].activate!
   end
 
-  on :d, "disable-plugin", "Disable a specific plugin.", :argument => true do |plugin_name|
+  on :d, "disable-plugin=", "Disable a specific plugin." do |plugin_name|
     Pry.plugins[plugin_name].disable!
   end
 
@@ -116,11 +149,11 @@ Copyright (c) 2011 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
@@ -129,12 +162,27 @@ Copyright (c) 2011 John Mair (banisterfiend)
     Pry.config.prompt = Pry::SIMPLE_PROMPT
   end
 
-  on :r, :require, "`require` a Ruby script at startup", :argument => true do |file|
+  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
 
-  on :I, "Add a path to the $LOAD_PATH", :argument => true do |path|
-    $LOAD_PATH << path
+  on :I=, "Add a path to the $LOAD_PATH", :as => Array, :delimiter => ":" do |load_path|
+    load_path.map! do |path|
+      /\A\.\// =~ path ? path : File.expand_path(path)
+    end
+
+    $LOAD_PATH.unshift(*load_path)
+  end
+
+  on "gem", "Shorthand for -I./lib -rgemname" do |load_path|
+    $LOAD_PATH.unshift("./lib")
+    Dir["./lib/*.rb"].each do |file|
+      Pry.config.requires << file
+    end
   end
 
   on :v, :version, "Display the Pry version" do
@@ -142,12 +190,11 @@ Copyright (c) 2011 John Mair (banisterfiend)
     exit
   end
 
-  on(:c, :context,
+  on(:c, :context=,
      "Start the session in the specified context. Equivalent to `context.pry` in a session.",
-     :argument => true,
      :default => "Pry.toplevel_binding"
      )
-end.process_options do |opts|
+end.add_option_processor do |opts|
 
   exit if opts.help?
 
@@ -155,19 +202,19 @@ 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)
     Pry.load_file_through_repl(full_name)
     exit
-  elsif opts[:exec]
-    exec_string = opts[:exec] + "\n"
-  else
-    exec_string = ""
   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,3 +1,7 @@
+require 'pry/code/loc'
+require 'pry/code/code_range'
+require 'pry/code/code_file'
+
 class Pry
   class << self
     # Convert the given object into an instance of `Pry::Code`, if it isn't
@@ -32,23 +36,12 @@ class Pry
       # Instantiate a `Code` object containing code loaded from a file or
       # Pry's line buffer.
       #
-      # @param [String] fn The name of a file, or "(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(fn, code_type = nil)
-        if fn == Pry.eval_path
-          f = Pry.line_buffer.drop(1)
-        else
-          if File.readable?(fn)
-            f = File.open(fn, 'r')
-            code_type = type_from_filename(fn)
-          else
-            raise MethodSource::SourceNotFoundError, "Cannot open #{fn.inspect} for reading."
-          end
-        end
-        new(f, 1, code_type || :ruby)
-      ensure
-        f.close if f.respond_to?(:close)
+      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
@@ -56,10 +49,10 @@ class Pry
       #
       # @param [::Method, UnboundMethod, Proc, Pry::Method] meth The method
       #   object.
-      # @param [Fixnum, nil] start_line The line number to start on, or nil to
+      # @param [Integer, nil] start_line The line number to start on, or nil to
       #   use the method's original line numbers.
       # @return [Code]
-      def from_method(meth, start_line=nil)
+      def from_method(meth, start_line = nil)
         meth = Pry::Method(meth)
         start_line ||= meth.source_line || 1
         new(meth.source, start_line, meth.source_type)
@@ -68,48 +61,16 @@ class Pry
       # Attempt to extract the source code for module (or class) `mod`.
       #
       # @param [Module, Class] mod The module (or class) of interest.
-      # @param [Fixnum, nil] start_line The line number to start on, or nil to use the
-      #   method's original line numbers.
-      # @param [Fixnum] candidate_rank The module candidate (by rank)
+      # @param [Integer] candidate_rank The module candidate (by rank)
       #   to use (see `Pry::WrappedModule::Candidate` for more information).
+      # @param [Integer, nil] start_line The line number to start on, or nil to
+      #   use the method's original line numbers.
       # @return [Code]
-      def from_module(mod, start_line=nil, candidate_rank=0)
+      def from_module(mod, candidate_rank = 0, start_line=nil)
         candidate = Pry::WrappedModule(mod).candidate(candidate_rank)
-
         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
-        # @return [Symbol, nil]
-        def type_from_filename(filename)
-          map = {
-            %w(.c .h) => :c,
-            %w(.cpp .hpp .cc .h cxx) => :cpp,
-            %w(.rb .ru .irbrc .gemspec .pryrc) => :ruby,
-            %w(.py) => :python,
-            %w(.diff) => :diff,
-            %w(.css) => :css,
-            %w(.html) => :html,
-            %w(.yaml .yml) => :yaml,
-            %w(.xml) => :xml,
-            %w(.php) => :php,
-            %w(.js) => :javascript,
-            %w(.java) => :java,
-            %w(.rhtml) => :rhtml,
-            %w(.json) => :json
-          }
-
-          _, type = map.find do |k, _|
-            k.any? { |ext| ext == File.extname(filename) }
-          end
-
-          type
-        end
     end
 
     # @return [Symbol] The type of code stored in this wrapper.
@@ -121,37 +82,39 @@ class Pry
     # empty `Code` object and then use `#push` to insert the lines.
     #
     # @param [Array<String>, String, IO] lines
-    # @param [Fixnum?] start_line
+    # @param [Integer?] start_line
     # @param [Symbol?] code_type
-    def initialize(lines=[], start_line=1, code_type=:ruby)
+    def initialize(lines = [], start_line = 1, code_type = :ruby)
       if lines.is_a? String
         lines = lines.lines
       end
-
-      @lines = lines.each_with_index.map { |l, i| [l.chomp, i + start_line.to_i] }
+      @lines = lines.each_with_index.map { |line, lineno|
+        LOC.new(line, lineno + start_line.to_i) }
       @code_type = code_type
     end
 
-    # Append the given line. `line_num` is one more than the last existing
+    # Append the given line. +lineno+ is one more than the last existing
     # line, unless specified otherwise.
     #
     # @param [String] line
-    # @param [Fixnum?] line_num
+    # @param [Integer?] lineno
     # @return [String] The inserted line.
-    def push(line, line_num=nil)
-      line_num = @lines.last.last + 1 unless line_num
-      @lines.push([line.chomp, line_num])
+    def push(line, lineno = nil)
+      if lineno.nil?
+        lineno = @lines.last.lineno + 1
+      end
+      @lines.push(LOC.new(line, lineno))
       line
     end
     alias << push
 
     # Filter the lines using the given block.
     #
-    # @yield [line]
+    # @yield [LOC]
     # @return [Code]
-    def select(&blk)
+    def select(&block)
       alter do
-        @lines = @lines.select(&blk)
+        @lines = @lines.select(&block)
       end
     end
 
@@ -159,92 +122,74 @@ class Pry
     # `Range` object or a first and last line number (inclusive). Negative
     # indices count from the end of the array of lines.
     #
-    # @param [Range, Fixnum] start_line
-    # @param [Fixnum?] end_line
+    # @param [Range, Integer] start_line
+    # @param [Integer?] end_line
     # @return [Code]
-    def between(start_line, end_line=nil)
+    def between(start_line, end_line = nil)
       return self unless start_line
 
-      if start_line.is_a? Range
-        end_line = start_line.last
-        end_line -= 1 if start_line.exclude_end?
-
-        start_line = start_line.first
-      else
-        end_line ||= start_line
-      end
-
-      if start_line > 0
-        start_idx = @lines.index { |l| l.last >= start_line } || @lines.length
-      else
-        start_idx = start_line
-      end
-
-      if end_line > 0
-        end_idx = (@lines.index { |l| l.last > end_line } || 0) - 1
-      else
-        end_idx = end_line
-      end
+      code_range = CodeRange.new(start_line, end_line)
 
       alter do
-        @lines = @lines[start_idx..end_idx] || []
+        @lines = @lines[code_range.indices_range(@lines)] || []
       end
     end
 
-    # Take `num_lines` from `start_line`, forward or backwards
+    # Take `num_lines` from `start_line`, forward or backwards.
     #
-    # @param [Fixnum] start_line
-    # @param [Fixnum] num_lines
+    # @param [Integer] start_line
+    # @param [Integer] num_lines
     # @return [Code]
     def take_lines(start_line, num_lines)
-      if start_line >= 0
-        start_idx = @lines.index { |l| l.last >= start_line } || @lines.length
-      else
-        start_idx = @lines.length + start_line
-      end
+      start_idx =
+        if start_line >= 0
+          @lines.index { |loc| loc.lineno >= start_line } || @lines.length
+        else
+          [@lines.length + start_line, 0].max
+        end
 
       alter do
         @lines = @lines.slice(start_idx, num_lines)
       end
     end
 
-    # Remove all lines except for the `lines` up to and excluding `line_num`.
+    # Remove all lines except for the +lines+ up to and excluding +lineno+.
     #
-    # @param [Fixnum] line_num
-    # @param [Fixnum] lines
+    # @param [Integer] lineno
+    # @param [Integer] lines
     # @return [Code]
-    def before(line_num, lines=1)
-      return self unless line_num
+    def before(lineno, lines = 1)
+      return self unless lineno
 
-      select do |l, ln|
-        ln >= line_num - lines && ln < line_num
+      select do |loc|
+        loc.lineno >= lineno - lines && loc.lineno < lineno
       end
     end
 
-    # Remove all lines except for the `lines` on either side of and including
-    # `line_num`.
+    # Remove all lines except for the +lines+ on either side of and including
+    # +lineno+.
     #
-    # @param [Fixnum] line_num
-    # @param [Fixnum] lines
+    # @param [Integer] lineno
+    # @param [Integer] lines
     # @return [Code]
-    def around(line_num, lines=1)
-      return self unless line_num
+    def around(lineno, lines = 1)
+      return self unless lineno
 
-      select do |l, ln|
-        ln >= line_num - lines && ln <= line_num + lines
+      select do |loc|
+        loc.lineno >= lineno - lines && loc.lineno <= lineno + lines
       end
     end
 
-    # Remove all lines except for the `lines` after and excluding `line_num`.
+    # Remove all lines except for the +lines+ after and excluding +lineno+.
     #
-    # @param [Fixnum] line_num
-    # @param [Fixnum] lines
+    # @param [Integer] lineno
+    # @param [Integer] lines
     # @return [Code]
-    def after(line_num, lines=1)
-      return self unless line_num
+    def after(lineno, lines = 1)
+      return self unless lineno
 
-      select do |l, ln|
-        ln > line_num && ln <= line_num + lines
+      select do |loc|
+        loc.lineno > lineno && loc.lineno <= lineno + lines
       end
     end
 
@@ -256,8 +201,8 @@ class Pry
       return self unless pattern
       pattern = Regexp.new(pattern)
 
-      select do |l, ln|
-        l =~ pattern
+      select do |loc|
+        loc.line =~ pattern
       end
     end
 
@@ -265,30 +210,30 @@ class Pry
     #
     # @param [Boolean?] y_n
     # @return [Code]
-    def with_line_numbers(y_n=true)
+    def with_line_numbers(y_n = true)
       alter do
         @with_line_numbers = y_n
       end
     end
 
-    # Format output with a marker next to the given `line_num`, unless `line_num`
-    # is falsy.
+    # Format output with a marker next to the given +lineno+, unless +lineno+ is
+    # falsy.
     #
-    # @param [Fixnum?] line_num
+    # @param [Integer?] lineno
     # @return [Code]
-    def with_marker(line_num=1)
+    def with_marker(lineno = 1)
       alter do
-        @with_marker     = !!line_num
-        @marker_line_num = line_num
+        @with_marker   = !!lineno
+        @marker_lineno = lineno
       end
     end
 
     # Format output with the specified number of spaces in front of every line,
     # unless `spaces` is falsy.
     #
-    # @param [Fixnum?] spaces
+    # @param [Integer?] spaces
     # @return [Code]
-    def with_indentation(spaces=0)
+    def with_indentation(spaces = 0)
       alter do
         @with_indentation = !!spaces
         @indentation_num  = spaces
@@ -300,72 +245,67 @@ class Pry
       Object.instance_method(:to_s).bind(self).call
     end
 
-    # Based on the configuration of the object, return a formatted String
-    # representation.
-    #
-    # @return [String]
-    def to_s
-      lines = @lines.map(&:dup)
-
-      if Pry.color
-        lines.each do |l|
-          l[0] = CodeRay.scan(l[0], @code_type).term
-        end
-      end
-
-      if @with_line_numbers
-        max_width = lines.last.last.to_s.length if lines.length > 0
-        lines.each do |l|
-          padded_line_num = l[1].to_s.rjust(max_width)
-          l[0] = "#{Pry::Helpers::BaseHelpers.colorize_code(padded_line_num.to_s)}: #{l[0]}"
-        end
-      end
+    # @return [Integer] the number of digits in the last line.
+    def max_lineno_width
+      @lines.length > 0 ? @lines.last.lineno.to_s.length : 0
+    end
 
-      if @with_marker
-        lines.each do |l|
-          if l[1] == @marker_line_num
-            l[0] = " => #{l[0]}"
-          else
-            l[0] = "    #{l[0]}"
-          end
-        end
-      end
+    # @return [String] a formatted representation (based on the configuration of
+    #   the object).
+    def to_s
+      print_to_output("")
+    end
 
-      if @with_indentation
-        lines.each do |l|
-          l[0] = "#{' ' * @indentation_num}#{l[0]}"
-        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)
+        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
+        output << loc.line
+        output << "\n"
       end
-
-      lines.map { |l| "#{l.first}\n" }.join
+      output
     end
 
     # Get the comment that describes the expression on the given line number.
     #
-    # @param [Fixnum]  line_number (1-based)
-    # @return [String]  the code.
+    # @param [Integer] line_number (1-based)
+    # @return [String] the code.
     def comment_describing(line_number)
       self.class.comment_describing(raw, line_number)
     end
 
     # Get the multiline expression that starts on the given line number.
     #
-    # @param [Fixnum]  line_number (1-based)
-    # @return [String]  the code.
-    def expression_at(line_number, consume=0)
+    # @param [Integer] line_number (1-based)
+    # @return [String] the code.
+    def expression_at(line_number, consume = 0)
       self.class.expression_at(raw, line_number, :consume => consume)
     end
 
+    # Get the (approximate) Module.nesting at the give line number.
+    #
+    # @param [Integer] line_number line number starting from 1
+    # @param [Module] top_module the module in which this code exists
+    # @return [Array<Module>] a list of open modules.
+    def nesting_at(line_number, top_module = Object)
+      Pry::Indent.nesting_at(raw, line_number)
+    end
+
     # Return an unformatted String of the code.
     #
     # @return [String]
     def raw
-      @lines.map(&:first).join("\n") + "\n"
+      @lines.map(&:line).join("\n") << "\n"
     end
 
     # Return the number of lines stored.
     #
-    # @return [Fixnum]
+    # @return [Integer]
     def length
       @lines ? @lines.length : 0
     end
@@ -377,26 +317,25 @@ class Pry
     # @return [Boolean]
     def ==(other)
       if other.is_a?(Code)
-        @other_lines = other.instance_variable_get(:@lines)
-        @lines.each_with_index.all? do |(l, ln), i|
-          l == @other_lines[i].first && ln == @other_lines[i].last
-        end
+        other_lines = other.instance_variable_get(:@lines)
+        @lines.each_with_index.all? { |loc, i| loc == other_lines[i] }
       else
         to_s.chomp == other.to_s.chomp
       end
     end
 
     # Forward any missing methods to the output of `#to_s`.
-    def method_missing(name, *args, &blk)
-      to_s.send(name, *args, &blk)
+    def method_missing(name, *args, &block)
+      to_s.send(name, *args, &block)
     end
     undef =~
 
     protected
-      # An abstraction of the `dup.instance_eval` pattern used throughout this
-      # class.
-      def alter(&blk)
-        dup.tap { |o| o.instance_eval(&blk) }
-      end
+
+    # An abstraction of the `dup.instance_eval` pattern used throughout this
+    # class.
+    def alter(&block)
+      dup.tap { |o| o.instance_eval(&block) }
+    end
   end
 end