pry 0.9.8pre3-i386-mingw32 → 0.9.8pre4-i386-mingw32

data/lib/pry/cli.rb

@@ -14,7 +14,7 @@ class Pry
       # @return [Array] The Procs that process the parsed options.
       attr_accessor :option_processors
 
-      # Add another set of CLI options
+      # Add another set of CLI options (a Slop block)
       def add_options(&block)
         if options
           old_options = options

data/lib/pry/command.rb

@@ -14,12 +14,34 @@ class Pry
     # Properties of the command itself (as passed as arguments to
     # {CommandSet#command} or {CommandSet#command_class}).
     class << self
+      attr_accessor :block
       attr_accessor :name
       attr_accessor :description
-      attr_accessor :options
-      attr_accessor :block
+      attr_accessor :command_options
+
+      # Define or get the command's description
+      def description(arg=nil)
+        @description = arg if arg
+        @description
+      end
+
+      # Define or get the command's options
+      def command_options(arg=nil)
+        @command_options = arg if arg
+        @command_options
+      end
+      # backward compatibility
+      alias_method :options, :command_options
+      alias_method :options=, :command_options=
+
+      # Define or get the command's banner
+      def banner(arg=nil)
+        @banner = arg if arg
+        @banner || description
+      end
     end
 
+
     # Make those properties accessible to instances
     def name; self.class.name; end
     def description; self.class.description; end
@@ -47,7 +69,7 @@ class Pry
         klass.send(:include, helpers)
         klass.name = name
         klass.description = description
-        klass.options = options
+        klass.command_options = options
         klass.block = block
         klass
       end
@@ -276,10 +298,19 @@ class Pry
     # backwards compatibility
     alias_method :opts, :context
 
+    # Call the block that was registered with this command.
+    #
+    # @param *String  the arguments passed
+    # @return Object  the return value of the block
     def call(*args)
       instance_exec(*correct_arg_arity(block.arity, args), &block)
     end
 
+    # Fix the number of arguments we pass to a block to avoid arity warnings.
+    #
+    # @param Number  the arity of the block
+    # @param Array   the arguments to pass
+    # @return Array  a (possibly shorter) array of the arguments to pass
     def correct_arg_arity(arity, args)
       case
       when arity < 0
@@ -304,12 +335,6 @@ class Pry
   # necessary, you can also override {setup} which will be called before {options}, for example to
   # require any gems your command needs to run, or to set up state.
   class ClassCommand < Command
-    class << self
-      def banner(arg=nil)
-        @banner = arg if arg
-        @banner || description
-      end
-    end
 
     attr_accessor :opts
     attr_accessor :args

data/lib/pry/command_set.rb

@@ -81,11 +81,12 @@ class Pry
     #   # hello john, nice number: 10
     #   # pry(main)> help number
     #   # number-N regex command
-    def command(name, description="No description.", options={}, &block)
+    def block_command(name, description="No description.", options={}, &block)
       options = default_options(name).merge!(options)
 
       commands[name] = Pry::BlockCommand.subclass(name, description, options, helper_module, &block)
     end
+    alias_method :command, :block_command
 
     # Defines a new Pry command class.
     #
@@ -96,7 +97,7 @@ class Pry
     # @param &Block  The class body's definition.
     #
     # @example
-    #   Pry::Commands.command_class "echo", "echo's the input", :shellwords => false do
+    #   Pry::Commands.create_command "echo", "echo's the input", :shellwords => false do
     #     def options(opt)
     #       opt.banner "Usage: echo [-u | -d] <string to echo>"
     #       opt.on :u, :upcase, "ensure the output is all upper-case"
@@ -112,13 +113,14 @@ class Pry
     #     end
     #   end
     #
-    def command_class(name, description="No description.", options={}, &block)
+    def create_command(name, description="No description.", options={}, &block)
       options = default_options(name).merge!(options)
 
       commands[name] = Pry::ClassCommand.subclass(name, description, options, helper_module, &block)
       commands[name].class_eval(&block)
       commands[name]
     end
+    alias_method :command_class, :create_command
 
     # Execute a block of code before a command is invoked. The block also
     # gets access to parameters that will be passed to the command and

data/lib/pry/default_commands/context.rb

@@ -24,10 +24,7 @@ class Pry
             when "."
               next
             when ".."
-              if stack.one?
-                _pry_.binding_stack.clear
-                throw(:breakout)
-              else
+              unless stack.size == 1
                 stack.pop
               end
             else

data/lib/pry/default_commands/documentation.rb

@@ -97,18 +97,24 @@ USAGE
           opt.on :l, :lines, "Only gist a subset of lines (only works with -m and -f)", :optional => true, :as => Range, :default => 1..-1
           opt.on :i, :in, "Gist entries from Pry's input expression history. Takes an index or range.", :optional => true,
           :as => Range, :default => -5..-1 do |range|
+            self.input_ranges ||= []
             input_ranges << absolute_index_range(range, _pry_.input_array.length)
           end
         end
 
         def process
+          self.content = ""
+
           if opts.present?(:in)
             in_option
-          elsif opts.present?(:file)
+          end
+          if opts.present?(:file)
             file_option
-          elsif opts.present?(:doc)
+          end
+          if opts.present?(:doc)
             doc_option
-          elsif opts.present?(:method)
+          end
+          if opts.present?(:method)
             method_option
           end
 
@@ -117,7 +123,6 @@ USAGE
 
         def in_option
           self.code_type = :ruby
-          self.content = ""
 
           input_ranges.each do |range|
             input_expressions = _pry_.input_array[range] || []
@@ -136,19 +141,19 @@ USAGE
         def file_option
           whole_file = File.read(File.expand_path(opts[:f]))
           if opts.present?(:lines)
-            self.content = restrict_to_lines(whole_file, opts[:l])
+            self.content << restrict_to_lines(whole_file, opts[:l])
           else
-            self.content = whole_file
+            self.content << whole_file
           end
         end
 
         def doc_option
           meth = get_method_or_raise(opts[:d], target, {})
-          self.content = meth.doc
+          self.content << meth.doc
           self.code_type = meth.source_type
 
           text.no_color do
-            self.content = process_comment_markup(self.content, self.code_type)
+            self.content << process_comment_markup(self.content, self.code_type)
           end
           self.code_type = :plain
         end
@@ -157,9 +162,9 @@ USAGE
           meth = get_method_or_raise(opts[:m], target, {})
           method_source = meth.source
           if opts.present?(:lines)
-            self.content = restrict_to_lines(method_source, opts[:l])
+            self.content << restrict_to_lines(method_source, opts[:l])
           else
-            self.content = method_source
+            self.content << method_source
           end
 
           self.code_type = meth.source_type

data/lib/pry/default_commands/input.rb

@@ -9,7 +9,7 @@ class Pry
       end
 
       command "show-input", "Show the contents of the input buffer for the current multi-line expression." do
-        render_output(false, 1, Pry.color ? CodeRay.scan(eval_string, :ruby).term : eval_string)
+        render_output(false, 1, colorize_code(eval_string))
       end
 
       command(/amend-line(?: (-?\d+)(?:\.\.(-?\d+))?)?/, "Amend a line of input in multi-line mode. Type `amend-line --help` for more information. Aliases %",

data/lib/pry/extended_commands/user_command_api.rb

@@ -19,45 +19,102 @@ class Pry
 
       end
 
-      command "reload-command", "Reload a command. reload-command CMD_NAME CMD_SET" do |command_name, set_name|
-        if command_name.nil?
-          raise CommandError, "Must provide command name"
-        end
+      command_class "reload-command", "Reload a Pry command." do
+        banner <<-BANNER
+          Usage: reload-command command
+          Reload a Pry command.
+        BANNER
 
-        if set_name.nil?
-          raise CommandError, "Must provide command set name"
-        end
+        def process
+          command = _pry_.commands.find_command(args.first)
+
+          if command.nil?
+            raise Pry::CommandError, 'No command found.'
+          end
 
-        cmd = Pry.config.commands.commands[command_name]
-        file_name = cmd.block.source_location.first
+          source_code = command.block.source
+          file, lineno = command.block.source_location
 
-        silence_warnings do
-          load file_name
+          set = Pry::CommandSet.new do
+            eval(source_code, binding, file, lineno)
+          end
+
+          _pry_.commands.delete(command.name)
+          _pry_.commands.import(set)
         end
-        Pry.config.commands.import target.eval(set_name)
-        _pry_.commands.import target.eval(set_name)
-        set_file_and_dir_locals(file_name)
       end
 
-      command "edit-command", "Edit a command. edit-command CMD_NAME CMD_SET" do |command_name, set_name|
-        if command_name.nil?
-          raise CommandError, "Must provide command name"
+      command_class "edit-command", "Edit a Pry command." do
+        banner <<-BANNER
+          Usage: edit-command [options] command
+          Edit a Pry command.
+        BANNER
+
+        def initialize env
+          @pry = env[:pry_instance]
+          @command = nil
+          super(env)
         end
 
-        if set_name.nil?
-          raise CommandError, "Must provide command set name"
+        def options(opt)
+          opt.on :p, :patch, 'Perform a in-memory edit of a command'
+        end
+
+        def process
+          @command = @pry.commands.find_command(args.first)
+
+          if @command.nil?
+            raise Pry::CommandError, 'Command not found.'
+          end
+
+          case
+          when opts.present?(:patch)
+            edit_temporarily
+          else
+            edit_permanently
+          end
         end
 
-        cmd = Pry.config.commands.commands[command_name]
-        file_name = cmd.block.source_location.first
+        def edit_permanently
+          file, lineno = @command.block.source_location
+          invoke_editor(file, lineno)
+
+          command_set = silence_warnings do
+            eval File.read(file), TOPLEVEL_BINDING, file, 1
+          end
+
+          unless command_set.is_a?(Pry::CommandSet)
+            raise Pry::CommandError,
+                  "Expected file '#{file}' to return a CommandSet"
+          end
+
+          @pry.commands.delete(@command.name)
+          @pry.commands.import(command_set)
+          set_file_and_dir_locals(file)
+        end
+
+        def edit_temporarily
+          source_code = Pry::Method(@command.block).source
+          modified_code = nil
+
+          temp_file do |f|
+            f.write(source_code)
+            f.flush
+
+            invoke_editor(f.path, 1)
+            modified_code = File.read(f.path)
+          end
+
+          command_set = CommandSet.new do
+            silence_warnings do
+              pry = Pry.new :input => StringIO.new(modified_code)
+              pry.rep(binding)
+            end
+          end
 
-        invoke_editor(*cmd.block.source_location)
-        silence_warnings do
-          load file_name
+          @pry.commands.delete(@command.name)
+          @pry.commands.import(command_set)
         end
-        Pry.config.commands.import target.eval(set_name)
-        _pry_.commands.import target.eval(set_name)
-        set_file_and_dir_locals(file_name)
       end
 
     end

data/lib/pry/hooks.rb

@@ -5,6 +5,59 @@ class Pry
       @hooks = {}
     end
 
+    # Ensure that duplicates have their @hooks object
+    def initialize_copy(orig)
+      hooks_dup = @hooks.dup
+      @hooks.each do |k, v|
+        hooks_dup[k] = v.dup
+      end
+
+      @hooks = hooks_dup
+    end
+
+    def hooks
+      @hooks
+    end
+    protected :hooks
+
+    # Destructively merge the contents of two `Pry:Hooks` instances.
+    # @param [Pry::Hooks] other The `Pry::Hooks` instance to merge
+
+
+
+    # TODO: implement by iterating over parameter and only overwriting
+    # elements in receiver if they exist in parameter, and adding
+    # other paramater elements to the end of the original's array
+    def merge!(other)
+      @hooks.merge!(other.dup.hooks) do |key, v1, v2|
+        merge_arrays(v1, v2)
+      end
+
+      self
+    end
+
+    def merge_arrays(array1, array2)
+      keys = array1.map {|(k,v)| k}
+      hash = {}
+      array1.each{|(k,v)| hash[k]=v}
+      keys.push(*array2.map {|(k,v)| k})
+      array2.each{|(k,v)| hash[k]=v}
+      result = []
+      keys.uniq!
+      keys.each{|k| result.push([k,hash[k]]) }
+      result
+    end
+    private :merge_arrays
+
+    # Return a new `Pry::Hooks` instance containing a merge of the contents of two `Pry:Hooks` instances,
+    # @param [Pry::Hooks] other The `Pry::Hooks` instance to merge
+    # @return [Pry::Hooks] The new hash.
+    def merge(other)
+      self.dup.tap do |v|
+        v.merge!(other)
+      end
+    end
+
     # Add a new hook to be executed for the `name` even.
     # @param [Symbol] event_name The name of the event.
     # @param [Symbol] hook_name The name of the hook.
@@ -91,10 +144,12 @@ class Pry
 
     # Clear all hooks functions for a given event.
     # @param [String] event_name The name of the event.
-    def clear(event_name)
+    def delete_hooks(event_name)
       @hooks[event_name] = []
     end
 
+    alias_method :clear, :delete_hooks
+
     # @param [Symbol] event_name Name of the event.
     # @param [Symbol] hook_name Name of the hook.
     # @return [Boolean] Whether the hook by the name `hook_name`

data/lib/pry/method.rb

@@ -1,5 +1,17 @@
 # -*- coding: utf-8 -*-
 class Pry
+  class << self
+    # If the given object is a `Pry::Method`, return it unaltered. If it's
+    # anything else, return it wrapped in a `Pry::Method` instance.
+    def Method(obj)
+      if obj.is_a? Pry::Method
+        obj
+      else
+        Pry::Method.new(obj)
+      end
+    end
+  end
+
   class Method
     include RbxMethod if Helpers::BaseHelpers.rbx?
 

data/lib/pry/pry_instance.rb

@@ -111,9 +111,9 @@ class Pry
     inject_local("_in_", @input_array, target)
     inject_local("_out_", @output_array, target)
     inject_local("_pry_", self, target)
-    inject_local("_ex_", nil, target)
-    inject_local("_file_", nil, target)
-    inject_local("_dir_", nil, target)
+    inject_local("_ex_", last_exception, target)
+    inject_local("_file_", last_file, target)
+    inject_local("_dir_", last_dir, target)
 
     # without this line we get 1 test failure, ask Mon_Ouie
     set_last_result(nil, target)
@@ -129,13 +129,13 @@ class Pry
 
   def special_locals
     {
-      :_in_ => @input_array,
-      :_out_ => @output_array,
-      :_pry_ => self,
-      :_ex_ => last_exception,
+      :_in_   => @input_array,
+      :_out_  => @output_array,
+      :_pry_  => self,
+      :_ex_   => last_exception,
       :_file_ => last_file,
-      :_dir_ => last_dir,
-      :_ => last_result
+      :_dir_  => last_dir,
+      :_      => last_result
     }
   end
 
@@ -566,7 +566,7 @@ class Pry
     end
 
     # Assert that a line which ends with a , or a \ is incomplete.
-    str !~ /[,\\]$/
+    str !~ /[,\\]\z/
   rescue SyntaxError => e
     if incomplete_user_input_exception?(e)
       false

data/lib/pry/version.rb

@@ -1,3 +1,3 @@
 class Pry
-  VERSION = "0.9.8pre3"
+  VERSION = "0.9.8pre4"
 end

data/pry.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = "pry"
-  s.version = "0.9.8pre3"
+  s.version = "0.9.8pre4"
 
   s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["John Mair (banisterfiend)"]
-  s.date = "2012-01-05"
+  s.date = "2012-01-12"
   s.description = "An IRB alternative and runtime developer console"
   s.email = "jrmair@gmail.com"
   s.executables = ["pry"]

data/test/test_default_commands/test_context.rb

@@ -141,8 +141,15 @@ describe "Pry::DefaultCommands::Context" do
       $outer.should == :outer
     end
 
-    it 'should break out of the repl loop of Pry instance when binding_stack has only one binding with cd ..' do
-      Pry.start(0, :input => StringIO.new("cd ..")).should == nil
+    it "should not leave the REPL session when given 'cd ..'" do
+      b = Pry.binding_for(Object.new) 
+      input = InputTester.new "cd ..", "$obj = self", "exit-all" 
+      
+      redirect_pry_io(input, StringIO.new) do
+        b.pry
+      end
+
+      $obj.should == b.eval("self")
     end
 
     it 'should break out to outer-most session with cd /' do

data/test/test_hooks.rb

@@ -53,6 +53,125 @@ describe Pry::Hooks do
     end
   end
 
+  describe "Pry::Hooks#merge" do
+    describe "merge!" do
+      it 'should merge in the Pry::Hooks' do
+        h1 = Pry::Hooks.new.add_hook(:test_hook, :testing) {}
+        h2 = Pry::Hooks.new
+
+        h2.merge!(h1)
+        h2.get_hook(:test_hook, :testing).should == h1.get_hook(:test_hook, :testing)
+      end
+
+      it 'should not share merged elements with original' do
+        h1 = Pry::Hooks.new.add_hook(:test_hook, :testing) {}
+        h2 = Pry::Hooks.new
+
+        h2.merge!(h1)
+        h2.add_hook(:test_hook, :testing2) {}
+        h2.get_hook(:test_hook, :testing2).should.not == h1.get_hook(:test_hook, :testing2)
+      end
+
+      it 'should NOT overwrite hooks belonging to shared event in receiver' do
+        h1 = Pry::Hooks.new.add_hook(:test_hook, :testing) {}
+        callable = proc {}
+        h2 = Pry::Hooks.new.add_hook(:test_hook, :testing2, callable)
+
+        h2.merge!(h1)
+        h2.get_hook(:test_hook, :testing2).should == callable
+      end
+
+      it 'should overwrite identical hook in receiver' do
+        callable1 = proc { :one }
+        h1 = Pry::Hooks.new.add_hook(:test_hook, :testing, callable1)
+        callable2 = proc { :two }
+        h2 = Pry::Hooks.new.add_hook(:test_hook, :testing, callable2)
+
+        h2.merge!(h1)
+        h2.get_hook(:test_hook, :testing).should == callable1
+        h2.hook_count(:test_hook).should == 1
+      end
+
+      it 'should preserve hook order' do
+        name = ""
+        h1 = Pry::Hooks.new
+        h1.add_hook(:test_hook, :testing3) { name << "h" }
+        h1.add_hook(:test_hook, :testing4) { name << "n" }
+
+        h2 = Pry::Hooks.new
+        h2.add_hook(:test_hook, :testing1) { name << "j" }
+        h2.add_hook(:test_hook, :testing2) { name << "o" }
+
+        h2.merge!(h1)
+        h2.exec_hook(:test_hook)
+
+        name.should == "john"
+      end
+
+      describe "merge" do
+        it 'should return a fresh, independent instance' do
+          h1 = Pry::Hooks.new.add_hook(:test_hook, :testing) {}
+          h2 = Pry::Hooks.new
+
+          h3 = h2.merge(h1)
+          h3.should.not == h1
+          h3.should.not == h2
+        end
+
+        it 'should contain hooks from original instance' do
+          h1 = Pry::Hooks.new.add_hook(:test_hook, :testing) {}
+          h2 = Pry::Hooks.new.add_hook(:test_hook2, :testing) {}
+
+          h3 = h2.merge(h1)
+          h3.get_hook(:test_hook, :testing).should == h1.get_hook(:test_hook, :testing)
+          h3.get_hook(:test_hook2, :testing).should == h2.get_hook(:test_hook2, :testing)
+        end
+
+        it 'should not affect original instances when new hooks are added' do
+          h1 = Pry::Hooks.new.add_hook(:test_hook, :testing) {}
+          h2 = Pry::Hooks.new.add_hook(:test_hook2, :testing) {}
+
+          h3 = h2.merge(h1)
+          h3.add_hook(:test_hook3, :testing) {}
+
+          h1.get_hook(:test_hook3, :testing).should == nil
+          h2.get_hook(:test_hook3, :testing).should == nil
+        end
+      end
+
+    end
+  end
+
+  describe "dupping a Pry::Hooks instance" do
+    it 'should share hooks with original' do
+      @hooks.add_hook(:test_hook, :testing) do
+        :none_such
+      end
+
+      hooks_dup = @hooks.dup
+      hooks_dup.get_hook(:test_hook, :testing).should == @hooks.get_hook(:test_hook, :testing)
+    end
+
+     it 'adding a new event to dupped instance should not affect original' do
+      @hooks.add_hook(:test_hook, :testing) { :none_such }
+      hooks_dup = @hooks.dup
+
+      hooks_dup.add_hook(:other_test_hook, :testing) { :okay_man }
+
+      hooks_dup.get_hook(:other_test_hook, :testing).should.not == @hooks.get_hook(:other_test_hook, :testing)
+    end
+
+     it 'adding a new hook to dupped instance should not affect original' do
+      @hooks.add_hook(:test_hook, :testing) { :none_such }
+      hooks_dup = @hooks.dup
+
+      hooks_dup.add_hook(:test_hook, :testing2) { :okay_man }
+
+      hooks_dup.get_hook(:test_hook, :testing2).should.not == @hooks.get_hook(:test_hook, :testing2)
+    end
+
+  end
+
   describe "getting hooks" do
     describe "get_hook" do
       it 'should return the correct requested hook' do

data/test/test_syntax_checking.rb

@@ -44,4 +44,15 @@ describe Pry do
     end
     output.string.should =~ /SyntaxError/
   end
+
+  it "should allow trailing , to continue the line" do
+    pry = Pry.new
+
+    pry.complete_expression?("puts 1, 2,").should == false
+  end
+
+  it "should complete an expression that contains a line ending with a ," do
+    pry = Pry.new
+    pry.complete_expression?("puts 1, 2,\n3").should == true
+  end
 end

metadata

@@ -2,7 +2,7 @@
 name: pry
 version: !ruby/object:Gem::Version 
   prerelease: 5
-  version: 0.9.8pre3
+  version: 0.9.8pre4
 platform: i386-mingw32
 authors: 
 - John Mair (banisterfiend)
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-05 00:00:00 Z
+date: 2012-01-12 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: coderay