pry 0.9.8pre2-i386-mingw32 → 0.9.8pre3-i386-mingw32

data/lib/pry/command_set.rb

@@ -8,41 +8,6 @@ class Pry
   # This class is used to create sets of commands. Commands can be imported from
   # different sets, aliased, removed, etc.
   class CommandSet
-    class Command < Struct.new(:name, :description, :options, :block)
-
-      def call(context, *args)
-        context.command_name = options[:listing]
-
-        if stub_block = options[:stub_info]
-          context.instance_eval(&stub_block)
-        else
-          ret = context.instance_exec(*correct_arg_arity(block.arity, args), &block)
-          if options[:keep_retval]
-            ret
-          else
-            Pry::CommandContext::VOID_VALUE
-          end
-        end
-      end
-
-      private
-      def correct_arg_arity(arity, args)
-        case arity <=> 0
-        when -1
-          args
-        when 0
-          []
-        when 1
-          # another jruby hack
-          if Pry::Helpers::BaseHelpers.jruby?
-            args[0..(arity - 1)]
-          else
-            args.values_at 0..(arity - 1)
-          end
-        end
-      end
-    end
-
     include Enumerable
     include Pry::Helpers::BaseHelpers
 
@@ -117,29 +82,42 @@ class Pry
     #   # pry(main)> help number
     #   # number-N regex command
     def command(name, description="No description.", options={}, &block)
+      options = default_options(name).merge!(options)
 
-      options = {
-        :requires_gem => [],
-        :keep_retval => false,
-        :argument_required => false,
-        :interpolate => true,
-        :shellwords => true,
-        :listing => name,
-        :use_prefix => true
-      }.merge!(options)
-
-      unless command_dependencies_met? options
-        gems_needed = Array(options[:requires_gem])
-        gems_not_installed = gems_needed.select { |g| !gem_installed?(g) }
+      commands[name] = Pry::BlockCommand.subclass(name, description, options, helper_module, &block)
+    end
 
-        options[:stub_info] = proc do
-          output.puts "\nThe command '#{name}' is #{Helpers::Text.bold("unavailable")} because it requires the following gems to be installed: #{(gems_not_installed.join(", "))}"
-          output.puts "-"
-          output.puts "Type `install-command #{name}` to install the required gems and activate this command."
-        end
-      end
+    # Defines a new Pry command class.
+    #
+    # @param [String, Regexp] name The name of the command. Can be
+    #   Regexp as well as String.
+    # @param [String] description A description of the command.
+    # @param [Hash] options The optional configuration parameters, see {#command}
+    # @param &Block  The class body's definition.
+    #
+    # @example
+    #   Pry::Commands.command_class "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"
+    #       opt.on :d, :downcase, "ensure the output is all lower-case"
+    #     end
+    #
+    #     def process
+    #       raise Pry::CommandError, "-u and -d makes no sense" if opts.present?(:u) && opts.present?(:d)
+    #       result = args.join(" ")
+    #       result.downcase! if opts.present?(:downcase)
+    #       result.upcase! if opts.present?(:upcase)
+    #       output.puts result
+    #     end
+    #   end
+    #
+    def command_class(name, description="No description.", options={}, &block)
+      options = default_options(name).merge!(options)
 
-      commands[name] = Command.new(name, description, options, block)
+      commands[name] = Pry::ClassCommand.subclass(name, description, options, helper_module, &block)
+      commands[name].class_eval(&block)
+      commands[name]
     end
 
     # Execute a block of code before a command is invoked. The block also
@@ -153,13 +131,7 @@ class Pry
     #   end
     def before_command(name, &block)
       cmd = find_command_by_name_or_listing(name)
-      prev_block = cmd.block
-
-      wrapper_block = proc do |*args|
-        instance_exec(*args, &block)
-        instance_exec(*args, &prev_block)
-      end
-      cmd.block = wrapper_block
+      cmd.hooks[:before].unshift block
     end
 
     # Execute a block of code after a command is invoked. The block also
@@ -173,13 +145,7 @@ class Pry
     #   end
     def after_command(name, &block)
       cmd = find_command_by_name_or_listing(name)
-      prev_block = cmd.block
-
-      wrapper_block = proc do |*args|
-        instance_exec(*args, &prev_block)
-        instance_exec(*args, &block)
-      end
-      cmd.block = wrapper_block
+      cmd.hooks[:after] << block
     end
 
     def each &block
@@ -267,27 +233,6 @@ class Pry
       commands.delete(cmd.name)
     end
 
-    # Runs a command.
-    # @param [Object] context Object which will be used as self during the
-    #   command.
-    # @param [String] name Name of the command to be run
-    # @param [Array<Object>] args Arguments passed to the command
-    # @raise [NoCommandError] If the command is not defined in this set
-    def run_command(context, name, *args)
-      context.extend helper_module
-      command = commands[name]
-
-      if command.nil?
-        raise NoCommandError.new(name, self)
-      end
-
-      if command.options[:argument_required] && args.empty?
-        puts "The command '#{command.name}' requires an argument."
-      else
-        command.call context, *args
-      end
-    end
-
     # Sets or gets the description for a command (replacing the old
     # description). Returns current description if no description
     # parameter provided.
@@ -328,7 +273,58 @@ class Pry
       commands.keys
     end
 
+    # Find a command that matches the given line
+    #
+    # @param [String]  the line that may be a command invocation
+    # @return [Pry::Command, nil]
+    def find_command(val)
+      commands.values.detect{ |c| c.matches?(val) }
+    end
+
+    # Is the given line a command invocation?
+    #
+    # @param [String]
+    # @return [Boolean]
+    def valid_command?(val)
+      !!find_command(val)
+    end
+
+    # Process the given line to see whether it needs executing as a command.
+    #
+    # @param String  the line to execute
+    # @param Hash  the context to execute the commands with
+    # @return CommandSet::Result
+    #
+    def process_line(val, context={})
+      if command = find_command(val)
+        context = context.merge(:command_set => self)
+        retval = command.new(context).process_line(val)
+        Result.new(true, retval)
+      else
+        Result.new(false)
+      end
+    end
+
+    # @nodoc  used for testing
+    def run_command(context, name, *args)
+      command = commands[name] or raise NoCommandError.new(name, self)
+      command.new(context).call_safely(*args)
+    end
+
     private
+
+    def default_options(name)
+      {
+        :requires_gem => [],
+        :keep_retval => false,
+        :argument_required => false,
+        :interpolate => true,
+        :shellwords => true,
+        :listing => name,
+        :use_prefix => true
+      }
+    end
+
     def define_default_commands
 
       command "help", "This menu." do |cmd|
@@ -345,7 +341,7 @@ class Pry
           stagger_output(help_text)
         else
           if command = find_command(cmd)
-            output.puts command.description
+            output.puts command.new.help
           else
             output.puts "No info for command: #{cmd}"
           end
@@ -355,10 +351,9 @@ class Pry
       command "install-command", "Install a disabled command." do |name|
         require 'rubygems/dependency_installer' unless defined? Gem::DependencyInstaller
         command = find_command(name)
-        stub_info = command.options[:stub_info]
 
-        if !stub_info
-          output.puts "Not a command stub. Nothing to do."
+        if command_dependencies_met?(command.options)
+          output.puts "Dependencies for #{command.name} are met. Nothing to do."
           next
         end
 
@@ -391,9 +386,31 @@ class Pry
         end
         next if gem_install_failed
 
-        command.options.delete :stub_info
         output.puts "Installation of `#{name}` successful! Type `help #{name}` for information"
       end
     end
   end
+
+  # Wraps the return result of process_commands, indicates if the
+  # result IS a command and what kind of command (e.g void)
+  class Result
+    attr_reader :retval
+
+    def initialize(is_command, retval = nil)
+      @is_command, @retval = is_command, retval
+    end
+
+    # Is the result a command?
+    # @return [Boolean]
+    def command?
+      @is_command
+    end
+
+    # Is the result a command and if it is, is it a void command?
+    # (one that does not return a value)
+    # @return [Boolean]
+    def void_command?
+      retval == Command::VOID_VALUE
+    end
+  end
 end

data/lib/pry/default_commands/documentation.rb

@@ -3,124 +3,196 @@ class Pry
 
     Documentation = Pry::CommandSet.new do
 
-      command "ri", "View ri documentation. e.g `ri Array#each`" do |*args|
-        run ".ri", *args
+      command_class "ri", "View ri documentation. e.g `ri Array#each`" do
+        banner <<-BANNER
+          Usage: ri [spec]
+          e.g. ri Array#each
+
+          Relies on the ri executable being available. See also: show-doc.
+        BANNER
+
+        def process
+          run ".ri", *args
+        end
       end
 
-      command "show-doc", "Show the comments above METH. Type `show-doc --help` for more info. Aliases: \?", :shellwords => false do |*args|
-        opts, meth = parse_options!(args, :method_object) do |opt|
-          opt.banner unindent <<-USAGE
-            Usage: show-doc [OPTIONS] [METH]
-            Show the comments above method METH. Tries instance methods first and then methods by default.
-            e.g show-doc hello_method
-          USAGE
+      command_class "show-doc", "Show the comments above METH. Type `show-doc --help` for more info. Aliases: \?", :shellwords => false do |*args|
+        banner <<-BANNER
+          Usage: show-doc [OPTIONS] [METH]
+          Show the comments above method METH. Tries instance methods first and then methods by default.
+          e.g show-doc hello_method
+        BANNER
 
+        def options(opt)
+          method_options(opt)
           opt.on :f, :flood, "Do not use a pager to view text longer than one screen."
         end
 
-        raise Pry::CommandError, "No documentation found." if meth.doc.nil? || meth.doc.empty?
-
-        doc = process_comment_markup(meth.doc, meth.source_type)
-        output.puts make_header(meth, doc)
-        output.puts "#{text.bold("Owner:")} #{meth.owner || "N/A"}"
-        output.puts "#{text.bold("Visibility:")} #{meth.visibility}"
-        output.puts "#{text.bold("Signature:")} #{meth.signature}"
-        output.puts
-        render_output(opts.present?(:flood), false, doc)
+        def process
+          meth = method_object
+          raise Pry::CommandError, "No documentation found." if meth.doc.nil? || meth.doc.empty?
+
+          doc = process_comment_markup(meth.doc, meth.source_type)
+          output.puts make_header(meth, doc)
+          output.puts "#{text.bold("Owner:")} #{meth.owner || "N/A"}"
+          output.puts "#{text.bold("Visibility:")} #{meth.visibility}"
+          output.puts "#{text.bold("Signature:")} #{meth.signature}"
+          output.puts
+          render_output(opts.present?(:flood), false, doc)
+        end
       end
 
       alias_command "?", "show-doc"
 
-      command "stat", "View method information and set _file_ and _dir_ locals. Type `stat --help` for more info.", :shellwords => false do |*args|
-        target = target()
-
-        opts, meth = parse_options!(args, :method_object) do |opt|
-          opt.banner unindent <<-USAGE
+      command_class "stat", "View method information and set _file_ and _dir_ locals. Type `stat --help` for more info.", :shellwords => false do |*args|
+        banner <<-BANNER
             Usage: stat [OPTIONS] [METH]
             Show method information for method METH and set _file_ and _dir_ locals.
             e.g: stat hello_method
-          USAGE
-        end
-
-        output.puts unindent <<-EOS
-          Method Information:
-          --
-          Name: #{meth.name}
-          Owner: #{meth.owner ? meth.owner : "Unknown"}
-          Visibility: #{meth.visibility}
-          Type: #{meth.is_a?(::Method) ? "Bound" : "Unbound"}
-          Arity: #{meth.arity}
-          Method Signature: #{meth.signature}
-          Source Location: #{meth.source_location ? meth.source_location.join(":") : "Not found."}
-        EOS
+        BANNER
+
+        def options(opt)
+          method_options(opt)
+        end
+
+        def process
+          meth = method_object
+          output.puts unindent <<-EOS
+            Method Information:
+            --
+            Name: #{meth.name}
+            Owner: #{meth.owner ? meth.owner : "Unknown"}
+            Visibility: #{meth.visibility}
+            Type: #{meth.is_a?(::Method) ? "Bound" : "Unbound"}
+            Arity: #{meth.arity}
+            Method Signature: #{meth.signature}
+            Source Location: #{meth.source_location ? meth.source_location.join(":") : "Not found."}
+          EOS
+        end
       end
 
-      command "gist", "Gist a method or expression history to github. Type `gist --help` for more info.", :requires_gem => "gist", :shellwords => false do |*args|
-        require 'gist'
+      command_class "gist", "Gist a method or expression history to github. Type `gist --help` for more info.", :requires_gem => "gist", :shellwords => false do
+        attr_accessor :content
+        attr_accessor :code_type
+        attr_accessor :input_ranges
 
-        target = target()
+        def setup
+          require 'gist'
+        end
 
-        opts = parse_options!(args) do |opt|
+        def options(opt)
           opt.banner unindent <<-USAGE
-            Usage: gist [OPTIONS] [METH]
-            Gist method (doc or source) or input expression to github.
-            Ensure the `gist` gem is properly working before use. http://github.com/defunkt/gist for instructions.
-            e.g: gist -m my_method
-            e.g: gist -d my_method
-            e.g: gist -i 1..10
-          USAGE
+  Usage: gist [OPTIONS] [METH]
+  Gist method (doc or source) or input expression to github.
+  Ensure the `gist` gem is properly working before use. http://github.com/defunkt/gist for instructions.
+  e.g: gist -m my_method
+  e.g: gist -d my_method
+  e.g: gist -i 1..10
+USAGE
 
           opt.on :d, :doc, "Gist a method's documentation.", true
           opt.on :m, :method, "Gist a method's source.", true
+          opt.on :f, :file, "Gist a file.", true
           opt.on :p, :public, "Create a public gist (default: false)", :default => false
-          opt.on :i, :in, "Gist entries from Pry's input expression history. Takes an index or range.", :optional => true, :as => Range, :default => -5..-1
+          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|
+            input_ranges << absolute_index_range(range, _pry_.input_array.length)
+          end
         end
 
-        type_map = { :ruby => "rb", :c => "c", :plain => "plain" }
-        if opts.present?(:in)
-          code_type = :ruby
-          content = ""
-          normalized_range = absolute_index_range(opts[:i], _pry_.input_array.length)
-          input_items = _pry_.input_array[normalized_range] || []
-
-          input_items.each_with_index.map do |code, index|
-            corrected_index = index + normalized_range.first
-            if code && code != ""
-              content << code
-              content << "#{comment_expression_result_for_gist(Pry.config.gist.inspecter.call(_pry_.output_array[corrected_index]))}" if code !~ /;\Z/
+        def process
+          if opts.present?(:in)
+            in_option
+          elsif opts.present?(:file)
+            file_option
+          elsif opts.present?(:doc)
+            doc_option
+          elsif opts.present?(:method)
+            method_option
+          end
+
+          perform_gist
+        end
+
+        def in_option
+          self.code_type = :ruby
+          self.content = ""
+
+          input_ranges.each do |range|
+            input_expressions = _pry_.input_array[range] || []
+            input_expressions.each_with_index.map do |code, index|
+              corrected_index = index + range.first
+              if code && code != ""
+                self.content << code
+                if code !~ /;\Z/
+                  self.content << "#{comment_expression_result_for_gist(Pry.config.gist.inspecter.call(_pry_.output_array[corrected_index]))}"
+                end
+              end
             end
           end
-        elsif opts.present?(:doc)
+        end
+
+        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])
+          else
+            self.content = whole_file
+          end
+        end
+
+        def doc_option
           meth = get_method_or_raise(opts[:d], target, {})
-          content = meth.doc
-          code_type = meth.source_type
+          self.content = meth.doc
+          self.code_type = meth.source_type
 
           text.no_color do
-            content = process_comment_markup(content, code_type)
+            self.content = process_comment_markup(self.content, self.code_type)
           end
-          code_type = :plain
-        elsif opts.present?(:method)
+          self.code_type = :plain
+        end
+
+        def method_option
           meth = get_method_or_raise(opts[:m], target, {})
-          content = meth.source
-          code_type = meth.source_type
+          method_source = meth.source
+          if opts.present?(:lines)
+            self.content = restrict_to_lines(method_source, opts[:l])
+          else
+            self.content = method_source
+          end
+
+          self.code_type = meth.source_type
         end
 
-        # prevent Gist from exiting the session on error
-        begin
-        link = Gist.write([:extension => ".#{type_map[code_type]}",
-                           :input => content],
-                          !opts[:p])
-        rescue SystemExit
+        def perform_gist
+          type_map = { :ruby => "rb", :c => "c", :plain => "plain" }
+
+          # prevent Gist from exiting the session on error
+          begin
+            extname = opts.present?(:file) ? ".#{gist_file_extension(opts[:f])}" : ".#{type_map[self.code_type]}"
+
+            link = Gist.write([:extension => extname,
+                               :input => self.content],
+                              !opts[:p])
+          rescue SystemExit
+          end
+
+          if link
+            Gist.copy(link)
+            output.puts "Gist created at #{link} and added to clipboard."
+          end
         end
 
-        if link
-          Gist.copy(link)
-          output.puts "Gist created at #{link} and added to clipboard."
+        def restrict_to_lines(content, lines)
+          line_range = one_index_range(lines)
+          content.lines.to_a[line_range].join
         end
-      end
 
+        def gist_file_extension(file_name)
+          file_name.split(".").last
+        end
 
-      helpers do
         def comment_expression_result_for_gist(result)
           content = ""
           result.lines.each_with_index do |line, index|
@@ -133,8 +205,7 @@ class Pry
           content
         end
       end
-
-
     end
   end
 end
+