pry 0.10.2-i386-mingw32 → 1.0.0.pre1-i386-mingw32

data/lib/pry/commands/watch_expression/expression.rb

@@ -1,38 +0,0 @@
-class Pry
-  class Command::WatchExpression
-    class Expression
-      attr_reader :target, :source, :value, :previous_value, :_pry_
-
-      def initialize(_pry_, target, source)
-        @_pry_ = _pry_
-        @target = target
-        @source = Code.new(source).strip
-      end
-
-      def eval!
-        @previous_value = @value
-        @value = Pry::ColorPrinter.pp(target_eval(target, source), "")
-      end
-
-      def to_s
-        "#{Code.new(source).highlighted.strip} => #{value}"
-      end
-
-      # Has the value of the expression changed?
-      #
-      # We use the pretty-printed string represenation to detect differences
-      # as this avoids problems with dup (causes too many differences) and == (causes too few)
-      def changed?
-        (value != previous_value)
-      end
-
-      private
-
-      def target_eval(target, source)
-        target.eval(source)
-      rescue => e
-        e
-      end
-    end
-  end
-end

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/exceptions.rb

@@ -1,78 +0,0 @@
-class Pry
-
-  # As a REPL, we often want to catch any unexpected exceptions that may have
-  # been raised; however we don't want to go overboard and prevent the user
-  # from exiting Pry when they want to.
-  module RescuableException
-    def self.===(exception)
-      case exception
-        # Catch when the user hits ^C (Interrupt < SignalException), and assume
-        # that they just wanted to stop the in-progress command (just like bash
-        # etc.)
-      when Interrupt
-        true
-        # Don't catch signals (particularly not SIGTERM) as these are unlikely
-        # to be intended for pry itself. We should also make sure that
-        # Kernel#exit works.
-      when *Pry.config.exception_whitelist
-        false
-        # All other exceptions will be caught.
-      else
-        true
-      end
-    end
-  end
-
-  # Catches SecurityErrors if $SAFE is set
-  module Pry::TooSafeException
-    def self.===(exception)
-      $SAFE > 0 && SecurityError === exception
-    end
-  end
-
-  # An Exception Tag (cf. Exceptional Ruby) that instructs Pry to show the error
-  # in a more user-friendly manner. This should be used when the exception
-  # happens within Pry itself as a direct consequence of the user typing
-  # something wrong.
-  #
-  # This allows us to distinguish between the user typing:
-  #
-  # pry(main)> def )
-  # SyntaxError: unexpected )
-  #
-  # pry(main)> method_that_evals("def )")
-  # SyntaxError: (eval):1: syntax error, unexpected ')'
-  # from ./a.rb:2 in `eval'
-  module UserError; end
-
-  # When we try to get a binding for an object, we try to define a method on
-  # that Object's singleton class. This doesn't work for "frozen" Object's, and
-  # the exception is just a vanilla RuntimeError.
-  module FrozenObjectException
-    def self.===(exception)
-      ["can't modify frozen class/module",
-       "can't modify frozen Class",
-       "can't modify frozen object"
-      ].include?(exception.message)
-    end
-  end
-
-  # Don't catch these exceptions
-  DEFAULT_EXCEPTION_WHITELIST = [SystemExit,
-                                 SignalException,
-                                 Pry::TooSafeException]
-
-  # CommandErrors are caught by the REPL loop and displayed to the user. They
-  # indicate an exceptional condition that's fatal to the current command.
-  class CommandError < StandardError; end
-  class MethodNotFound < CommandError; end
-
-  # indicates obsolete API
-  class ObsoleteError < StandardError; end
-
-  # This is to keep from breaking under Rails 3.2 for people who are doing that
-  # IRB = Pry thing.
-  module ExtendCommandBundle
-  end
-
-end

data/lib/pry/input_completer.rb

@@ -1,242 +0,0 @@
-# taken from irb
-# Implements tab completion for Readline in Pry
-class Pry::InputCompleter
-  NUMERIC_REGEXP            = /^(-?(0[dbo])?[0-9_]+(\.[0-9_]+)?([eE]-?[0-9]+)?)\.([^.]*)$/
-  ARRAY_REGEXP              = /^([^\]]*\])\.([^.]*)$/
-  SYMBOL_REGEXP             = /^(:[^:.]*)$/
-  SYMBOL_METHOD_CALL_REGEXP = /^(:[^:.]+)\.([^.]*)$/
-  REGEX_REGEXP              = /^(\/[^\/]*\/)\.([^.]*)$/
-  PROC_OR_HASH_REGEXP       = /^([^\}]*\})\.([^.]*)$/
-  TOPLEVEL_LOOKUP_REGEXP    = /^::([A-Z][^:\.\(]*)$/
-  CONSTANT_REGEXP           = /^([A-Z][A-Za-z0-9]*)$/
-  CONSTANT_OR_METHOD_REGEXP = /^([A-Z].*)::([^:.]*)$/
-  HEX_REGEXP                = /^(-?0x[0-9a-fA-F_]+)\.([^.]*)$/
-  GLOBALVARIABLE_REGEXP     = /^(\$[^.]*)$/
-  VARIABLE_REGEXP           = /^([^."].*)\.([^.]*)$/
-
-  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 = [
-               "%", "&", "*", "**", "+",  "-",  "/",
-               "<", "<<", "<=", "<=>", "==", "===", "=~", ">", ">=", ">>",
-               "[]", "[]=", "^", "!", "!=", "!~"
-              ]
-
-  WORD_ESCAPE_STR = " \t\n\"\\'`><=;|&{("
-
-  def initialize(input, pry = nil)
-    @pry = pry
-    @input = input
-    @input.basic_word_break_characters = WORD_ESCAPE_STR if @input.respond_to?(:basic_word_break_characters=)
-    @input.completion_append_character = nil if @input.respond_to?(:completion_append_character=)
-  end
-
-  #
-  # Return a new completion proc for use by Readline.
-  #
-  def call(str, options = {})
-    custom_completions = options[:custom_completions] || []
-    # 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(str)
-
-    if path.call.empty?
-      target = options[:target]
-    else
-      # Assume the user is tab-completing the 'cd' command
-      begin
-        target = Pry::ObjectPath.new(path.call, @pry.binding_stack).resolve.last
-      # but if that doesn't work, assume they're doing division with no spaces
-      rescue Pry::CommandError
-        target = options[:target]
-      end
-    end
-
-    begin
-      bind = target
-      # Complete stdlib symbols
-      case input
-      when REGEX_REGEXP # Regexp
-        receiver = $1
-        message = Regexp.quote($2)
-        candidates = Regexp.instance_methods.collect(&:to_s)
-        select_message(path, receiver, message, candidates)
-      when ARRAY_REGEXP # Array
-        receiver = $1
-        message = Regexp.quote($2)
-        candidates = Array.instance_methods.collect(&:to_s)
-        select_message(path, receiver, message, candidates)
-      when PROC_OR_HASH_REGEXP # 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_REGEXP # 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 TOPLEVEL_LOOKUP_REGEXP # Absolute Constant or class methods
-        receiver = $1
-        candidates = Object.constants.collect(&:to_s)
-        candidates.grep(/^#{receiver}/).collect{|e| "::" << e}
-      when CONSTANT_REGEXP # 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 CONSTANT_OR_METHOD_REGEXP # 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 Pry::RescuableException
-            candidates = []
-          end
-          candidates.grep(/^#{message}/).collect{|e| receiver + "::" + e}
-        when SYMBOL_METHOD_CALL_REGEXP # method call on a Symbol
-          receiver = $1
-          message = Regexp.quote($2)
-          candidates = Symbol.instance_methods.collect(&:to_s)
-          select_message(path, receiver, message, candidates)
-        when NUMERIC_REGEXP
-          # Numeric
-          receiver = $1
-          message = Regexp.quote($5)
-          begin
-            candidates = eval(receiver, bind).methods.collect(&:to_s)
-          rescue Pry::RescuableException
-            candidates = []
-          end
-          select_message(path, receiver, message, candidates)
-        when HEX_REGEXP
-          # Numeric(0xFFFF)
-          receiver = $1
-          message = Regexp.quote($2)
-          begin
-            candidates = eval(receiver, bind).methods.collect(&:to_s)
-          rescue Pry::RescuableException
-            candidates = []
-          end
-          select_message(path, receiver, message, candidates)
-        when GLOBALVARIABLE_REGEXP # global
-          regmessage = Regexp.new(Regexp.quote($1))
-          candidates = global_variables.collect(&:to_s).grep(regmessage)
-        when VARIABLE_REGEXP # 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 Pry::RescuableException
-              candidates = []
-            end
-          else
-            # func1.func2
-            candidates = []
-            ObjectSpace.each_object(Module){|m|
-              begin
-                name = m.name.to_s
-              rescue Pry::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|custom_completions).grep(/^#{Regexp.quote(input)}/)
-          candidates.collect(&path)
-        end
-      rescue Pry::RescuableException
-        []
-      end
-    end
-
-    def 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 build_path(input)
-      # check to see if the input is a regex
-      return proc {|i| i.to_s }, input if input[/\/\./]
-      trailing_slash = input.end_with?('/')
-      contexts = input.chomp('/').split(/\//)
-      input = contexts[-1]
-      path = proc do |i|
-        p = contexts[0..-2].push(i).join('/')
-        p += '/' if trailing_slash && !i.nil?
-        p
-      end
-      return path, input
-    end
-end