pry 0.12.2-java → 0.13.0-java

data/lib/pry/commands/fix_indent.rb

@@ -1,19 +1,23 @@
+# frozen_string_literal: true
+
 class Pry
-  class Command::FixIndent < Pry::ClassCommand
-    match 'fix-indent'
-    group 'Input and Output'
+  class Command
+    class FixIndent < Pry::ClassCommand
+      match 'fix-indent'
+      group 'Input and Output'
 
-    description "Correct the indentation for contents of the input buffer"
+      description "Correct the indentation for contents of the input buffer"
 
-    banner <<-USAGE
-      Usage: fix-indent
-    USAGE
+      banner <<-USAGE
+        Usage: fix-indent
+      USAGE
 
-    def process
-      indented_str = Pry::Indent.indent(eval_string)
-      eval_string.replace indented_str
+      def process
+        indented_str = Pry::Indent.indent(eval_string)
+        pry_instance.eval_string = indented_str
+      end
     end
-  end
 
-  Pry::Commands.add_command(Pry::Command::FixIndent)
+    Pry::Commands.add_command(Pry::Command::FixIndent)
+  end
 end

data/lib/pry/commands/help.rb

@@ -1,164 +1,171 @@
+# frozen_string_literal: true
+
 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?
+  class Command
+    class 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
-      visible
-    end
 
-    # Get a hash of available commands grouped by the "group" name.
-    def command_groups
-      visible_commands.values.group_by(&:group)
-    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)
+      def process
+        if args.empty?
+          display_index(command_groups)
+        else
+          display_search(args.first)
+        end
       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 = []
+      # 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])
+        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)
+          help_text << help_text_for_commands(group_name, commands) if commands.any?
         end
+
+        pry_instance.pager.page help_text.join("\n\n")
       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)
+        "#{bold(name.capitalize)}\n" + commands.map do |command|
+          "  #{command.options[:listing].to_s.ljust(18)} " \
+          "#{command.description.capitalize}"
+        end.join("\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)
-      "#{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
 
-    # @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
 
-    # 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 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)
+      # 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.empty?
+          display_index(groups)
+        else
+          display_filtered_commands(search)
+        end
       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)
+      # 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
-    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})
+      # Display help for an individual command.
+      #
+      # @param [Pry::Command] command
+      def display_command(command)
+        pry_instance.pager.page command.new.help
       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)
+          return { key => value } if normalize(key) == normalize(search)
+          next unless normalize(key).start_with?(normalize(search))
 
-    # 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
+
+        matching
       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
 
-    # Clean search terms to make it easier to search group names
-    #
-    # @param [String] key
-    # @return [String]
-    def normalize(key)
-      key.downcase.gsub(/pry\W+/, '')
+      def group_sort_key(group_name)
+        [
+          %w[
+            Help Context Editing Introspection Input_and_output Navigating_pry
+            Gems Basic Commands
+          ].index(group_name.tr(' ', '_')) || 99, group_name
+        ]
+      end
     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
+    Pry::Commands.add_command(Pry::Command::Help)
   end
-
-  Pry::Commands.add_command(Pry::Command::Help)
 end

data/lib/pry/commands/hist.rb

@@ -1,181 +1,182 @@
-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
+# frozen_string_literal: true
 
-      if opts.present?(:show)
-        @history = @history.between(opts[:show])
+class Pry
+  class Command
+    class 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
 
-      if opts.present?(:grep)
-        @history = @history.grep(opts[:grep])
-      end
+      def process
+        @history = find_history
 
-      @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
+        @history = @history.between(opts[:show]) if opts.present?(:show)
 
-      if opts.present?(:'exclude-pry')
-        @history = @history.select do |loc|
-                     !command_set.valid_command?(loc.line)
-                   end
-      end
+        @history = @history.grep(opts[:grep]) if opts.present?(:grep)
 
-      if opts.present?(:save)
-        process_save
-      elsif opts.present?(:clear)
-        process_clear
-      elsif opts.present?(:replay)
-        process_replay
-      else
-        process_display
-      end
-    end
+        @history =
+          if opts.present?(:head)
+            @history.take_lines(1, opts[:head] || 10)
+          elsif opts.present?(:tail)
+            @history.take_lines(-(opts[:tail] || 10), opts[:tail] || 10)
+          else
+            @history
+          end
 
-    private
+        if opts.present?(:'exclude-pry')
+          @history = @history.reject do |loc|
+            command_set.valid_command?(loc.line)
+          end
+        end
 
-    def process_display
-      unless opts.present?(:'no-numbers')
-        @history = @history.with_line_numbers
+        if opts.present?(:save)
+          process_save
+        elsif opts.present?(:clear)
+          process_clear
+        elsif opts.present?(:replay)
+          process_replay
+        else
+          process_display
+        end
       end
 
-      _pry_.pager.open do |pager|
-        @history.print_to_output(pager, true)
-      end
-    end
+      private
 
-    def process_save
-      case opts[:save]
-      when Range
-        @history = @history.between(opts[:save])
+      def process_display
+        @history = @history.with_line_numbers unless opts.present?(:'no-numbers')
 
-        unless args.first
-          raise CommandError, "Must provide a file name."
+        pry_instance.pager.open do |pager|
+          @history.print_to_output(pager, true)
         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}..."
+      def process_save
+        case opts[:save]
+        when Range
+          @history = @history.between(opts[:save])
 
-      File.open(file_name, 'w') { |f| f.write(@history.raw) }
+          raise CommandError, "Must provide a file name." unless args.first
 
-      output.puts "History saved."
-    end
+          file_name = File.expand_path(args.first)
+        when String
+          file_name = File.expand_path(opts[:save])
+        end
 
-    def process_clear
-      Pry.history.clear
-      output.puts "History cleared."
-    end
+        output.puts "Saving history in #{file_name}..."
 
-    def process_replay
-      @history = @history.between(opts[:r])
-      replay_sequence = @history.raw
+        File.open(file_name, 'w') { |f| f.write(@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)
+        output.puts "History saved."
+      end
 
-      replay_sequence.lines.each do |line|
-        _pry_.eval line, generated: true
+      def process_clear
+        Pry.history.clear
+        output.puts "History cleared."
       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 }`"
+      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_instance.eval line, generated: true
         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)
+      # 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_instance = slop
+          slop_instance.parse(replay_sequence.split(' ')[1..-1])
+
+          if slop_instance.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
 
-      Pry::Code(Pry.history.filter(h[0..-2]))
+      # 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
+
+        Pry::Code(Pry.history.filter(h[0..-2]))
+      end
     end
-  end
 
-  Pry::Commands.add_command(Pry::Command::Hist)
-  Pry::Commands.alias_command 'history', 'hist'
+    Pry::Commands.add_command(Pry::Command::Hist)
+    Pry::Commands.alias_command 'history', 'hist'
+  end
 end