pry 0.10.pre.1-i386-mswin32 → 0.10.0.pre3-i386-mswin32

data/lib/pry/commands/gem_open.rb

@@ -0,0 +1,29 @@
+class Pry
+  class Command::GemOpen < Pry::ClassCommand
+    match 'gem-open'
+    group 'Gems'
+    description 'Opens the working directory of the gem in your editor.'
+    command_options :argument_required => true
+
+    banner <<-'BANNER'
+      Usage: gem-open GEM_NAME
+
+      Change the current working directory to that in which the given gem is
+      installed, and then opens your text editor.
+
+      gem-open pry-exception_explorer
+    BANNER
+
+    def process(gem)
+      Dir.chdir(Rubygem.spec(gem).full_gem_path) do
+        Pry::Editor.invoke_editor(".", 0, false)
+      end
+    end
+
+    def complete(str)
+      Rubygem.complete(str)
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::GemOpen)
+end

data/lib/pry/commands/gist.rb

@@ -0,0 +1,101 @@
+class Pry
+  class Command::Gist < Pry::ClassCommand
+    match 'gist'
+    group 'Misc'
+    description 'Upload code, docs, history to https://gist.github.com/.'
+    command_options :requires_gem => "gist"
+
+    banner <<-'BANNER'
+      Usage: gist [OPTIONS] [--help]
+
+      The gist command enables you to gist code from files and methods to github.
+
+      gist -i 20 --lines 1..3
+      gist Pry#repl --lines 1..-1
+      gist Rakefile --lines 5
+    BANNER
+
+    def setup
+      require 'gist'
+    end
+
+    def options(opt)
+      CodeCollector.inject_options(opt)
+      opt.on :login, "Authenticate the gist gem with GitHub"
+      opt.on :p, :public, "Create a public gist (default: false)", :default => false
+      opt.on :clip, "Copy the selected content to clipboard instead, do NOT gist it", :default => false
+    end
+
+    def process
+      return ::Gist.login! if opts.present?(:login)
+      cc = CodeCollector.new(args, opts, _pry_)
+
+      if cc.content =~ /\A\s*\z/
+        raise CommandError, "Found no code to gist."
+      end
+
+      if opts.present?(:clip)
+        clipboard_content(cc.content)
+      else
+        # we're overriding the default behavior of the 'in' option (as
+        # defined on CodeCollector) with our local behaviour.
+        content = opts.present?(:in) ? input_content : cc.content
+        gist_content content, cc.file
+      end
+    end
+
+    def clipboard_content(content)
+      ::Gist.copy(content)
+      output.puts "Copied content to clipboard!"
+    end
+
+    def input_content
+      content = ""
+      CodeCollector.input_expression_ranges.each do |range|
+        input_expressions = _pry_.input_array[range] || []
+        Array(input_expressions).each_with_index do |code, index|
+          corrected_index = index + range.first
+          if code && code != ""
+            content << code
+            if code !~ /;\Z/
+              content << "#{comment_expression_result_for_gist(_pry_.config.gist.inspecter.call(_pry_.output_array[corrected_index]))}"
+            end
+          end
+        end
+      end
+
+      content
+    end
+
+    def comment_expression_result_for_gist(result)
+      content = ""
+      result.lines.each_with_index do |line, index|
+        if index == 0
+          content << "# => #{line}"
+        else
+          content << "#    #{line}"
+        end
+      end
+
+      content
+    end
+
+    def gist_content(content, filename)
+      response = ::Gist.gist(content, :filename => filename || "pry_gist.rb", :public => !!opts[:p])
+      if response
+        url = response['html_url']
+        message = "Gist created at URL #{url}"
+        begin
+          ::Gist.copy(url)
+          message << ", which is now in the clipboard."
+        rescue ::Gist::ClipboardError
+        end
+
+        output.puts message
+      end
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::Gist)
+  Pry::Commands.alias_command 'clipit', 'gist --clip'
+end

data/lib/pry/commands/help.rb

@@ -0,0 +1,164 @@
+class Pry
+  class Command::Help < Pry::ClassCommand
+    match 'help'
+    group 'Help'
+    description 'Show a list of commands or information about a specific command.'
+
+    banner <<-'BANNER'
+      Usage: help [COMMAND]
+
+      With no arguments, help lists all the available commands along with their
+      descriptions. When given a command name as an argument, shows the help
+      for that command.
+    BANNER
+
+    # We only want to show commands that have descriptions, so that the
+    # easter eggs don't show up.
+    def visible_commands
+      visible = {}
+      commands.each do |key, command|
+        visible[key] = command if command.description && !command.description.empty?
+      end
+      visible
+    end
+
+    # Get a hash of available commands grouped by the "group" name.
+    def command_groups
+      visible_commands.values.group_by(&:group)
+    end
+
+    def process
+      if args.empty?
+        display_index(command_groups)
+      else
+        display_search(args.first)
+      end
+    end
+
+    # Display the index view, with headings and short descriptions per command.
+    #
+    # @param [Hash<String, Array<Commands>>] groups
+    def display_index(groups)
+      help_text = []
+
+      sorted_group_names(groups).each do |group_name|
+        commands = sorted_commands(groups[group_name])
+
+        if commands.any?
+           help_text << help_text_for_commands(group_name, commands)
+        end
+      end
+
+      _pry_.pager.page help_text.join("\n\n")
+    end
+
+    # Given a group name and an array of commands,
+    # return the help string for those commands.
+    #
+    # @param [String] name The group name.
+    # @param [Array<Pry::Command>] commands
+    # @return [String] The generated help string.
+    def help_text_for_commands(name, commands)
+      "#{text.bold(name.capitalize)}\n" << commands.map do |command|
+        "  #{command.options[:listing].to_s.ljust(18)} #{command.description.capitalize}"
+      end.join("\n")
+    end
+
+    # @param [Hash] groups
+    # @return [Array<String>] An array of sorted group names.
+    def sorted_group_names(groups)
+      groups.keys.sort_by(&method(:group_sort_key))
+    end
+
+    # Sort an array of commands by their `listing` name.
+    #
+    # @param [Array<Pry::Command>] commands The commands to sort
+    # @return [Array<Pry::Command>] commands sorted by listing name.
+    def sorted_commands(commands)
+      commands.sort_by{ |command| command.options[:listing].to_s }
+    end
+
+    # Display help for an individual command or group.
+    #
+    # @param [String] search  The string to search for.
+    def display_search(search)
+      if command = command_set.find_command_for_help(search)
+        display_command(command)
+      else
+        display_filtered_search_results(search)
+      end
+    end
+
+    # Display help for a searched item, filtered first by group
+    # and if that fails, filtered by command name.
+    #
+    # @param [String] search The string to search for.
+    def display_filtered_search_results(search)
+      groups = search_hash(search, command_groups)
+
+      if groups.size > 0
+        display_index(groups)
+      else
+        display_filtered_commands(search)
+      end
+    end
+
+    # Display help for a searched item, filtered by group
+    #
+    # @param [String] search The string to search for.
+    def display_filtered_commands(search)
+      filtered = search_hash(search, visible_commands)
+      raise CommandError, "No help found for '#{args.first}'" if filtered.empty?
+
+      if filtered.size == 1
+        display_command(filtered.values.first)
+      else
+        display_index({"'#{search}' commands" => filtered.values})
+      end
+    end
+
+    # Display help for an individual command.
+    #
+    # @param [Pry::Command] command
+    def display_command(command)
+      _pry_.pager.page command.new.help
+    end
+
+    # Find a subset of a hash that matches the user's search term.
+    #
+    # If there's an exact match a Hash of one element will be returned,
+    # otherwise a sub-Hash with every key that matches the search will
+    # be returned.
+    #
+    # @param [String] search the search term
+    # @param [Hash] hash the hash to search
+    def search_hash(search, hash)
+      matching = {}
+
+      hash.each_pair do |key, value|
+        next unless key.is_a?(String)
+        if normalize(key) == normalize(search)
+          return {key => value}
+        elsif normalize(key).start_with?(normalize(search))
+          matching[key] = value
+        end
+      end
+
+      matching
+    end
+
+    # Clean search terms to make it easier to search group names
+    #
+    # @param [String] key
+    # @return [String]
+    def normalize(key)
+      key.downcase.gsub(/pry\W+/, '')
+    end
+
+    def group_sort_key(group_name)
+      [%w(Help Context Editing Introspection Input_and_output Navigating_pry Gems Basic Commands).index(group_name.gsub(' ', '_')) || 99, group_name]
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::Help)
+end

data/lib/pry/commands/hist.rb

@@ -0,0 +1,180 @@
+class Pry
+  class Command::Hist < Pry::ClassCommand
+    match 'hist'
+    group 'Editing'
+    description 'Show and replay Readline history.'
+
+    banner <<-'BANNER'
+      Usage:   hist [--head|--tail]
+               hist --all
+               hist --head N
+               hist --tail N
+               hist --show START..END
+               hist --grep PATTERN
+               hist --clear
+               hist --replay START..END
+               hist --save [START..END] FILE
+      Aliases: history
+
+      Show and replay Readline history.
+    BANNER
+
+    def options(opt)
+      opt.on :a, :all,    "Display all history"
+      opt.on :H, :head,   "Display the first N items", :optional_argument => true, :as => Integer
+      opt.on :T, :tail,   "Display the last N items", :optional_argument => true, :as => Integer
+      opt.on :s, :show,   "Show the given range of lines", :optional_argument => true, :as => Range
+      opt.on :G, :grep,   "Show lines matching the given pattern", :argument => true, :as => String
+      opt.on :c, :clear , "Clear the current session's history"
+      opt.on :r, :replay, "Replay a line or range of lines", :argument => true, :as => Range
+      opt.on     :save,   "Save history to a file", :argument => true, :as => Range
+      opt.on :e, :'exclude-pry', "Exclude Pry commands from the history"
+      opt.on :n, :'no-numbers',  "Omit line numbers"
+    end
+
+    def process
+      @history = find_history
+
+      if opts.present?(:show)
+        @history = @history.between(opts[:show])
+      end
+
+      if opts.present?(:grep)
+        @history = @history.grep(opts[:grep])
+      end
+
+      @history = case
+        when opts.present?(:head)
+          @history.take_lines(1, opts[:head] || 10)
+        when opts.present?(:tail)
+          @history.take_lines(-(opts[:tail] || 10), opts[:tail] || 10)
+        when opts.present?(:show)
+          @history.between(opts[:show])
+        else
+          @history
+        end
+
+      if opts.present?(:'exclude-pry')
+        @history = @history.select do |loc|
+                     !command_set.valid_command?(loc.line)
+                   end
+      end
+
+      if opts.present?(:save)
+        process_save
+      elsif opts.present?(:clear)
+        process_clear
+      elsif opts.present?(:replay)
+        process_replay
+      else
+        process_display
+      end
+    end
+
+    private
+
+    def process_display
+      unless opts.present?(:'no-numbers')
+        @history = @history.with_line_numbers
+      end
+
+      _pry_.pager.open do |pager|
+        @history.print_to_output(pager, true)
+      end
+    end
+
+    def process_save
+      case opts[:save]
+      when Range
+        @history = @history.between(opts[:save])
+
+        unless args.first
+          raise CommandError, "Must provide a file name."
+        end
+
+        file_name = File.expand_path(args.first)
+      when String
+        file_name = File.expand_path(opts[:save])
+      end
+
+      output.puts "Saving history in #{file_name}..."
+
+      File.open(file_name, 'w') { |f| f.write(@history.raw) }
+
+      output.puts "History saved."
+    end
+
+    def process_clear
+      Pry.history.clear
+      output.puts "History cleared."
+    end
+
+    def process_replay
+      @history = @history.between(opts[:r])
+      replay_sequence = @history.raw
+
+      # If we met follow-up "hist" call, check for the "--replay" option
+      # presence. If "hist" command is called with other options, proceed
+      # further.
+      check_for_juxtaposed_replay(replay_sequence)
+
+      replay_sequence.lines.each do |line|
+        _pry_.eval line, :generated => true
+      end
+    end
+
+    # Checks +replay_sequence+ for the presence of neighboring replay calls.
+    # @example
+    #   [1] pry(main)> hist --show 46894
+    #   46894: hist --replay 46675..46677
+    #   [2] pry(main)> hist --show 46675..46677
+    #   46675: 1+1
+    #   46676: a = 100
+    #   46677: hist --tail
+    #   [3] pry(main)> hist --replay 46894
+    #   Error: Replay index 46894 points out to another replay call: `hist -r 46675..46677`
+    #   [4] pry(main)>
+    #
+    # @raise [Pry::CommandError] If +replay_sequence+ contains another
+    #   "hist --replay" call
+    # @param [String] replay_sequence The sequence of commands to be replayed
+    #   (per saltum)
+    # @return [Boolean] `false` if +replay_sequence+ does not contain another
+    #   "hist --replay" call
+    def check_for_juxtaposed_replay(replay_sequence)
+      if replay_sequence =~ /\Ahist(?:ory)?\b/
+        # Create *fresh* instance of Options for parsing of "hist" command.
+        _slop = self.slop
+        _slop.parse replay_sequence.split(' ')[1..-1]
+
+        if _slop.present?(:r)
+          replay_sequence = replay_sequence.split("\n").join('; ')
+          index = opts[:r]
+          index = index.min if index.min == index.max || index.max.nil?
+
+          raise CommandError, "Replay index #{ index } points out to another replay call: `#{ replay_sequence }`"
+        end
+      else
+        false
+      end
+    end
+
+    # Finds history depending on the given switch.
+    #
+    # @return [Pry::Code] if it finds `--all` (or `-a`) switch, returns all
+    #   entries in history. Without the switch returns only the entries from the
+    #   current Pry session.
+    def find_history
+      h = if opts.present?(:all)
+            Pry.history.to_a
+          else
+            Pry.history.to_a.last(Pry.history.session_line_count)
+          end
+      # The last value in history will be the 'hist' command itself.
+      Pry::Code(h[0..-2])
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::Hist)
+  Pry::Commands.alias_command 'history', 'hist'
+end