pry 0.9.10pre1-i386-mingw32 → 0.9.11-i386-mingw32

data/lib/pry/commands/edit.rb

@@ -0,0 +1,206 @@
+class Pry
+  class Command::Edit < Pry::ClassCommand
+    require 'pry/commands/edit/method_patcher'
+    require 'pry/commands/edit/exception_patcher'
+    require 'pry/commands/edit/file_and_line_locator'
+
+    match 'edit'
+    group 'Editing'
+    description 'Invoke the default editor on a file.'
+
+    banner <<-'BANNER'
+      Usage: edit [--no-reload|--reload|--patch] [--line LINE] [--temp|--ex|FILE[:LINE]|OBJECT|--in N]
+
+      Open a text editor. When no FILE is given, edits the pry input buffer. Ensure
+      `Pry.config.editor` is set to your editor of choice.
+
+      edit sample.rb                edit -p MyClass#my_method
+      edit sample.rb --line 105     edit YourClass
+      edit MyClass#my_method        edit --ex
+      edit --method                 edit --ex -p
+
+      https://github.com/pry/pry/wiki/Editor-integration#wiki-Edit_command
+    BANNER
+
+    def options(opt)
+      opt.on :e, :ex,      "Open the file that raised the most recent exception (_ex_.file)",
+                           :optional_argument => true, :as => Integer
+      opt.on :i, :in,      "Open a temporary file containing the Nth input expression. N may be a range",
+                           :optional_argument => true, :as => Range, :default => -1..-1
+      opt.on :t, :temp,    "Open an empty temporary file"
+      opt.on :l, :line,    "Jump to this line in the opened file",
+                           :argument => true, :as => Integer
+      opt.on :n, :"no-reload", "Don't automatically reload the edited code"
+      opt.on :c, :current, "Open the current __FILE__ and at __LINE__ (as returned by `whereami`)"
+      opt.on :r, :reload,  "Reload the edited code immediately (default for ruby files)"
+      opt.on :p, :patch,   "Instead of editing the object's file, try to edit in a tempfile and apply as a monkey patch"
+      opt.on :m, :method,  "Explicitly edit the _current_ method (when inside a method context)."
+    end
+
+    def process
+      if bad_option_combination?
+        raise CommandError, "Only one of --ex, --temp, --in, --method and FILE may be specified."
+      end
+
+      if repl_edit?
+        # code defined in pry, eval'd within pry.
+        repl_edit
+      elsif runtime_patch?
+        # patch code without persisting changes
+        apply_runtime_patch
+      else
+        # code stored in actual files, eval'd at top-level
+        file_edit
+      end
+    end
+
+    def repl_edit?
+      !opts.present?(:ex) && !opts.present?(:current) && !opts.present?(:method) &&
+        filename_argument.empty?
+    end
+
+    def repl_edit
+      content = Pry::Editor.edit_tempfile_with_content(initial_temp_file_content,
+                                                       initial_temp_file_content.lines.count)
+      if repl_reload?
+        silence_warnings do
+          eval_string.replace content
+        end
+      end
+    end
+
+    def file_based_exception?
+      opts.present?(:ex) && !opts.present?(:patch)
+    end
+
+    def runtime_patch?
+       !file_based_exception? && (opts.present?(:patch) || pry_method?(code_object))
+    end
+
+    def apply_runtime_patch
+      if patch_exception?
+        ExceptionPatcher.new(_pry_, state, file_and_line_for_current_exception).perform_patch
+      else
+        if code_object.is_a?(Pry::Method)
+          MethodPatcher.new(_pry_, code_object).perform_patch
+        else
+          raise NotImplementedError, "Cannot yet patch #{code_object} objects!"
+        end
+      end
+    end
+
+    def ensure_file_name_is_valid(file_name)
+      raise CommandError, "Cannot find a valid file for #{filename_argument}" if !file_name
+      raise CommandError, "#{file_name} is not a valid file name, cannot edit!" if not_a_real_file?(file_name)
+    end
+
+    def file_and_line_for_current_exception
+      FileAndLineLocator.from_exception(_pry_.last_exception, opts[:ex].to_i)
+    end
+
+    def file_and_line
+      file_name, line = if opts.present?(:current)
+                          FileAndLineLocator.from_binding(target)
+                        elsif opts.present?(:ex)
+                          file_and_line_for_current_exception
+                        elsif code_object
+                          FileAndLineLocator.from_code_object(code_object, filename_argument)
+                        else
+                          # when file and line are passed as a single arg, e.g my_file.rb:30
+                          FileAndLineLocator.from_filename_argument(filename_argument)
+                        end
+
+      [file_name, opts.present?(:line) ? opts[:l].to_i : line]
+    end
+
+    def file_edit
+      file_name, line = file_and_line
+
+      ensure_file_name_is_valid(file_name)
+
+      Pry::Editor.invoke_editor(file_name, line, reload?(file_name))
+      set_file_and_dir_locals(file_name)
+
+      if reload?(file_name)
+        silence_warnings do
+          TOPLEVEL_BINDING.eval(File.read(file_name), file_name)
+        end
+      end
+    end
+
+    def filename_argument
+      args.join(' ')
+    end
+
+    def code_object
+      @code_object ||= !probably_a_file?(filename_argument) &&
+        Pry::CodeObject.lookup(filename_argument, _pry_)
+    end
+
+    def pry_method?(code_object)
+      code_object.is_a?(Pry::Method) &&
+        code_object.pry_method?
+    end
+
+    def patch_exception?
+      opts.present?(:ex) && opts.present?(:patch)
+    end
+
+    def bad_option_combination?
+      [opts.present?(:ex), opts.present?(:temp),
+       opts.present?(:in), opts.present?(:method), !filename_argument.empty?].count(true) > 1
+    end
+
+    def input_expression
+      case opts[:i]
+      when Range
+        (_pry_.input_array[opts[:i]] || []).join
+      when Fixnum
+        _pry_.input_array[opts[:i]] || ""
+      else
+        raise Pry::CommandError, "Not a valid range: #{opts[:i]}"
+      end
+    end
+
+    def reloadable?
+      opts.present?(:reload) || opts.present?(:ex)
+    end
+
+    def never_reload?
+      opts.present?(:'no-reload') || Pry.config.disable_auto_reload
+    end
+
+    # conditions much less strict than for reload? (which is for file-based reloads)
+    def repl_reload?
+      !never_reload?
+    end
+
+    def reload?(file_name="")
+      (reloadable? || file_name.end_with?(".rb")) && !never_reload?
+    end
+
+    def initial_temp_file_content
+      case
+      when opts.present?(:temp)
+        ""
+      when opts.present?(:in)
+        input_expression
+      when eval_string.strip != ""
+        eval_string
+      else
+        _pry_.input_array.reverse_each.find { |x| x && x.strip != "" } || ""
+      end
+    end
+
+    def probably_a_file?(str)
+      [".rb", ".c", ".py", ".yml", ".gemspec"].include? File.extname(str) ||
+        str =~ /\/|\\/
+    end
+
+    def complete(search)
+      super + Bond::Rc.files(search.split(" ").last || '')
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::Edit)
+end

data/lib/pry/commands/edit/exception_patcher.rb

@@ -0,0 +1,25 @@
+class Pry
+  class Command::Edit
+    class ExceptionPatcher
+      attr_accessor :_pry_
+      attr_accessor :state
+      attr_accessor :file_and_line
+
+      def initialize(_pry_, state, exception_file_and_line)
+        @_pry_ = _pry_
+        @state = state
+        @file_and_line = exception_file_and_line
+      end
+
+      # perform the patch
+      def perform_patch
+        file_name, line = file_and_line
+        lines = state.dynamical_ex_file || File.read(file_name)
+
+        source = Pry::Editor.edit_tempfile_with_content(lines)
+        _pry_.evaluate_ruby source
+        state.dynamical_ex_file = source.split("\n")
+      end
+    end
+  end
+end

data/lib/pry/commands/edit/file_and_line_locator.rb

@@ -0,0 +1,38 @@
+class Pry
+  class Command::Edit
+    module FileAndLineLocator
+      class << self
+        def from_binding(target)
+          [target.eval("__FILE__"), target.eval("__LINE__")]
+        end
+
+        def from_code_object(code_object, filename_argument)
+          if File.exists?(code_object.source_file.to_s)
+            [code_object.source_file, code_object.source_line]
+          else
+            raise CommandError, "Cannot find a file for #{filename_argument}!"
+          end
+        end
+
+        def from_exception(exception, backtrace_level)
+          raise CommandError, "No exception found." if exception.nil?
+
+          file_name, line = exception.bt_source_location_for(backtrace_level)
+          raise CommandError, "Exception has no associated file." if file_name.nil?
+          raise CommandError, "Cannot edit exceptions raised in REPL." if Pry.eval_path == file_name
+
+          file_name = RbxPath.convert_path_to_full(file_name) if RbxPath.is_core_path?(file_name)
+
+          [file_name, line]
+        end
+
+        # when file and line are passed as a single arg, e.g my_file.rb:30
+        def from_filename_argument(filename_argument)
+          f = File.expand_path(filename_argument)
+          l = f.sub!(/:(\d+)$/, "") ? $1.to_i : 1
+          [f, l]
+        end
+      end
+    end
+  end
+end

data/lib/pry/commands/edit/method_patcher.rb

@@ -0,0 +1,122 @@
+class Pry
+  class Command::Edit
+    class MethodPatcher
+      attr_accessor :_pry_
+      attr_accessor :code_object
+
+      def initialize(_pry_, code_object)
+        @_pry_ = _pry_
+        @code_object = code_object
+      end
+
+      # perform the patch
+      def perform_patch
+        if code_object.alias?
+          with_method_transaction do
+            _pry_.evaluate_ruby patched_code
+          end
+        else
+          _pry_.evaluate_ruby patched_code
+        end
+      end
+
+      private
+
+      def patched_code
+        @patched_code ||= wrap(Pry::Editor.edit_tempfile_with_content(adjusted_lines))
+      end
+
+      # The method code adjusted so that the first line is rewritten
+      # so that def self.foo --> def foo
+      def adjusted_lines
+        lines = code_object.source.lines.to_a
+        lines[0] = definition_line_for_owner(lines.first)
+        lines
+      end
+
+      # Run some code ensuring that at the end target#meth_name will not have changed.
+      #
+      # When we're redefining aliased methods we will overwrite the method at the
+      # unaliased name (so that super continues to work). By wrapping that code in a
+      # transation we make that not happen, which means that alias_method_chains, etc.
+      # continue to work.
+      #
+      # @param [String] meth_name  The method name before aliasing
+      # @param [Module] target  The owner of the method
+
+      def with_method_transaction
+        temp_name = "__pry_#{code_object.original_name}__"
+        co = code_object
+        code_object.owner.class_eval do
+          alias_method temp_name, co.original_name
+          yield
+          alias_method co.name, co.original_name
+          alias_method co.original_name, temp_name
+        end
+
+      ensure
+        co.send(:remove_method, temp_name) rescue nil
+      end
+
+      # Update the definition line so that it can be eval'd directly on the Method's
+      # owner instead of from the original context.
+      #
+      # In particular this takes `def self.foo` and turns it into `def foo` so that we
+      # don't end up creating the method on the singleton class of the singleton class
+      # by accident.
+      #
+      # This is necessarily done by String manipulation because we can't find out what
+      # syntax is needed for the argument list by ruby-level introspection.
+      #
+      # @param String   The original definition line. e.g. def self.foo(bar, baz=1)
+      # @return String  The new definition line. e.g. def foo(bar, baz=1)
+      def definition_line_for_owner(line)
+        if line =~ /^def (?:.*?\.)?#{Regexp.escape(code_object.original_name)}(?=[\(\s;]|$)/
+          "def #{code_object.original_name}#{$'}"
+        else
+          raise CommandError, "Could not find original `def #{code_object.original_name}` line to patch."
+        end
+      end
+
+      # Apply wrap_for_owner and wrap_for_nesting successively to `source`
+      # @param [String] source
+      # @return [String] The wrapped source.
+      def wrap(source)
+        wrap_for_nesting(wrap_for_owner(source))
+      end
+
+      # Update the source code so that when it has the right owner when eval'd.
+      #
+      # This (combined with definition_line_for_owner) is backup for the case that
+      # wrap_for_nesting fails, to ensure that the method will stil be defined in
+      # the correct place.
+      #
+      # @param [String] source  The source to wrap
+      # @return [String]
+      def wrap_for_owner(source)
+        Pry.current[:pry_owner] = code_object.owner
+        "Pry.current[:pry_owner].class_eval do\n#{source}\nend"
+      end
+
+      # Update the new source code to have the correct Module.nesting.
+      #
+      # This method uses syntactic analysis of the original source file to determine
+      # the new nesting, so that we can tell the difference between:
+      #
+      #   class A; def self.b; end; end
+      #   class << A; def b; end; end
+      #
+      # The resulting code should be evaluated in the TOPLEVEL_BINDING.
+      #
+      # @param [String] source  The source to wrap.
+      # @return [String]
+      def wrap_for_nesting(source)
+        nesting = Pry::Code.from_file(code_object.source_file).nesting_at(code_object.source_line)
+
+        (nesting + [source] + nesting.map{ "end" } + [""]).join("\n")
+      rescue Pry::Indent::UnparseableNestingError => e
+        source
+      end
+    end
+  end
+end

data/lib/pry/commands/exit.rb

@@ -0,0 +1,42 @@
+class Pry
+  class Command::Exit < Pry::ClassCommand
+    match 'exit'
+    group 'Navigating Pry'
+    description 'Pop the previous binding.'
+    command_options :keep_retval => true
+
+    banner <<-'BANNER'
+      Usage:   exit [OPTIONS] [--help]
+      Aliases: quit
+
+      Pop the previous binding (does NOT exit program). It can be useful to exit a
+      context with a user-provided value. For instance an exit value can be used to
+      determine program flow.
+
+      exit "pry this"
+      exit
+
+      https://github.com/pry/pry/wiki/State-navigation#wiki-Exit_with_value
+    BANNER
+
+    def process
+      if _pry_.binding_stack.one?
+        _pry_.run_command "exit-all #{arg_string}"
+      else
+        # otherwise just pop a binding and return user supplied value
+        process_pop_and_return
+      end
+    end
+
+    def process_pop_and_return
+      popped_object = _pry_.binding_stack.pop.eval('self')
+
+      # return a user-specified value if given otherwise return the object
+      return target.eval(arg_string) unless arg_string.empty?
+      popped_object
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::Exit)
+  Pry::Commands.alias_command 'quit', 'exit'
+end

data/lib/pry/commands/exit_all.rb

@@ -0,0 +1,29 @@
+class Pry
+  class Command::ExitAll < Pry::ClassCommand
+    match 'exit-all'
+    group 'Navigating Pry'
+    description 'End the current Pry session.'
+
+    banner <<-'BANNER'
+      Usage:   exit-all [--help]
+      Aliases: !!@
+
+      End the current Pry session (popping all bindings and returning to caller).
+      Accepts optional return value.
+    BANNER
+
+    def process
+      # calculate user-given value
+      exit_value = target.eval(arg_string)
+
+      # clear the binding stack
+      _pry_.binding_stack.clear
+
+      # break out of the repl loop
+      throw(:breakout, exit_value)
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::ExitAll)
+  Pry::Commands.alias_command '!!@', 'exit-all'
+end