pry 0.9.7.4-i386-mingw32 → 0.9.8-i386-mingw32

data/lib/pry/default_commands/shell.rb

@@ -28,104 +28,209 @@ class Pry
           _pry_.instance_eval(&Pry::FILE_COMPLETIONS)
         end
       end
-
       alias_command "file-mode", "shell-mode"
 
-      command "cat", "Show output of file FILE. Type `cat --help` for more information." do |*args|
-        start_line = 0
-        end_line = -1
-        file_name = nil
-        bt_index = 0
+      create_command "save-file", "Export to a file using content from the REPL."  do
+        banner <<-USAGE
+          Usage: save-file [OPTIONS] [FILE]
+          Save REPL content to a file.
+          e.g: save-file -m my_method -m my_method2 ./hello.rb
+          e.g: save-file -i 1..10 ./hello.rb --append
+          e.g: save-file -c show-method ./my_command.rb
+          e.g: save-file -f sample_file --lines 2..10 ./output_file.rb
+        USAGE
+
+        attr_accessor :content
+        attr_accessor :file_name
+
+        def setup
+          self.content = ""
+        end
 
-        opts = Slop.parse!(args) do |opt|
-          opt.on :s, :start, "Start line (defaults to start of file)Line 1 is the first line.", true, :as => Integer do |line|
-            start_line = line - 1
+        def options(opt)
+          opt.on :m, :method, "Save a method's source.", true do |meth_name|
+            meth = get_method_or_raise(meth_name, target, {})
+            self.content << meth.source
+          end
+          opt.on :c, :command, "Save a command's source.", true do |command_name|
+            command = find_command(command_name)
+            block = Pry::Method.new(find_command(command_name).block)
+            self.content << block.source
+          end
+          opt.on :f, :file, "Save a file.", true do |file|
+            self.content << File.read(File.expand_path(file))
           end
+          opt.on :l, :lines, "Only save a subset of lines.", :optional => true, :as => Range, :default => 1..-1
+          opt.on :i, :in, "Save entries from Pry's input expression history. Takes an index or range.", :optional => true,
+          :as => Range, :default => -5..-1 do |range|
+            input_expressions = _pry_.input_array[range] || []
+            Array(input_expressions).each { |v| self.content << v }
+          end
+          opt.on :a, :append, "Append to the given file instead of overwriting it."
+        end
 
-          opt.on :e, :end, "End line (defaults to end of file). Line -1 is the last line", true, :as => Integer do |line|
-            end_line = line - 1
+        def process
+          if args.empty?
+            raise CommandError, "Must specify a file name."
           end
 
-          opt.on :ex, "Show a window of N lines either side of the last exception (defaults to 5).", :optional => true, :as => Integer do |bt_index_arg|
-            window_size = Pry.config.exception_window_size || 5
-            ex = _pry_.last_exception
-            next if !ex
-            if bt_index_arg
-              bt_index = bt_index_arg
-            else
-              bt_index = ex.bt_index
-            end
-            ex.bt_index = (bt_index + 1) % ex.backtrace.size
-
-            ex_file, ex_line = ex.bt_source_location_for(bt_index)
-            start_line = (ex_line - 1) - window_size
-            start_line = start_line < 0 ? 0 : start_line
-            end_line = (ex_line - 1) + window_size
-            if ex_file && RbxPath.is_core_path?(ex_file)
-              file_name = RbxPath.convert_path_to_full(ex_file)
+          self.file_name = File.expand_path(args.first)
+
+          save_file
+        end
+
+        def save_file
+          if self.content.empty?
+            raise CommandError, "Found no code to save."
+          end
+
+          File.open(file_name, mode) do |f|
+            if opts.present?(:lines)
+              f.puts restrict_to_lines(content, opts[:l])
             else
-              file_name = ex_file
+              f.puts content
             end
           end
+        end
 
-          opt.on :l, "line-numbers", "Show line numbers."
-          opt.on :t, :type, "The specific file type for syntax higlighting (e.g ruby, python)", true, :as => Symbol
-          opt.on :f, :flood, "Do not use a pager to view text longer than one screen."
-          opt.on :h, :help, "This message." do
-            output.puts opt
+        def mode
+          if opts.present?(:append)
+            "a"
+          else
+            "w"
           end
         end
+      end
 
-        next if opts.help?
+      create_command "cat", "Show code from a file, Pry's input buffer, or the last exception." do
+        banner <<-USAGE
+          Usage: cat FILE
+                 cat --ex [STACK_INDEX]
+                 cat --in [INPUT_INDEX_OR_RANGE]
 
-        if opts.ex?
-          if file_name.nil?
-            raise CommandError, "No Exception or Exception has no associated file."
-          end
-        else
-          file_name = args.shift
-        end
+          cat is capable of showing part or all of a source file, the context of the
+          last exception, or an expression from Pry's input history.
+
+          cat --ex defaults to showing the lines surrounding the location of the last
+          exception. Invoking it more than once travels up the exception's backtrace,
+          and providing a number shows the context of the given index of the backtrace.
+        USAGE
 
-        if !file_name
-          raise CommandError, "Must provide a file name."
+        def options(opt)
+          opt.on :ex,        "Show the context of the last exception.", :optional => true, :as => Integer
+          opt.on :i, :in,    "Show one or more entries from Pry's expression history.", :optional => true, :as => Range, :default => -5..-1
+
+          opt.on :s, :start, "Starting line (defaults to the first line).", :optional => true, :as => Integer
+          opt.on :e, :end,   "Ending line (defaults to the last line).", :optional => true, :as => Integer
+          opt.on :l, :'line-numbers', "Show line numbers."
+          opt.on :t, :type,  "The file type for syntax highlighting (e.g., 'ruby' or 'python').", true, :as => Symbol
+
+          opt.on :f, :flood, "Do not use a pager to view text longer than one screen."
         end
 
-        begin
-          contents, _, _ = read_between_the_lines(file_name, start_line, end_line)
-          contents = syntax_highlight_by_file_type_or_specified(contents, file_name, opts[:type])
-        rescue Errno::ENOENT
-          raise CommandError, "Could not find file: #{file_name}"
+        def process
+          handler = case
+            when opts.present?(:ex)
+              method :process_ex
+            when opts.present?(:in)
+              method :process_in
+            else
+              method :process_file
+            end
+
+          output = handler.call do |code|
+            code.code_type = opts[:type] || :ruby
+
+            code.between(opts[:start] || 1, opts[:end] || -1).
+              with_line_numbers(opts.present?(:'line-numbers') || opts.present?(:ex))
+          end
+
+          render_output(output, opts)
         end
 
-        if opts.l?
-          contents = text.with_line_numbers contents, start_line + 1
+        def process_ex
+          window_size = Pry.config.default_window_size || 5
+          ex = _pry_.last_exception
+
+          raise CommandError, "No exception found." unless ex
+
+          if opts[:ex].nil?
+            bt_index = ex.bt_index
+            ex.inc_bt_index
+          else
+            bt_index = opts[:ex]
+          end
+
+          ex_file, ex_line = ex.bt_source_location_for(bt_index)
+
+          raise CommandError, "The given backtrace level is out of bounds." unless ex_file
+
+          if RbxPath.is_core_path?(ex_file)
+            ex_file = RbxPath.convert_path_to_full(ex_file)
+          end
+
+          set_file_and_dir_locals(ex_file)
+
+          start_line = ex_line - window_size
+          start_line = 1 if start_line < 1
+          end_line = ex_line + window_size
+
+          header = unindent <<-HEADER
+            #{text.bold 'Exception:'} #{ex.class}: #{ex.message}
+            --
+            #{text.bold('From:')} #{ex_file} @ line #{ex_line} @ #{text.bold("level: #{bt_index}")} of backtrace (of #{ex.backtrace.size - 1}).
+
+          HEADER
+
+          code = yield(Pry::Code.from_file(ex_file).
+                         between(start_line, end_line).
+                         with_marker(ex_line))
+
+          "#{header}#{code}"
         end
 
-        # add the arrow pointing to line that caused the exception
-        if opts.ex?
-          ex_file, ex_line = _pry_.last_exception.bt_source_location_for(bt_index)
-          contents = text.with_line_numbers contents, start_line + 1, :bright_red
+        def process_in
+          normalized_range = absolute_index_range(opts[:i], _pry_.input_array.length)
+          input_items = _pry_.input_array[normalized_range] || []
 
-          contents = contents.lines.each_with_index.map do |line, idx|
-            l = idx + start_line
-            if l == (ex_line - 1)
-              " =>#{line}"
-            else
-              "   #{line}"
+          zipped_items = normalized_range.zip(input_items).reject { |_, s| s.nil? || s == "" }
+
+          unless zipped_items.length > 0
+            raise CommandError, "No expressions found."
+          end
+
+          if zipped_items.length > 1
+            contents = ""
+            zipped_items.each do |i, s|
+              contents << "#{text.bold(i.to_s)}:\n"
+              contents << yield(Pry::Code(s).with_indentation(2)).to_s
             end
-          end.join
+          else
+            contents = yield(Pry::Code(zipped_items.first.last))
+          end
 
-          # header for exceptions
-          output.puts "\n#{Pry::Helpers::Text.bold('Exception:')} #{_pry_.last_exception.class}: #{_pry_.last_exception.message}\n--"
-          output.puts "#{Pry::Helpers::Text.bold('From:')} #{ex_file} @ line #{ex_line} @ #{text.bold('level: ')} #{bt_index} of backtrace (of #{_pry_.last_exception.backtrace.size - 1}).\n\n"
+          contents
         end
 
-        set_file_and_dir_locals(file_name)
+        def process_file
+          file_name = args.shift
+
+          unless file_name
+            raise CommandError, "Must provide a filename, --in, or --ex."
+          end
+
+          file_name, line_num = file_name.split(':')
+          file_name = File.expand_path(file_name)
+          set_file_and_dir_locals(file_name)
 
-        if opts.f?
-          output.puts contents
-        else
-          stagger_output(contents)
+          code = yield(Pry::Code.from_file(file_name))
+
+          if line_num
+            code = code.around(line_num.to_i,
+                               Pry.config.default_window_size || 7)
+          end
+
+          code
         end
       end
     end

data/lib/pry/helpers/base_helpers.rb

@@ -91,14 +91,19 @@ class Pry
         27
       end
 
+      # have fun on the Windows platform.
+      def windows?
+        RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+      end
+
       # are we on Jruby platform?
       def jruby?
-        defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /jruby/
+        RbConfig::CONFIG['ruby_install_name'] == 'jruby'
       end
 
       # are we on rbx platform?
       def rbx?
-       defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /rbx/
+        RbConfig::CONFIG['ruby_install_name'] == 'rbx'
       end
 
       # a simple pager for systems without `less`. A la windows.

data/lib/pry/helpers/command_helpers.rb

@@ -6,26 +6,21 @@ class Pry
 
       module_function
 
-      # if start_line is not false then add line numbers starting with start_line
-      def render_output(should_flood, start_line, text, color=:blue)
-        if start_line
-          text = Pry::Helpers::Text.with_line_numbers text, start_line, color
-        end
-
-        if should_flood
-          output.puts text
-        else
-          stagger_output(text)
-        end
-      end
-
       # Open a temp file and yield it to the block, closing it after
       # @return [String] The path of the temp file
-      def temp_file
-        file = Tempfile.new(["tmp", ".rb"])
+      def temp_file(ext='.rb')
+        file = Tempfile.new(['pry', ext])
         yield file
       ensure
-        file.close
+        file.close(true) if file
+      end
+
+      def render_output(str, opts={})
+        if opts[:flood]
+          output.puts str
+        else
+          stagger_output str
+        end
       end
 
       def get_method_or_raise(name, target, opts={}, omit_help=false)
@@ -34,14 +29,14 @@ class Pry
         if name && !meth
           command_error("The method '#{name}' could not be found.", omit_help)
         elsif !meth
-          command_error("No method name given, and context is not a method.", omit_help)
+          command_error("No method name given, and context is not a method.", omit_help, NonMethodContextError)
         end
 
         (opts[:super] || 0).times do
           if meth.super
             meth = meth.super
           else
-            command_error("The method '#{meth.name}' is not defined in a superclass of '#{class_name(meth.owner)}'.", omit_help)
+            command_error("'#{meth.name_with_owner}' has no super method.", omit_help)
           end
         end
 
@@ -49,9 +44,9 @@ class Pry
         meth
       end
 
-      def command_error(message, omit_help)
+      def command_error(message, omit_help, klass=CommandError)
         message += " Type `#{command_name} --help` for help." unless omit_help
-        raise CommandError, message
+        raise klass, message
       end
 
       def make_header(meth, content=meth.source)
@@ -66,60 +61,6 @@ class Pry
         header << "#{Pry::Helpers::Text.bold("Number of lines:")} #{content.each_line.count.to_s}\n"
       end
 
-      def file_map
-        {
-          [".c", ".h"] => :c,
-          [".cpp", ".hpp", ".cc", ".h", "cxx"] => :cpp,
-          [".rb", "Rakefile", ".irbrc", ".gemspec", ".pryrc"] => :ruby,
-          ".py" => :python,
-          ".diff" => :diff,
-          ".css" => :css,
-          ".html" => :html,
-          [".yaml", ".yml"] => :yaml,
-          ".xml" => :xml,
-          ".php" => :php,
-          ".js" => :javascript,
-          ".java" => :java,
-          ".rhtml" => :rhtml,
-          ".json" => :json
-        }
-      end
-
-      def syntax_highlight_by_file_type_or_specified(contents, file_name, file_type)
-        _, language_detected = file_map.find do |k, v|
-          Array(k).any? do |matcher|
-            matcher == File.extname(file_name) || matcher == File.basename(file_name)
-          end
-        end
-
-        language_detected = file_type if file_type
-        if Pry.color
-          CodeRay.scan(contents, language_detected).term
-        else
-          contents
-        end
-      end
-
-      # convert negative line numbers to positive by wrapping around
-      # last line (as per array indexing with negative numbers)
-      def normalized_line_number(line_number, total_lines)
-        line_number < 0 ? line_number + total_lines : line_number
-      end
-
-      # returns the file content between the lines and the normalized
-      # start and end line numbers.
-      def read_between_the_lines(file_name, start_line, end_line)
-        if file_name == Pry.eval_path
-          content = Pry.line_buffer.drop(1).join
-        else
-          content = File.read(File.expand_path(file_name))
-        end
-        lines_array = content.each_line.to_a
-
-        [lines_array[start_line..end_line].join, normalized_line_number(start_line, lines_array.size),
-         normalized_line_number(end_line, lines_array.size)]
-      end
-
       def process_rdoc(comment, code_type)
         comment = comment.dup
         comment.gsub(/<code>(?:\s*\n)?(.*?)\s*<\/code>/m) { Pry.color ? CodeRay.scan($1, code_type).term : $1 }.
@@ -157,6 +98,7 @@ class Pry
       end
 
       def invoke_editor(file, line)
+        raise CommandError, "Please set Pry.config.editor or export $EDITOR" unless Pry.config.editor
         if Pry.config.editor.respond_to?(:call)
           editor_invocation = Pry.config.editor.call(file, line)
         else
@@ -176,14 +118,16 @@ class Pry
           # Note we dont want to use Pry.config.system here as that
           # may be invoked non-interactively (i.e via Open4), whereas we want to
           # ensure the editor is always interactive
-          system(editor_invocation)
+          system(editor_invocation) or raise CommandError, "`#{editor_invocation}` gave exit status: #{$?.exitstatus}"
         end
       end
 
       # Return the syntax for a given editor for starting the editor
       # and moving to a particular line within that file
       def start_line_syntax_for_editor(file_name, line_number)
-        file_name = file_name.gsub(/\//, '\\') if RUBY_PLATFORM =~ /mswin|mingw/
+        if windows?
+          file_name = file_name.gsub(/\//, '\\')
+        end
 
         # special case for 1st line
         return file_name if line_number <= 1
@@ -198,7 +142,7 @@ class Pry
         when /^jedit/
           "#{file_name} +line:#{line_number}"
         else
-          if RUBY_PLATFORM =~ /mswin|mingw/
+          if windows?
             "#{file_name}"
           else
             "+#{line_number} #{file_name}"
@@ -247,6 +191,56 @@ class Pry
         text.gsub(/^#{margin}/, '')
       end
 
+      # Restrict a string to the given range of lines (1-indexed)
+      # @param [String] content The string.
+      # @param [Range, Fixnum] lines The line(s) to restrict it to.
+      # @return [String] The resulting string.
+      def restrict_to_lines(content, lines)
+        line_range = one_index_range_or_number(lines)
+        Array(content.lines.to_a[line_range]).join
+      end
+
+      def one_index_number(line_number)
+        if line_number > 0
+          line_number - 1
+        else
+          line_number
+        end
+      end
+
+      # convert a 1-index range to a 0-indexed one
+      def one_index_range(range)
+        Range.new(one_index_number(range.begin), one_index_number(range.end))
+      end
+
+      def one_index_range_or_number(range_or_number)
+        case range_or_number
+        when Range
+          one_index_range(range_or_number)
+        else
+          one_index_number(range_or_number)
+        end
+      end
+
+      def absolute_index_number(line_number, array_length)
+        if line_number >= 0
+          line_number
+        else
+          [array_length + line_number, 0].max
+        end
+      end
+
+      def absolute_index_range(range_or_number, array_length)
+        case range_or_number
+        when Range
+          a = absolute_index_number(range_or_number.begin, array_length)
+          b = absolute_index_number(range_or_number.end, array_length)
+        else
+          a = b = absolute_index_number(range_or_number, array_length)
+        end
+
+        Range.new(a, b)
+      end
     end
 
   end