pry 0.9.12.2 → 0.14.2

data/lib/pry/commands/gem_install.rb

@@ -1,29 +0,0 @@
-class Pry
-  class Command::GemInstall < Pry::ClassCommand
-    match 'gem-install'
-    group 'Gems'
-    description 'Install a gem and refresh the gem cache.'
-    command_options :argument_required => true
-
-    banner <<-'BANNER'
-      Usage: gem-install GEM_NAME
-
-      Installs the given gem and refreshes the gem cache so that you can immediately
-      'require GEM_FILE'.
-
-      gem-install pry-stack_explorer
-    BANNER
-
-    def setup
-      require 'rubygems/dependency_installer' unless defined? Gem::DependencyInstaller
-    end
-
-    def process(gem)
-      Rubygem.install(gem)
-      output.puts "Gem `#{ text.green(gem) }` installed."
-      require gem
-    end
-  end
-
-  Pry::Commands.add_command(Pry::Command::GemInstall)
-end

data/lib/pry/commands/gem_list.rb

@@ -1,33 +0,0 @@
-class Pry
-  class Command::GemList < Pry::ClassCommand
-    match 'gem-list'
-    group 'Gems'
-    description 'List and search installed gems.'
-
-    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    = Rubygem.list(pattern).group_by(&:name)
-
-      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
-
-  Pry::Commands.add_command(Pry::Command::GemList)
-end

data/lib/pry/commands/gem_open.rb

@@ -1,29 +0,0 @@
-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

@@ -1,102 +0,0 @@
-class Pry
-  class Command::Gist < Pry::ClassCommand
-    match 'gist'
-    group 'Misc'
-    description 'Playback a string variable or a method or a file as input.'
-    command_options :requires_gem => "jist"
-
-    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 'jist'
-    end
-
-    def options(opt)
-      CodeCollector.inject_options(opt)
-      opt.on :login, "Authenticate the jist 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 Jist.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)
-      Jist.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 = Jist.gist(content, :filename => filename || "pry_gist.rb", :public => !!opts[:p])
-      if response
-        url = response['html_url']
-        message = "Gist created at URL #{url}"
-        begin
-          Jist.copy(url)
-          message << ", which is now in the clipboard."
-        rescue Jist::ClipboardError
-        end
-
-        output.puts message
-      end
-    end
-  end
-
-  Pry::Commands.add_command(Pry::Command::Gist)
-  Pry::Commands.alias_command 'clipit', 'gist --clip'
-  Pry::Commands.alias_command 'jist', 'gist'
-end

data/lib/pry/commands/install_command.rb

@@ -1,51 +0,0 @@
-class Pry
-  class Command::InstallCommand < Pry::ClassCommand
-    match 'install-command'
-    group 'Commands'
-    description 'Install a disabled command.'
-
-    banner <<-'BANNER'
-      Usage: install-command COMMAND
-
-      Installs the gems necessary to run the given COMMAND. You will generally not
-      need to run this unless told to by an error message.
-    BANNER
-
-    def process(name)
-      require 'rubygems/dependency_installer' unless defined? Gem::DependencyInstaller
-      command = find_command(name)
-
-      if command_dependencies_met?(command.options)
-        output.puts "Dependencies for #{command.name} are met. Nothing to do."
-        return
-      end
-
-      output.puts "Attempting to install `#{name}` command..."
-      gems_to_install = Array(command.options[:requires_gem])
-
-      gems_to_install.each do |g|
-        next if Rubygem.installed?(g)
-        output.puts "Installing `#{g}` gem..."
-
-        begin
-          Gem::DependencyInstaller.new.install(g)
-        rescue Gem::GemNotFoundException
-          raise CommandError, "Required Gem: `#{g}` not found. Aborting command installation."
-        end
-      end
-
-      Gem.refresh
-      gems_to_install.each do |g|
-        begin
-          require g
-        rescue LoadError
-          raise CommandError, "Required Gem: `#{g}` installed but not found?!. Aborting command installation."
-        end
-      end
-
-      output.puts "Installation of `#{name}` successful! Type `help #{name}` for information"
-    end
-  end
-
-  Pry::Commands.add_command(Pry::Command::InstallCommand)
-end

data/lib/pry/commands/simple_prompt.rb

@@ -1,22 +0,0 @@
-class Pry
-  class Command::SimplePrompt < Pry::ClassCommand
-    match 'simple-prompt'
-    group 'Misc'
-    description 'Toggle the simple prompt.'
-
-    banner <<-'BANNER'
-      Toggle the simple prompt.
-    BANNER
-
-    def process
-      case _pry_.prompt
-      when Pry::SIMPLE_PROMPT
-        _pry_.pop_prompt
-      else
-        _pry_.push_prompt Pry::SIMPLE_PROMPT
-      end
-    end
-  end
-
-  Pry::Commands.add_command(Pry::Command::SimplePrompt)
-end

data/lib/pry/commands.rb

@@ -1,6 +0,0 @@
-# Default commands used by Pry.
-Pry::Commands = Pry::CommandSet.new
-
-Dir[File.expand_path('../commands', __FILE__) + '/*.rb'].each do |file|
-  require file
-end

data/lib/pry/completion.rb

@@ -1,304 +0,0 @@
-# taken from irb
-
-class Pry
-
-  module BondCompleter
-
-    def self.build_completion_proc(target, pry=nil, commands=[""])
-      if !@started
-        @started = true
-        start
-      end
-
-      Pry.current[:pry] = pry
-      proc{ |*a| Bond.agent.call(*a) }
-    end
-
-    def self.start
-      Bond.start(:eval_binding => lambda{ Pry.current[:pry].current_context })
-      Bond.complete(:on => /\A/) do |input|
-        Pry.commands.complete(input.line,
-                             :pry_instance => Pry.current[:pry],
-                             :target       => Pry.current[:pry].current_context,
-                             :command_set  => Pry.current[:pry].commands)
-      end
-    end
-
-  end
-
-  # Implements tab completion for Readline in Pry
-  module InputCompleter
-
-    if Readline.respond_to?("basic_word_break_characters=")
-      Readline.basic_word_break_characters = " \t\n\"\\'`><=;|&{("
-    end
-
-    Readline.completion_append_character = nil
-
-    ReservedWords = [
-      "BEGIN", "END",
-      "alias", "and",
-      "begin", "break",
-      "case", "class",
-      "def", "defined", "do",
-      "else", "elsif", "end", "ensure",
-      "false", "for",
-      "if", "in",
-      "module",
-      "next", "nil", "not",
-      "or",
-      "redo", "rescue", "retry", "return",
-      "self", "super",
-      "then", "true",
-      "undef", "unless", "until",
-      "when", "while",
-      "yield" ]
-
-    Operators = [
-      "%", "&", "*", "**", "+",  "-",  "/",
-      "<", "<<", "<=", "<=>", "==", "===", "=~", ">", ">=", ">>",
-      "[]", "[]=", "^", "!", "!=", "!~"
-    ]
-
-    # Return a new completion proc for use by Readline.
-    # @param [Binding] target The current binding context.
-    # @param [Array<String>] commands The array of Pry commands.
-    def self.build_completion_proc(target, pry=nil, commands=[""])
-
-      proc do |input|
-
-        # if there are multiple contexts e.g. cd 1/2/3
-        # get new target for 1/2 and find candidates for 3
-        path, input = build_path(input)
-
-        # We silence warnings here or Ruby 1.8 cries about "multiple values for
-        # block 0 for 1".
-        Helpers::BaseHelpers.silence_warnings do
-          unless path.call.empty?
-            target = begin
-              ctx = Helpers::BaseHelpers.context_from_object_path(path.call, pry)
-              ctx.first
-            rescue Pry::CommandError
-              []
-            end
-            target = target.last
-          end
-        end
-
-        begin
-          bind = target
-
-          case input
-
-
-          # Complete stdlib symbols
-
-          when /^(\/[^\/]*\/)\.([^.]*)$/
-            # Regexp
-            receiver = $1
-            message = Regexp.quote($2)
-
-            candidates = Regexp.instance_methods.collect(&:to_s)
-            select_message(path, receiver, message, candidates)
-
-          when /^([^\]]*\])\.([^.]*)$/
-            # Array
-            receiver = $1
-            message = Regexp.quote($2)
-
-            candidates = Array.instance_methods.collect(&:to_s)
-            select_message(path, receiver, message, candidates)
-
-          when /^([^\}]*\})\.([^.]*)$/
-            # Proc or Hash
-            receiver = $1
-            message = Regexp.quote($2)
-
-            candidates = Proc.instance_methods.collect(&:to_s)
-            candidates |= Hash.instance_methods.collect(&:to_s)
-            select_message(path, receiver, message, candidates)
-
-          when /^(:[^:.]*)$/
-            # Symbol
-            if Symbol.respond_to?(:all_symbols)
-              sym        = Regexp.quote($1)
-              candidates = Symbol.all_symbols.collect{|s| ":" + s.id2name}
-
-              candidates.grep(/^#{sym}/)
-            else
-              []
-            end
-
-          when /^::([A-Z][^:\.\(]*)$/
-            # Absolute Constant or class methods
-            receiver = $1
-            candidates = Object.constants.collect(&:to_s)
-            candidates.grep(/^#{receiver}/).collect{|e| "::" + e}
-
-
-          # Complete target symbols
-
-          when /^([A-Z][A-Za-z0-9]*)$/
-            # Constant
-            message = $1
-
-            begin
-              context = target.eval("self")
-              context = context.class unless context.respond_to? :constants
-              candidates = context.constants.collect(&:to_s)
-            rescue
-              candidates = []
-            end
-            candidates = candidates.grep(/^#{message}/).collect(&path)
-
-          when /^([A-Z].*)::([^:.]*)$/
-            # Constant or class methods
-            receiver = $1
-            message = Regexp.quote($2)
-            begin
-              candidates = eval("#{receiver}.constants.collect(&:to_s)", bind)
-              candidates |= eval("#{receiver}.methods.collect(&:to_s)", bind)
-            rescue RescuableException
-              candidates = []
-            end
-            candidates.grep(/^#{message}/).collect{|e| receiver + "::" + e}
-
-          when /^(:[^:.]+)\.([^.]*)$/
-            # Symbol
-            receiver = $1
-            message = Regexp.quote($2)
-
-            candidates = Symbol.instance_methods.collect(&:to_s)
-            select_message(path, receiver, message, candidates)
-
-          when /^(-?(0[dbo])?[0-9_]+(\.[0-9_]+)?([eE]-?[0-9]+)?)\.([^.]*)$/
-            # Numeric
-            receiver = $1
-            message = Regexp.quote($5)
-
-            begin
-              candidates = eval(receiver, bind).methods.collect(&:to_s)
-            rescue RescuableException
-              candidates = []
-            end
-            select_message(path, receiver, message, candidates)
-
-          when /^(-?0x[0-9a-fA-F_]+)\.([^.]*)$/#
-            # Numeric(0xFFFF)
-            receiver = $1
-            message = Regexp.quote($2)
-
-            begin
-              candidates = eval(receiver, bind).methods.collect(&:to_s)
-            rescue RescuableException
-              candidates = []
-            end
-            select_message(path, receiver, message, candidates)
-
-          when /^(\$[^.]*)$/
-            # Global variables
-            regmessage = Regexp.new(Regexp.quote($1))
-            candidates = global_variables.collect(&:to_s).grep(regmessage)
-
-          when /^([^."].*)\.([^.]*)$/
-            # Variable
-            receiver = $1
-            message = Regexp.quote($2)
-
-            gv = eval("global_variables", bind).collect(&:to_s)
-            lv = eval("local_variables", bind).collect(&:to_s)
-            cv = eval("self.class.constants", bind).collect(&:to_s)
-
-            if (gv | lv | cv).include?(receiver) or /^[A-Z]/ =~ receiver && /\./ !~ receiver
-              # foo.func and foo is local var. OR
-              # Foo::Bar.func
-              begin
-                candidates = eval("#{receiver}.methods", bind).collect(&:to_s)
-              rescue RescuableException
-                candidates = []
-              end
-            else
-              # func1.func2
-              candidates = []
-              ObjectSpace.each_object(Module){|m|
-                begin
-                  name = m.name.to_s
-                rescue RescuableException
-                  name = ""
-                end
-                next if name != "IRB::Context" and
-                /^(IRB|SLex|RubyLex|RubyToken)/ =~ name
-
-                # jruby doesn't always provide #instance_methods() on each
-                # object.
-                if m.respond_to?(:instance_methods)
-                  candidates.concat m.instance_methods(false).collect(&:to_s)
-                end
-              }
-              candidates.sort!
-              candidates.uniq!
-            end
-            select_message(path, receiver, message, candidates)
-
-          when /^\.([^.]*)$/
-            # Unknown(maybe String)
-            receiver = ""
-            message = Regexp.quote($1)
-
-            candidates = String.instance_methods(true).collect(&:to_s)
-            select_message(path, receiver, message, candidates)
-
-          else
-
-            candidates = eval(
-              "methods | private_methods | local_variables | " \
-                "self.class.constants | instance_variables",
-              bind
-            ).collect(&:to_s)
-
-            if eval("respond_to?(:class_variables)", bind)
-              candidates += eval("class_variables", bind).collect(&:to_s)
-            end
-            candidates = (candidates|ReservedWords|commands).grep(/^#{Regexp.quote(input)}/)
-            candidates.collect(&path)
-          end
-        rescue RescuableException
-          []
-        end
-      end
-    end
-
-    def self.select_message(path, receiver, message, candidates)
-      candidates.grep(/^#{message}/).collect { |e|
-        case e
-        when /^[a-zA-Z_]/
-          path.call(receiver + "." + e)
-        when /^[0-9]/
-        when *Operators
-          #receiver + " " + e
-        end
-      }.compact
-    end
-
-    # build_path seperates the input into two parts: path and input.
-    # input is the partial string that should be completed
-    # path is a proc that takes an input and builds a full path.
-    def self.build_path(input)
-
-      # check to see if the input is a regex
-      return proc {|input| input.to_s }, input if input[/\/\./]
-
-      trailing_slash = input.end_with?('/')
-      contexts = input.chomp('/').split(/\//)
-      input = contexts[-1]
-
-      path = Proc.new do |input|
-        p = contexts[0..-2].push(input).join('/')
-        p += '/' if trailing_slash && !input.nil?
-        p
-      end
-
-      return path, input
-    end
-  end
-end

data/lib/pry/custom_completions.rb

@@ -1,6 +0,0 @@
-class Pry
-
-  # This proc will be instance_eval's against the active Pry instance
-  DEFAULT_CUSTOM_COMPLETIONS = proc { commands.commands.keys }
-  FILE_COMPLETIONS = proc { commands.commands.keys + Dir.entries('.') }
-end

data/lib/pry/history_array.rb

@@ -1,116 +0,0 @@
-class Pry
-  # A history array is an array to which you can only add elements. Older
-  # entries are removed progressively, so that the aray never contains more than
-  # N elements.
-  #
-  # History arrays are used by Pry to store the output of the last commands.
-  #
-  # @example
-  #   ary = Pry::HistoryArray.new 10
-  #   ary << 1 << 2 << 3
-  #   ary[0] # => 1
-  #   ary[1] # => 2
-  #   10.times { |n| ary << n }
-  #   ary[0] # => nil
-  #   ary[-1] # => 9
-  class HistoryArray
-    include Enumerable
-
-    # @param [Integer] size Maximum amount of objects in the array
-    def initialize(size)
-      @max_size = size
-
-      @hash  = {}
-      @count = 0
-    end
-
-    # Pushes an object at the end of the array
-    # @param [Object] value Object to be added
-    def <<(value)
-      @hash[@count] = value
-
-      if @hash.size > max_size
-        @hash.delete(@count - max_size)
-      end
-
-      @count += 1
-
-      self
-    end
-
-    # @overload [](index)
-    #   @param [Integer] index Index of the item to access.
-    #   @return [Object, nil] Item at that index or nil if it has been removed.
-    # @overload [](index, size)
-    #   @param [Integer] index Index of the first item to access.
-    #   @param [Integer] size Amount of items to access
-    #   @return [Array, nil] The selected items. Nil if index is greater than
-    #     the size of the array.
-    # @overload [](range)
-    #   @param [Range<Integer>] range Range of indices to access.
-    #   @return [Array, nil] The selected items. Nil if index is greater than
-    #     the size of the array.
-    def [](index_or_range, size = nil)
-      if index_or_range.is_a? Integer
-        index = convert_index(index_or_range)
-
-        if size
-          end_index = index + size
-          index > @count ? nil : (index...[end_index, @count].min).map do |n|
-            @hash[n]
-          end
-        else
-          @hash[index]
-        end
-      else
-        range = convert_range(index_or_range)
-        range.begin > @count ? nil : range.map { |n| @hash[n] }
-      end
-    end
-
-    # @return [Integer] Amount of objects in the array
-    def size
-      @count
-    end
-    alias count size
-    alias length size
-
-    def empty?
-      size == 0
-    end
-
-    def each
-      ((@count - size)...@count).each do |n|
-        yield @hash[n]
-      end
-    end
-
-    def to_a
-      ((@count - size)...@count).map { |n| @hash[n] }
-    end
-
-    def pop!
-      @hash.delete @count - 1
-      @count -= 1
-    end
-
-    def inspect
-      "#<#{self.class} size=#{size} first=#{@count - size} max_size=#{max_size}>"
-    end
-
-    # @return [Integer] Maximum amount of objects in the array
-    attr_reader :max_size
-
-    private
-    def convert_index(n)
-      n >= 0 ? n : @count + n
-    end
-
-    def convert_range(range)
-      end_index = convert_index(range.end)
-      end_index += 1 unless range.exclude_end?
-
-      Range.new(convert_index(range.begin), [end_index, @count].min, true)
-    end
-  end
-end