From 68758e49ab9073561db02a985878c3f7e1d63fcd Mon Sep 17 00:00:00 2001 From: John Mair Date: Tue, 1 Jan 2013 01:25:43 +0100 Subject: [PATCH] be brave, fully remove the 'edit-method' command All functionality has been successfully moved to 'edit' command, with all tests passing. --- lib/pry/commands/edit/method_patcher.rb | 4 +- lib/pry/commands/edit_method.rb | 171 ------------- spec/commands/edit_method_spec.rb | 299 ----------------------- spec/commands/edit_spec.rb | 310 +++++++++++++++++++++++- 4 files changed, 310 insertions(+), 474 deletions(-) delete mode 100644 lib/pry/commands/edit_method.rb delete mode 100644 spec/commands/edit_method_spec.rb diff --git a/lib/pry/commands/edit/method_patcher.rb b/lib/pry/commands/edit/method_patcher.rb index 9359efad..3edc6ebb 100644 --- a/lib/pry/commands/edit/method_patcher.rb +++ b/lib/pry/commands/edit/method_patcher.rb @@ -18,7 +18,7 @@ class Pry if method_object.alias? with_method_transaction do _pry_.evaluate_ruby source - Pry.binding_for(method_object.owner).eval("alias #{method_object.name} #{original_name}") + Pry.binding_for(method_object.owner).eval("alias #{method_object.name} #{method_object.original_name}") end else _pry_.evaluate_ruby source @@ -45,7 +45,7 @@ class Pry # @param [String] meth_name The method name before aliasing # @param [Module] target The owner of the method def with_method_transaction - target = Pry.binding_for(target) + target = Pry.binding_for(method_object.owner) temp_name = "__pry_#{method_object.original_name}__" target.eval("alias #{temp_name} #{method_object.original_name}") diff --git a/lib/pry/commands/edit_method.rb b/lib/pry/commands/edit_method.rb deleted file mode 100644 index 5ed841cd..00000000 --- a/lib/pry/commands/edit_method.rb +++ /dev/null @@ -1,171 +0,0 @@ -class Pry - class Command::EditMethod < Pry::ClassCommand - match 'edit-method' - group 'Editing' - description 'Edit the source code for a method.' - - banner <<-BANNER - Usage: edit-method [OPTIONS] [METH] - - Edit the method METH in an editor. - Ensure Pry.config.editor is set to your editor of choice. - - e.g: `edit-method hello_method` - e.g: `edit-method Pry#rep` - e.g: `edit-method` - - https://github.com/pry/pry/wiki/Editor-integration#wiki-Edit_method - BANNER - - command_options :shellwords => false - - def options(opt) - method_options(opt) - opt.on :n, "no-reload", "Do not automatically reload the method's file after editing." - opt.on "no-jump", "Do not fast forward editor to first line of method." - opt.on :p, :patch, "Instead of editing the method's file, try to edit in a tempfile and apply as a monkey patch." - end - - def process - begin - @method = method_object - rescue MethodNotFound => err - end - - if opts.present?(:patch) || (@method && @method.dynamically_defined?) - if err - raise err # can't patch a non-method - end - - process_patch - else - if err && !File.exist?(target.eval('__FILE__')) - raise err # can't edit a non-file - end - - process_file - end - end - - def process_patch - lines = @method.source.lines.to_a - lines[0] = definition_line_for_owner(lines[0]) - - source = wrap_for_nesting(wrap_for_owner(Pry::Editor.edit_tempfile_with_content(lines))) - - if @method.alias? - with_method_transaction(original_name, @method.owner) do - _pry_.evaluate_ruby source - Pry.binding_for(@method.owner).eval("alias #{@method.name} #{original_name}") - end - else - _pry_.evaluate_ruby source - end - end - - def process_file - file, line = extract_file_and_line - - reload = !opts.present?(:'no-reload') && !Pry.config.disable_auto_reload - Pry::Editor.invoke_editor(file, opts["no-jump"] ? 0 : line, reload) - silence_warnings do - load file if reload - end - end - - protected - def extract_file_and_line - if @method - if @method.source_type == :c - raise CommandError, "Can't edit a C method." - else - [@method.source_file, @method.source_line] - end - else - [target.eval('__FILE__'), target.eval('__LINE__')] - end - 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(meth_name, target) - target = Pry.binding_for(target) - temp_name = "__pry_#{meth_name}__" - - target.eval("alias #{temp_name} #{meth_name}") - yield - target.eval("alias #{meth_name} #{temp_name}") - ensure - target.eval("undef #{temp_name}") rescue nil - end - - # The original name of the method, if it's not present raise an error telling - # the user why we don't work. - # - def original_name - @method.original_name or raise CommandError, "Pry can only patch methods created with the `def` keyword." - 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(original_name)}(?=[\(\s;]|$)/ - "def #{original_name}#{$'}" - else - raise CommandError, "Could not find original `def #{original_name}` line to patch." - end - 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) - Thread.current[:__pry_owner__] = @method.owner - source = "Thread.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(@method.source_file).nesting_at(@method.source_line) - - (nesting + [source] + nesting.map{ "end" } + [""]).join("\n") - rescue Pry::Indent::UnparseableNestingError => e - source - end - end - - Pry::Commands.add_command(Pry::Command::EditMethod) -end diff --git a/spec/commands/edit_method_spec.rb b/spec/commands/edit_method_spec.rb deleted file mode 100644 index d8333b59..00000000 --- a/spec/commands/edit_method_spec.rb +++ /dev/null @@ -1,299 +0,0 @@ -require 'helper' - -describe "edit-method" do - describe "on a method defined in a file" do - before do - @tempfile = Tempfile.new(['pry', '*.rb']) - @tempfile.puts <<-EOS - module A - def a - :yup - end - - def b - :kinda - end - end - - class X - include A - - def self.x - :double_yup - end - - def x - :nope - end - - def b - super - end - alias c b - - def y? - :because - end - - class B - G = :nawt - - def foo - :possibly - G - end - end - end - EOS - @tempfile.flush - load @tempfile.path - end - - after do - @tempfile.close(true) - end - - describe 'without -p' do - before do - @old_editor = Pry.config.editor - @file = @line = @contents = nil - Pry.config.editor = lambda do |file, line| - @file = file; @line = line - nil - end - end - after do - Pry.config.editor = @old_editor - end - - it "should correctly find a class method" do - pry_eval 'edit-method X.x' - @file.should == @tempfile.path - @line.should == 14 - end - - it "should correctly find an instance method" do - pry_eval 'edit-method X#x' - @file.should == @tempfile.path - @line.should == 18 - end - - it "should correctly find a method on an instance" do - pry_eval 'x = X.new', 'edit-method x.x' - @file.should == @tempfile.path - @line.should == 18 - end - - it "should correctly find a method from a module" do - pry_eval 'edit-method X#a' - @file.should == @tempfile.path - @line.should == 2 - end - - it "should correctly find an aliased method" do - pry_eval 'edit-method X#c' - @file.should == @tempfile.path - @line.should == 22 - end - end - - describe 'with -p' do - before do - @old_editor = Pry.config.editor - Pry.config.editor = lambda do |file, line| - lines = File.read(file).lines.to_a - lines[1] = ":maybe\n" - File.open(file, 'w') do |f| - f.write(lines.join) - end - @patched_def = String(lines[1]).chomp - nil - end - end - - after do - Pry.config.editor = @old_editor - end - - it "should successfully replace a class method" do - pry_eval 'edit-method -p X.x' - - class << X - X.method(:x).owner.should == self - end - X.method(:x).receiver.should == X - X.x.should == :maybe - end - - it "should successfully replace an instance method" do - pry_eval 'edit-method -p X#x' - - X.instance_method(:x).owner.should == X - X.new.x.should == :maybe - end - - it "should successfully replace a method on an instance" do - pry_eval 'instance = X.new', 'edit-method -p instance.x' - - instance = X.new - instance.method(:x).owner.should == X - instance.x.should == :maybe - end - - it "should successfully replace a method from a module" do - pry_eval 'edit-method -p X#a' - - X.instance_method(:a).owner.should == A - X.new.a.should == :maybe - end - - it "should successfully replace a method with a question mark" do - pry_eval 'edit-method -p X#y?' - - X.instance_method(:y?).owner.should == X - X.new.y?.should == :maybe - end - - it "should preserve module nesting" do - pry_eval 'edit-method -p X::B#foo' - - X::B.instance_method(:foo).owner.should == X::B - X::B.new.foo.should == :nawt - end - - describe "monkey-patching" do - before do - @edit = 'edit-method --patch ' # A shortcut. - end - - # @param [Integer] lineno - # @return [String] the stripped line from the tempfile at +lineno+ - def stripped_line_at(lineno) - @tempfile.rewind - @tempfile.lines.to_a[lineno].strip - end - - # Applies the monkey patch for +method+ with help of evaluation of - # +eval_strs+. The idea is to capture the initial line number (before - # the monkey patch), because it gets overwritten by the line number from - # the monkey patch. And our goal is to check that the original - # definition hasn't changed. - # @param [UnboundMethod] method - # @param [Array] eval_strs - # @return [Array] eval_strs + # @return [Array