pry 0.10.4 → 0.14.1

data/lib/pry/config/behavior.rb

@@ -1,139 +0,0 @@
-module Pry::Config::Behavior
-  ASSIGNMENT     = "=".freeze
-  NODUP          = [TrueClass, FalseClass, NilClass, Symbol, Numeric, Module, Proc].freeze
-  INSPECT_REGEXP = /#{Regexp.escape "default=#<"}/
-
-  module Builder
-    def from_hash(hash, default = nil)
-      new(default).tap do |config|
-        config.merge!(hash)
-      end
-    end
-  end
-
-  def self.included(klass)
-    unless defined?(RESERVED_KEYS)
-      const_set :RESERVED_KEYS, instance_methods(false).map(&:to_s).freeze
-    end
-    klass.extend(Builder)
-  end
-
-  def initialize(default = Pry.config)
-    @default = default
-    @lookup = {}
-  end
-
-  #
-  # @return [Pry::Config::Behavior]
-  #   returns the default used if a matching value for a key isn't found in self
-  #
-  def default
-    @default
-  end
-
-  def [](key)
-    @lookup[key.to_s]
-  end
-
-  def []=(key, value)
-    key = key.to_s
-    if RESERVED_KEYS.include?(key)
-      raise ArgumentError, "few things are reserved by pry, but using '#{key}' as a configuration key is."
-    end
-    @lookup[key] = value
-  end
-
-  def method_missing(name, *args, &block)
-    key = name.to_s
-    if key[-1] == ASSIGNMENT
-      short_key = key[0..-2]
-      self[short_key] = args[0]
-    elsif key?(key)
-      self[key]
-    elsif @default.respond_to?(name)
-      value = @default.public_send(name, *args, &block)
-      # FIXME: refactor Pry::Hook so that it stores config on the config object,
-      # so that we can use the normal strategy.
-      self[key] = value = value.dup if key == 'hooks'
-      value
-    else
-      nil
-    end
-  end
-
-  def merge!(other)
-    other = try_convert_to_hash(other)
-    raise TypeError, "unable to convert argument into a Hash" unless other
-    other.each do |key, value|
-      self[key] = value
-    end
-  end
-
-  def ==(other)
-    @lookup == try_convert_to_hash(other)
-  end
-  alias_method :eql?, :==
-
-  def respond_to_missing?(key, include_private=false)
-    key?(key) or @default.respond_to?(key) or super(key, include_private)
-  end
-
-  def key?(key)
-    key = key.to_s
-    @lookup.key?(key)
-  end
-
-  def clear
-    @lookup.clear
-    true
-  end
-  alias_method :refresh, :clear
-
-  def forget(key)
-    @lookup.delete(key.to_s)
-  end
-
-  def keys
-    @lookup.keys
-  end
-
-  def to_hash
-    @lookup.dup
-  end
-  alias_method :to_h, :to_hash
-
-
-  def inspect
-    key_str = keys.map { |key| "'#{key}'" }.join(",")
-    "#<#{_clip_inspect(self)} local_keys=[#{key_str}] default=#{@default.inspect}>"
-  end
-
-  def pretty_print(q)
-    q.text inspect[1..-1].gsub(INSPECT_REGEXP, "default=<")
-  end
-
-private
-  def _clip_inspect(obj)
-    "#{obj.class}:0x%x" % obj.object_id << 1
-  end
-
-  def _dup(value)
-    if NODUP.any? { |klass| klass === value }
-      value
-    else
-      value.dup
-    end
-  end
-
-  def try_convert_to_hash(obj)
-    if Hash === obj
-      obj
-    elsif obj.respond_to?(:to_h)
-      obj.to_h
-    elsif obj.respond_to?(:to_hash)
-      obj.to_hash
-    else
-      nil
-    end
-  end
-end

data/lib/pry/config/convenience.rb

@@ -1,25 +0,0 @@
-module Pry::Config::Convenience
-  SHORTCUTS = [
-               :input,
-               :output,
-               :commands,
-               :print,
-               :exception_handler,
-               :hooks,
-               :color,
-               :pager,
-               :editor,
-               :memory_size,
-               :extra_sticky_locals
-              ]
-
-
-  def config_shortcut(*names)
-    names.each do |name|
-      reader = name
-      setter = "#{name}="
-      define_method(reader) { config.public_send(name) }
-      define_method(setter) { |value| config.public_send(setter, value) }
-    end
-  end
-end

data/lib/pry/config/default.rb

@@ -1,161 +0,0 @@
-class Pry::Config::Default
-  include Pry::Config::Behavior
-
-  default = {
-    input: proc {
-      lazy_readline
-    },
-    output: proc {
-      $stdout
-    },
-    commands: proc {
-      Pry::Commands
-    },
-    prompt_name: proc {
-      Pry::DEFAULT_PROMPT_NAME
-    },
-    prompt: proc {
-      Pry::DEFAULT_PROMPT
-    },
-    prompt_safe_objects: proc {
-      Pry::DEFAULT_PROMPT_SAFE_OBJECTS
-    },
-    print: proc {
-      Pry::DEFAULT_PRINT
-    },
-    quiet: proc {
-      false
-    },
-    exception_handler: proc {
-      Pry::DEFAULT_EXCEPTION_HANDLER
-    },
-    exception_whitelist: proc {
-      Pry::DEFAULT_EXCEPTION_WHITELIST
-    },
-    hooks: proc {
-      Pry::DEFAULT_HOOKS
-    },
-    pager: proc {
-      true
-    },
-    system: proc {
-      Pry::DEFAULT_SYSTEM
-    },
-    color: proc {
-      Pry::Helpers::BaseHelpers.use_ansi_codes?
-    },
-    default_window_size: proc {
-      5
-    },
-    editor: proc {
-      Pry.default_editor_for_platform
-    }, # TODO: Pry::Platform.editor
-    should_load_rc: proc {
-      true
-    },
-    should_load_local_rc: proc {
-      true
-    },
-    should_trap_interrupts: proc {
-      Pry::Helpers::BaseHelpers.jruby?
-    }, # TODO: Pry::Platform.jruby?
-    disable_auto_reload: proc {
-      false
-    },
-    command_prefix: proc {
-      ""
-    },
-    auto_indent: proc {
-      Pry::Helpers::BaseHelpers.use_ansi_codes?
-    },
-    correct_indent: proc {
-      true
-    },
-    collision_warning: proc {
-      false
-    },
-    output_prefix: proc {
-      "=> "
-    },
-    requires: proc {
-      []
-    },
-    should_load_requires: proc {
-      true
-    },
-    should_load_plugins: proc {
-      true
-    },
-    windows_console_warning: proc {
-      true
-    },
-    control_d_handler: proc {
-      Pry::DEFAULT_CONTROL_D_HANDLER
-    },
-    memory_size: proc {
-      100
-    },
-    extra_sticky_locals: proc {
-      {}
-    },
-    command_completions: proc {
-      proc { commands.keys }
-    },
-    file_completions: proc {
-      proc { Dir["."] }
-    },
-    ls: proc {
-      Pry::Config.from_hash(Pry::Command::Ls::DEFAULT_OPTIONS)
-    },
-    completer: proc {
-      require "pry/input_completer"
-      Pry::InputCompleter
-    }
-  }
-
-  def initialize
-    super(nil)
-    configure_gist
-    configure_history
-  end
-
-  default.each do |key, value|
-    define_method(key) do
-      if default[key].equal?(value)
-        default[key] = instance_eval(&value)
-      end
-      default[key]
-    end
-  end
-
-private
-  # TODO:
-  # all of this configure_* stuff is a relic of old code.
-  # we should try move this code to being command-local.
-  def configure_gist
-    self["gist"] = Pry::Config.from_hash(inspecter: proc(&:pretty_inspect))
-  end
-
-  def configure_history
-    self["history"] = Pry::Config.from_hash "should_save" => true,
-      "should_load" => true
-    history.file = File.expand_path("~/.pry_history") rescue nil
-    if history.file.nil?
-      self.should_load_rc = false
-      history.should_save = false
-      history.should_load = false
-    end
-  end
-
-  def lazy_readline
-    require 'readline'
-    Readline
-  rescue LoadError
-    warn "Sorry, you can't use Pry without Readline or a compatible library."
-    warn "Possible solutions:"
-    warn " * Rebuild Ruby with Readline support using `--with-readline`"
-    warn " * Use the rb-readline gem, which is a pure-Ruby port of Readline"
-    warn " * Use the pry-coolline gem, a pure-ruby alternative to Readline"
-    raise
-  end
-end

data/lib/pry/history_array.rb

@@ -1,121 +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 array 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
-
-    # Returns [Hash] copy of the internal @hash history
-    def to_h
-      @hash.dup
-    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

data/lib/pry/plugins.rb

@@ -1,103 +0,0 @@
-class Pry
-  class PluginManager
-    PRY_PLUGIN_PREFIX = /^pry-/
-
-    # Placeholder when no associated gem found, displays warning
-    class NoPlugin
-      def initialize(name)
-        @name = name
-      end
-
-      def method_missing(*args)
-        warn "Warning: The plugin '#{@name}' was not found! (no gem found)"
-      end
-    end
-
-    class Plugin
-      attr_accessor :name, :gem_name, :enabled, :spec, :active
-
-      def initialize(name, gem_name, spec, enabled)
-        @name, @gem_name, @enabled, @spec = name, gem_name, enabled, spec
-      end
-
-      # Disable a plugin. (prevents plugin from being loaded, cannot
-      # disable an already activated plugin)
-      def disable!
-        self.enabled = false
-      end
-
-      # Enable a plugin. (does not load it immediately but puts on
-      # 'white list' to be loaded)
-      def enable!
-        self.enabled = true
-      end
-
-      # Load the Command line options defined by this plugin (if they exist)
-      def load_cli_options
-        cli_options_file = File.join(spec.full_gem_path, "lib/#{spec.name}/cli.rb")
-        require cli_options_file if File.exist?(cli_options_file)
-      end
-      # Activate the plugin (require the gem - enables/loads the
-      # plugin immediately at point of call, even if plugin is
-      # disabled)
-      # Does not reload plugin if it's already active.
-      def activate!
-        # Create the configuration object for the plugin.
-        Pry.config.send("#{gem_name.gsub('-', '_')}=", Pry::Config.from_hash({}))
-
-        begin
-          require gem_name if !active?
-        rescue LoadError => e
-          warn "Found plugin #{gem_name}, but could not require '#{gem_name}'"
-          warn e
-        rescue => e
-          warn "require '#{gem_name}' # Failed, saying: #{e}"
-        end
-
-        self.active = true
-        self.enabled = true
-      end
-
-      alias active? active
-      alias enabled? enabled
-    end
-
-    def initialize
-      @plugins = []
-    end
-
-    # Find all installed Pry plugins and store them in an internal array.
-    def locate_plugins
-      Gem.refresh
-      (Gem::Specification.respond_to?(:each) ? Gem::Specification : Gem.source_index.find_name('')).each do |gem|
-        next if gem.name !~ PRY_PLUGIN_PREFIX
-        plugin_name = gem.name.split('-', 2).last
-        @plugins << Plugin.new(plugin_name, gem.name, gem, true) if !gem_located?(gem.name)
-      end
-      @plugins
-    end
-
-    # @return [Hash] A hash with all plugin names (minus the 'pry-') as
-    #   keys and Plugin objects as values.
-    def plugins
-      h = Hash.new { |_, key| NoPlugin.new(key) }
-      @plugins.each do |plugin|
-        h[plugin.name] = plugin
-      end
-      h
-    end
-
-    # Require all enabled plugins, disabled plugins are skipped.
-    def load_plugins
-      @plugins.each do |plugin|
-        plugin.activate! if plugin.enabled?
-      end
-    end
-
-    private
-    def gem_located?(gem_name)
-      @plugins.any? { |plugin| plugin.gem_name == gem_name }
-    end
-  end
-
-end

data/lib/pry/rbx_path.rb

@@ -1,22 +0,0 @@
-class Pry
-  module RbxPath
-    module_function
-    def is_core_path?(path)
-      Pry::Helpers::BaseHelpers.rbx? && (path.start_with?("kernel") || path.start_with?("lib")) && File.exist?(convert_path_to_full(path))
-    end
-
-    def convert_path_to_full(path)
-      if path.start_with?("kernel")
-        File.join File.dirname(Rubinius::KERNEL_PATH), path
-      elsif path.start_with?("lib")
-        File.join File.dirname(Rubinius::LIB_PATH), path
-      else
-        path
-      end
-    end
-
-    def rvm_ruby?(path)
-      !!(path =~ /\.rvm/)
-    end
-  end
-end

data/lib/pry/rubygem.rb

@@ -1,82 +0,0 @@
-require 'rubygems'
-
-class Pry
-  module Rubygem
-
-    class << self
-      def installed?(name)
-        if Gem::Specification.respond_to?(:find_all_by_name)
-          Gem::Specification.find_all_by_name(name).any?
-        else
-          Gem.source_index.find_name(name).first
-        end
-      end
-
-      # Get the gem spec object for the given gem name.
-      #
-      # @param [String] name
-      # @return [Gem::Specification]
-      def spec(name)
-        specs = if Gem::Specification.respond_to?(:each)
-                  Gem::Specification.find_all_by_name(name)
-                else
-                  Gem.source_index.find_name(name)
-                end
-
-        first_spec = specs.sort_by{ |spec| Gem::Version.new(spec.version) }.last
-
-        first_spec or raise CommandError, "Gem `#{name}` not found"
-      end
-
-      # List gems matching a pattern.
-      #
-      # @param [Regexp] pattern
-      # @return [Array<Gem::Specification>]
-      def list(pattern = /.*/)
-        if Gem::Specification.respond_to?(:each)
-          Gem::Specification.select{|spec| spec.name =~ pattern }
-        else
-          Gem.source_index.gems.values.select{|spec| spec.name =~ pattern }
-        end
-      end
-
-      # Completion function for gem-cd and gem-open.
-      #
-      # @param [String] so_far what the user's typed so far
-      # @return [Array<String>] completions
-      def complete(so_far)
-        if so_far =~ / ([^ ]*)\z/
-          self.list(%r{\A#{$2}}).map(&:name)
-        else
-          self.list.map(&:name)
-        end
-      end
-
-      # Installs a gem with all its dependencies.
-      #
-      # @param [String] name
-      # @return [void]
-      def install(name)
-        gemrc_opts = Gem.configuration['gem'].split(' ')
-        destination = if gemrc_opts.include?('--user-install')
-                        Gem.user_dir
-                      elsif File.writable?(Gem.dir)
-                        Gem.dir
-                      else
-                        Gem.user_dir
-                      end
-        installer = Gem::DependencyInstaller.new(:install_dir => destination)
-        installer.install(name)
-      rescue Errno::EACCES
-        raise CommandError,
-          "Insufficient permissions to install #{ Pry::Helpers::Text.green(name) }."
-      rescue Gem::GemNotFoundException
-        raise CommandError,
-          "Gem #{ Pry::Helpers::Text.green(name) } not found. Aborting installation."
-      else
-        Gem.refresh
-      end
-    end
-
-  end
-end