pry 0.9.10 → 0.9.11

data/lib/pry/default_commands/find_method.rb

@@ -1,169 +0,0 @@
-class Pry
-  module DefaultCommands
-    FindMethod = Pry::CommandSet.new do
-
-      create_command "find-method" do
-        extend Helpers::BaseHelpers
-
-        group "Context"
-
-        options :requires_gem => "ruby18_source_location" if mri_18?
-
-        description "Recursively search for a method within a Class/Module or the current namespace. find-method [-n | -c] METHOD [NAMESPACE]"
-
-        banner <<-BANNER
-          Usage: find-method  [-n | -c] METHOD [NAMESPACE]
-
-          Recursively search for a method within a Class/Module or the current namespace.
-          Use the `-n` switch (the default) to search for methods whose name matches the given regex.
-          Use the `-c` switch to search for methods that contain the given code.
-
-          e.g find-method re Pry                # find all methods whose name match /re/ inside the Pry namespace. Matches Pry#repl, etc.
-          e.g find-method -c 'output.puts' Pry  # find all methods that contain the code: output.puts inside the Pry namepsace.
-        BANNER
-
-        def setup
-          require 'ruby18_source_location' if mri_18?
-        end
-
-        def options(opti)
-          opti.on :n, :name, "Search for a method by name"
-          opti.on :c, :content, "Search for a method based on content in Regex form"
-        end
-
-        def process
-          return if args.size < 1
-          pattern = ::Regexp.new args[0]
-          if args[1]
-            klass = target.eval(args[1])
-            if !klass.is_a?(Module)
-              klass = klass.class
-            end
-          else
-            klass = (target_self.is_a?(Module)) ? target_self : target_self.class
-          end
-
-          matches = if opts.content?
-                      content_search(pattern, klass)
-                    else
-                      name_search(pattern, klass)
-                    end
-
-          if matches.empty?
-            output.puts text.bold("No Methods Matched")
-          else
-            print_matches(matches, pattern)
-          end
-
-        end
-
-        private
-
-        # pretty-print a list of matching methods.
-        #
-        # @param Array[Method]
-        def print_matches(matches, pattern)
-          grouped = matches.group_by(&:owner)
-          order = grouped.keys.sort_by{ |x| x.name || x.to_s }
-
-          order.each do |klass|
-            output.puts text.bold(klass.name)
-            grouped[klass].each do |method|
-              header = method.name_with_owner
-
-              extra = if opts.content?
-                        header += ": "
-                        colorize_code((method.source.split(/\n/).select {|x| x =~ pattern }).join("\n#{' ' * header.length}"))
-                      else
-                        ""
-                      end
-
-              output.puts header + extra
-            end
-          end
-        end
-
-        # Run the given block against every constant in the provided namespace.
-        #
-        # @param Module  The namespace in which to start the search.
-        # @param Hash[Module,Boolean]  The namespaces we've already visited (private)
-        # @yieldparam klazz  Each class/module in the namespace.
-        #
-        def recurse_namespace(klass, done={}, &block)
-          return if !(Module === klass) || done[klass]
-
-          done[klass] = true
-
-          yield klass
-
-          klass.constants.each do |name|
-            next if klass.autoload?(name)
-            begin
-              const = klass.const_get(name)
-            rescue RescuableException
-              # constant loading is an inexact science at the best of times,
-              # this often happens when a constant was .autoload? but someone
-              # tried to load it. It's now not .autoload? but will still raise
-              # a NameError when you access it.
-            else
-              recurse_namespace(const, done, &block)
-            end
-          end
-        end
-
-        # Gather all the methods in a namespace that pass the given block.
-        #
-        # @param Module  The namespace in which to search.
-        # @yieldparam Method  The method to test
-        # @yieldreturn Boolean
-        # @return Array[Method]
-        #
-        def search_all_methods(namespace)
-          done = Hash.new{ |h,k| h[k] = {} }
-          matches = []
-
-          recurse_namespace(namespace) do |klass|
-            (Pry::Method.all_from_class(klass) + Pry::Method.all_from_obj(klass)).each do |method|
-              next if done[method.owner][method.name]
-              done[method.owner][method.name] = true
-
-              matches << method if yield method
-            end
-          end
-
-          matches
-        end
-
-        # Search for all methods with a name that matches the given regex
-        # within a namespace.
-        #
-        # @param Regex  The regex to search for
-        # @param Module  The namespace to search
-        # @return Array[Method]
-        #
-        def name_search(regex, namespace)
-          search_all_methods(namespace) do |meth|
-            meth.name =~ regex
-          end
-        end
-
-        # Search for all methods who's implementation matches the given regex
-        # within a namespace.
-        #
-        # @param Regex  The regex to search for
-        # @param Module  The namespace to search
-        # @return Array[Method]
-        #
-        def content_search(regex, namespace)
-          search_all_methods(namespace) do |meth|
-            begin
-              meth.source =~ regex
-            rescue RescuableException
-              false
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/pry/default_commands/gems.rb

@@ -1,84 +0,0 @@
-class Pry
-  module DefaultCommands
-
-    Gems = Pry::CommandSet.new do
-
-      create_command "gem-install", "Install a gem and refresh the gem cache.", :argument_required => true do |gem|
-
-        banner <<-BANNER
-          Usage: gem-install GEM_NAME
-
-          Installs the given gem and refreshes the gem cache so that you can immediately 'require GEM_FILE'
-        BANNER
-
-        def setup
-          require 'rubygems/dependency_installer' unless defined? Gem::DependencyInstaller
-        end
-
-        def process(gem)
-          begin
-            destination = File.writable?(Gem.dir) ? Gem.dir : Gem.user_dir
-            installer = Gem::DependencyInstaller.new :install_dir => destination
-            installer.install gem
-          rescue Errno::EACCES
-            raise CommandError, "Insufficient permissions to install `#{text.green gem}`."
-          rescue Gem::GemNotFoundException
-            raise CommandError, "Gem `#{text.green gem}` not found."
-          else
-            Gem.refresh
-            output.puts "Gem `#{text.green gem}` installed."
-          end
-        end
-      end
-
-      create_command "gem-cd", "Change working directory to specified gem's directory.", :argument_required => true do |gem|
-        banner <<-BANNER
-          Usage: gem-cd GEM_NAME
-
-          Change the current working directory to that in which the given gem is installed.
-        BANNER
-
-        def process(gem)
-          specs = Gem::Specification.respond_to?(:each) ? Gem::Specification.find_all_by_name(gem) : Gem.source_index.find_name(gem)
-          spec  = specs.sort { |a,b| Gem::Version.new(b.version) <=> Gem::Version.new(a.version) }.first
-          if spec
-            Dir.chdir(spec.full_gem_path)
-            output.puts(Dir.pwd)
-          else
-            raise CommandError, "Gem `#{gem}` not found."
-          end
-        end
-      end
-
-      create_command "gem-list", "List and search installed gems." do |pattern|
-        banner <<-BANNER
-          Usage: gem-list [REGEX]
-
-          List all installed gems, when a regex is provided, limit the output to those that
-          match the regex.
-        BANNER
-
-        def process(pattern=nil)
-          pattern = Regexp.compile(pattern || '')
-          gems    = if Gem::Specification.respond_to?(:each)
-                      Gem::Specification.select{|spec| spec.name =~ pattern }.group_by(&:name)
-                    else
-                      Gem.source_index.gems.values.group_by(&:name).select { |gemname, specs| gemname =~ pattern }
-                    end
-
-          gems.each do |gem, specs|
-            specs.sort! do |a,b|
-              Gem::Version.new(b.version) <=> Gem::Version.new(a.version)
-            end
-
-            versions = specs.each_with_index.map do |spec, index|
-              index == 0 ? text.bright_green(spec.version.to_s) : text.green(spec.version.to_s)
-            end
-
-            output.puts "#{text.default gem} (#{versions.join ', '})"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/pry/default_commands/gist.rb

@@ -1,187 +0,0 @@
-class Pry
-  module DefaultCommands
-    Gist = Pry::CommandSet.new do
-      create_command "gist", "Gist a method or expression history to GitHub.", :requires_gem => "jist" do
-        include Pry::Helpers::DocumentationHelpers
-
-        banner <<-USAGE
-          Usage: gist [OPTIONS] [METH]
-          Gist method (doc or source) or input expression to GitHub.
-
-          If you'd like to permanently associate your gists with your GitHub account run `gist --login`.
-
-          e.g: gist -m my_method       # gist the method my_method
-          e.g: gist -d my_method       # gist the documentation for my_method
-          e.g: gist -i 1..10           # gist the input expressions from 1 to 10
-          e.g: gist -k show-method     # gist the command show-method
-          e.g: gist -c Pry             # gist the Pry class
-          e.g: gist -m hello_world --lines 2..-2    # gist from lines 2 to the second-last of the hello_world method
-          e.g: gist -m my_method --clip             # Copy my_method source to clipboard, do not gist it.
-        USAGE
-
-        command_options :shellwords => false
-
-        attr_accessor :content
-        attr_accessor :filename
-
-        def setup
-          require 'jist'
-          self.content   = ""
-          self.filename  = "a.rb"
-        end
-
-        def options(opt)
-          opt.on :login, "Authenticate the jist gem with GitHub"
-          opt.on :m, :method, "Gist a method's source.", :argument => true do |meth_name|
-            meth = get_method_or_raise(meth_name, target, {})
-            self.content << meth.source << "\n"
-            self.filename = meth.source_file
-          end
-          opt.on :d, :doc, "Gist a method's documentation.", :argument => true do |meth_name|
-            meth = get_method_or_raise(meth_name, target, {})
-            text.no_color do
-              self.content << process_comment_markup(meth.doc) << "\n"
-            end
-            self.filename = meth.source_file + ".doc"
-          end
-          opt.on :k, :command, "Gist a command's source.", :argument => true do |command_name|
-            command = find_command(command_name)
-            block = Pry::Method.new(command.block)
-            self.content << block.source << "\n"
-            self.filename = block.source_file
-          end
-          opt.on :c, :class, "Gist a class or module's source.", :argument => true do |class_name|
-            mod = Pry::WrappedModule.from_str(class_name, target)
-            self.content << mod.source << "\n"
-            self.filename = mod.source_file
-          end
-          opt.on :var, "Gist a variable's content.", :argument => true do |variable_name|
-            begin
-              obj = target.eval(variable_name)
-            rescue Pry::RescuableException
-              raise CommandError, "Gist failed: Invalid variable name: #{variable_name}"
-            end
-
-            self.content << Pry.config.gist.inspecter.call(obj) << "\n"
-          end
-          opt.on :hist, "Gist a range of Readline history lines.",  :optional_argument => true, :as => Range, :default => -20..-1 do |range|
-            h = Pry.history.to_a
-            self.content << h[one_index_range(convert_to_range(range))].join("\n") << "\n"
-          end
-
-          opt.on :f, :file, "Gist a file.", :argument => true do |file|
-            self.content << File.read(File.expand_path(file)) << "\n"
-            self.filename = file
-          end
-          opt.on :o, :out, "Gist entries from Pry's output result history. Takes an index or range.", :optional_argument => true,
-          :as => Range, :default => -1 do |range|
-            range = convert_to_range(range)
-
-            range.each do |v|
-              self.content << Pry.config.gist.inspecter.call(_pry_.output_array[v])
-            end
-
-            self.content << "\n"
-          end
-          opt.on :clip, "Copy the selected content to clipboard instead, do NOT gist it.", :default => false
-          opt.on :p, :public, "Create a public gist (default: false)", :default => false
-          opt.on :l, :lines, "Only gist a subset of lines from the gistable content.", :optional_argument => true, :as => Range, :default => 1..-1
-          opt.on :i, :in, "Gist entries from Pry's input expression history. Takes an index or range.", :optional_argument => true,
-          :as => Range, :default => -1 do |range|
-            range = convert_to_range(range)
-            input_expressions = _pry_.input_array[range] || []
-            Array(input_expressions).each_with_index 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
-        end
-
-        def process
-          return Jist.login! if opts.present?(:login)
-
-          if self.content =~ /\A\s*\z/
-            raise CommandError, "Found no code to gist."
-          end
-
-          if opts.present?(:clip)
-            perform_clipboard
-          else
-            perform_gist
-          end
-        end
-
-        # copy content to clipboard instead (only used with --clip flag)
-        def perform_clipboard
-          copy(self.content)
-          output.puts "Copied content to clipboard!"
-        end
-
-        def perform_gist
-          if opts.present?(:lines)
-            self.content = restrict_to_lines(content, opts[:l])
-          end
-
-          response = Jist.gist(content, :filename => File.basename(filename),
-                                        :public => !!opts[:p])
-
-          if response
-            copy(response['html_url'])
-            output.puts "Gist created at #{response['html_url']} and added to clipboard."
-          end
-        end
-
-        def convert_to_range(n)
-          if !n.is_a?(Range)
-            (n..n)
-          else
-            n
-          end
-        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
-
-        # Copy a string to the clipboard.
-        #
-        # @param [String] content
-        #
-        # @copyright Copyright (c) 2008 Chris Wanstrath (MIT)
-        # @see https://github.com/defunkt/gist/blob/master/lib/gist.rb#L178
-        def copy(content)
-          cmd = case true
-          when system("type pbcopy > /dev/null 2>&1")
-            :pbcopy
-          when system("type xclip > /dev/null 2>&1")
-            :xclip
-          when system("type putclip > /dev/null 2>&1")
-            :putclip
-          end
-
-          if cmd
-            IO.popen(cmd.to_s, 'r+') { |clip| clip.print content }
-          end
-
-          content
-        end
-      end
-
-      alias_command "clipit", "gist --clip"
-      alias_command "jist", "gist"
-    end
-  end
-end

data/lib/pry/default_commands/help.rb

@@ -1,127 +0,0 @@
-class Pry
-  module DefaultCommands
-    Help = Pry::CommandSet.new do
-      create_command "help" do |cmd|
-        description "Show a list of commands. Type `help <foo>` for information about <foo>."
-
-        banner <<-BANNER
-          Usage: help [ COMMAND ]
-
-          With no arguments, help lists all the available commands in the current
-          command-set along with their description.
-
-          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]]
-        def display_index(groups)
-          help_text = []
-
-          groups.keys.sort_by(&method(:group_sort_key)).each do |key|
-            commands = groups[key].sort_by{ |command| command.options[:listing].to_s }
-
-            unless commands.empty?
-              help_text << "#{text.bold(key)}\n" + commands.map do |command|
-                "  #{command.options[:listing].to_s.ljust(18)} #{command.description}"
-              end.join("\n")
-            end
-          end
-
-          stagger_output(help_text.join("\n\n"))
-        end
-
-        # Display help for an individual command or group.
-        #
-        # @param String  The string to search for.
-        def display_search(search)
-          if command = command_set.find_command_for_help(search)
-            display_command(command)
-          else
-            groups = search_hash(search, command_groups)
-
-            if groups.size > 0
-              display_index(groups)
-              return
-            end
-
-            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 an individual command.
-        #
-        # @param [Pry::Command]
-        def display_command(command)
-          stagger_output 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]  the search term
-        # @param [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
-        # @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
-    end
-  end
-end