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

data/lib/pry/commands/ls/instance_vars.rb

@@ -1,39 +0,0 @@
-require 'pry/commands/ls/interrogatable'
-
-class Pry
-  class Command::Ls < Pry::ClassCommand
-    class InstanceVars < Pry::Command::Ls::Formatter
-      include Pry::Command::Ls::Interrogatable
-
-      def initialize(interrogatee, no_user_opts, opts, _pry_)
-        super(_pry_)
-        @interrogatee = interrogatee
-        @no_user_opts = no_user_opts
-        @default_switch = opts[:ivars]
-      end
-
-      def correct_opts?
-        super || @no_user_opts
-      end
-
-      def output_self
-        ivars = if Object === @interrogatee
-                  Pry::Method.safe_send(@interrogatee, :instance_variables)
-                else
-                  [] #TODO: BasicObject support
-                end
-        kvars = Pry::Method.safe_send(interrogatee_mod, :class_variables)
-        ivars_out = output_section('instance variables', format(:instance_var, ivars))
-        kvars_out = output_section('class variables', format(:class_var, kvars))
-        ivars_out + kvars_out
-      end
-
-      private
-
-      def format(type, vars)
-        vars.sort_by { |var| var.to_s.downcase }.map { |var| color(type, var) }
-      end
-
-    end
-  end
-end

data/lib/pry/commands/ls/interrogatable.rb

@@ -1,18 +0,0 @@
-module Pry::Command::Ls::Interrogatable
-
-  private
-
-  def interrogating_a_module?
-    Module === @interrogatee
-  end
-
-  def interrogatee_mod
-    if interrogating_a_module?
-      @interrogatee
-    else
-      singleton = Pry::Method.singleton_class_of(@interrogatee)
-      singleton.ancestors.grep(::Class).reject { |c| c == singleton }.first
-    end
-  end
-
-end

data/lib/pry/commands/ls/jruby_hacks.rb

@@ -1,49 +0,0 @@
-module Pry::Command::Ls::JRubyHacks
-
-  private
-
-  # JRuby creates lots of aliases for methods imported from java in an attempt
-  # to make life easier for ruby programmers.  (e.g. getFooBar becomes
-  # get_foo_bar and foo_bar, and maybe foo_bar? if it returns a Boolean). The
-  # full transformations are in the assignAliases method of:
-  # https://github.com/jruby/jruby/blob/master/src/org/jruby/javasupport/JavaClass.java
-  #
-  # This has the unfortunate side-effect of making the output of ls even more
-  # incredibly verbose than it normally would be for these objects; and so we
-  # filter out all but the nicest of these aliases here.
-  #
-  # TODO: This is a little bit vague, better heuristics could be used.
-  #       JRuby also has a lot of scala-specific logic, which we don't copy.
-  def trim_jruby_aliases(methods)
-    grouped = methods.group_by do |m|
-      m.name.sub(/\A(is|get|set)(?=[A-Z_])/, '').gsub(/[_?=]/, '').downcase
-    end
-
-    grouped.map do |key, values|
-      values = values.sort_by do |m|
-        rubbishness(m.name)
-      end
-
-      found = []
-      values.select do |x|
-        (!found.any? { |y| x == y }) && found << x
-      end
-    end.flatten(1)
-  end
-
-  # When removing jruby aliases, we want to keep the alias that is
-  # "least rubbish" according to this metric.
-  def rubbishness(name)
-    name.each_char.map { |x|
-      case x
-      when /[A-Z]/
-        1
-      when '?', '=', '!'
-        -2
-      else
-        0
-      end
-    }.inject(&:+) + (name.size / 100.0)
-  end
-
-end

data/lib/pry/commands/ls/local_names.rb

@@ -1,35 +0,0 @@
-class Pry
-  class Command::Ls < Pry::ClassCommand
-    class LocalNames < Pry::Command::Ls::Formatter
-
-      def initialize(no_user_opts, args, _pry_)
-        super(_pry_)
-        @no_user_opts = no_user_opts
-        @args = args
-        @sticky_locals = _pry_.sticky_locals
-      end
-
-      def correct_opts?
-        super || (@no_user_opts && @args.empty?)
-      end
-
-      def output_self
-        local_vars = grep.regexp[@target.eval('local_variables')]
-        output_section('locals', format(local_vars))
-      end
-
-      private
-
-      def format(locals)
-        locals.sort_by(&:downcase).map do |name|
-          if @sticky_locals.include?(name.to_sym)
-            color(:pry_var, name)
-          else
-            color(:local_var, name)
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/pry/commands/ls/local_vars.rb

@@ -1,39 +0,0 @@
-class Pry
-  class Command::Ls < Pry::ClassCommand
-    class LocalVars < Pry::Command::Ls::Formatter
-
-      def initialize(opts, _pry_)
-        super(_pry_)
-        @default_switch = opts[:locals]
-        @sticky_locals = _pry_.sticky_locals
-      end
-
-      def output_self
-        name_value_pairs = @target.eval('local_variables').reject { |e|
-          @sticky_locals.keys.include?(e.to_sym)
-        }.map { |name|
-          [name, (@target.eval(name.to_s))]
-        }
-        format(name_value_pairs).join('')
-      end
-
-      private
-
-      def format(name_value_pairs)
-        name_value_pairs.sort_by { |name, value|
-          value.to_s.size
-        }.reverse.map { |name, value|
-          colorized_assignment_style(name, format_value(value))
-        }
-      end
-
-      def colorized_assignment_style(lhs, rhs, desired_width = 7)
-        colorized_lhs = color(:local_var, lhs)
-        color_escape_padding = colorized_lhs.size - lhs.size
-        pad = desired_width + color_escape_padding
-        "%-#{pad}s = %s" % [color(:local_var, colorized_lhs), rhs]
-      end
-
-    end
-  end
-end

data/lib/pry/commands/ls/ls_entity.rb

@@ -1,70 +0,0 @@
-require 'pry/commands/ls/grep'
-require 'pry/commands/ls/formatter'
-require 'pry/commands/ls/globals'
-require 'pry/commands/ls/constants'
-require 'pry/commands/ls/methods'
-require 'pry/commands/ls/self_methods'
-require 'pry/commands/ls/instance_vars'
-require 'pry/commands/ls/local_names'
-require 'pry/commands/ls/local_vars'
-
-class Pry
-  class Command::Ls < Pry::ClassCommand
-
-    class LsEntity
-      attr_reader :_pry_
-
-      def initialize(opts)
-        @interrogatee = opts[:interrogatee]
-        @no_user_opts = opts[:no_user_opts]
-        @opts = opts[:opts]
-        @args = opts[:args]
-        @grep = Grep.new(Regexp.new(opts[:opts][:G] || '.'))
-        @_pry_ = opts.delete(:_pry_)
-      end
-
-      def entities_table
-        entities.map(&:write_out).reject { |o| !o }.join('')
-      end
-
-      private
-
-      def grep(entity)
-        entity.tap { |o| o.grep = @grep }
-      end
-
-      def globals
-        grep Globals.new(@opts, _pry_)
-      end
-
-      def constants
-        grep Constants.new(@interrogatee, @no_user_opts, @opts, _pry_)
-      end
-
-      def methods
-        grep(Methods.new(@interrogatee, @no_user_opts, @opts, _pry_))
-      end
-
-      def self_methods
-        grep SelfMethods.new(@interrogatee, @no_user_opts, @opts, _pry_)
-      end
-
-      def instance_vars
-        grep InstanceVars.new(@interrogatee, @no_user_opts, @opts, _pry_)
-      end
-
-      def local_names
-        grep LocalNames.new(@no_user_opts, @args, _pry_)
-      end
-
-      def local_vars
-        LocalVars.new(@opts, _pry_)
-      end
-
-      def entities
-        [globals, constants, methods, self_methods, instance_vars, local_names,
-          local_vars]
-      end
-    end
-  end
-end

data/lib/pry/commands/ls/methods.rb

@@ -1,57 +0,0 @@
-require 'pry/commands/ls/methods_helper'
-require 'pry/commands/ls/interrogatable'
-
-class Pry
-  class Command::Ls < Pry::ClassCommand
-    class Methods < Pry::Command::Ls::Formatter
-
-      include Pry::Command::Ls::Interrogatable
-      include Pry::Command::Ls::MethodsHelper
-
-      def initialize(interrogatee, no_user_opts, opts, _pry_)
-        super(_pry_)
-        @interrogatee = interrogatee
-        @no_user_opts = no_user_opts
-        @default_switch = opts[:methods]
-        @instance_methods_switch = opts['instance-methods']
-        @ppp_switch = opts[:ppp]
-        @jruby_switch = opts['all-java']
-        @quiet_switch = opts[:quiet]
-        @verbose_switch = opts[:verbose]
-      end
-
-      def output_self
-        methods = all_methods.group_by(&:owner)
-        # Reverse the resolution order so that the most useful information
-        # appears right by the prompt.
-        resolution_order.take_while(&below_ceiling).reverse.map do |klass|
-          methods_here = (methods[klass] || []).select { |m| grep.regexp[m.name] }
-          heading = "#{ Pry::WrappedModule.new(klass).method_prefix }methods"
-          output_section(heading, format(methods_here))
-        end.join('')
-      end
-
-      private
-
-      def correct_opts?
-        super || @instance_methods_switch || @ppp_switch || @no_user_opts
-      end
-
-
-      # Get a lambda that can be used with `take_while` to prevent over-eager
-      # traversal of the Object's ancestry graph.
-      def below_ceiling
-        ceiling = if @quiet_switch
-                    [Pry::Method.safe_send(interrogatee_mod, :ancestors)[1]] +
-                      _pry_.config.ls.ceiling
-                  elsif @verbose_switch
-                    []
-                  else
-                    _pry_.config.ls.ceiling.dup
-                  end
-        lambda { |klass| !ceiling.include?(klass) }
-      end
-
-    end
-  end
-end

data/lib/pry/commands/ls/methods_helper.rb

@@ -1,46 +0,0 @@
-require 'pry/commands/ls/jruby_hacks'
-
-module Pry::Command::Ls::MethodsHelper
-
-  include Pry::Command::Ls::JRubyHacks
-
-  private
-
-  # Get all the methods that we'll want to output.
-  def all_methods(instance_methods = false)
-    methods = if instance_methods || @instance_methods_switch
-                Pry::Method.all_from_class(@interrogatee)
-              else
-                Pry::Method.all_from_obj(@interrogatee)
-              end
-
-    if Pry::Helpers::BaseHelpers.jruby? && !@jruby_switch
-      methods = trim_jruby_aliases(methods)
-    end
-
-    methods.select { |method| @ppp_switch || method.visibility == :public }
-  end
-
-  def resolution_order
-    if @instance_methods_switch
-      Pry::Method.instance_resolution_order(@interrogatee)
-    else
-      Pry::Method.resolution_order(@interrogatee)
-    end
-  end
-
-  def format(methods)
-    methods.sort_by(&:name).map do |method|
-      if method.name == 'method_missing'
-        color(:method_missing, 'method_missing')
-      elsif method.visibility == :private
-        color(:private_method, method.name)
-      elsif method.visibility == :protected
-        color(:protected_method, method.name)
-      else
-        color(:public_method, method.name)
-      end
-    end
-  end
-
-end

data/lib/pry/commands/ls/self_methods.rb

@@ -1,32 +0,0 @@
-require 'pry/commands/ls/interrogatable'
-require 'pry/commands/ls/methods_helper'
-
-class Pry
-  class Command::Ls < Pry::ClassCommand
-    class SelfMethods < Pry::Command::Ls::Formatter
-      include Pry::Command::Ls::Interrogatable
-      include Pry::Command::Ls::MethodsHelper
-
-      def initialize(interrogatee, no_user_opts, opts, _pry_)
-        super(_pry_)
-        @interrogatee = interrogatee
-        @no_user_opts = no_user_opts
-      end
-
-      def output_self
-        methods = all_methods(true).select do |m|
-          m.owner == @interrogatee && grep.regexp[m.name]
-        end
-        heading = "#{ Pry::WrappedModule.new(@interrogatee).method_prefix }methods"
-        output_section(heading, format(methods))
-      end
-
-      private
-
-      def correct_opts?
-        @no_user_opts && interrogating_a_module?
-      end
-
-    end
-  end
-end

data/lib/pry/commands/watch_expression.rb

@@ -1,105 +0,0 @@
-class Pry
-  class Command::WatchExpression < Pry::ClassCommand
-    require 'pry/commands/watch_expression/expression.rb'
-
-    match 'watch'
-    group 'Context'
-    description 'Watch the value of an expression and print a notification whenever it changes.'
-    command_options :use_prefix => false
-
-    banner <<-'BANNER'
-      Usage: watch [EXPRESSION]
-             watch
-             watch --delete [INDEX]
-
-      watch [EXPRESSION] adds an expression to the list of those being watched.
-      It will be re-evaluated every time you hit enter in pry. If its value has
-      changed, the new value will be printed to the console.
-
-      This is useful if you are step-through debugging and want to see how
-      something changes over time.  It's also useful if you're trying to write
-      a method inside pry and want to check that it gives the right answers
-      every time you redefine it.
-
-      watch on its own displays all the currently watched expressions and their
-      values, and watch --delete [INDEX] allows you to delete expressions from
-      the list being watched.
-    BANNER
-
-    def options(opt)
-      opt.on :d, :delete,
-        "Delete the watch expression with the given index. If no index is given; clear all watch expressions.",
-        :optional_argument => true, :as => Integer
-      opt.on :l, :list,
-        "Show all current watch expressions and their values.  Calling watch with no expressions or options will also show the watch expressions."
-    end
-
-    def process
-      case
-      when opts.present?(:delete)
-        delete opts[:delete]
-      when opts.present?(:list) || args.empty?
-        list
-      else
-        add_hook
-        add_expression(args)
-      end
-    end
-
-    private
-
-    def expressions
-      _pry_.config.watch_expressions ||= []
-    end
-
-    def delete(index)
-      if index
-        output.puts "Deleting watch expression ##{index}: #{expressions[index-1]}"
-        expressions.delete_at(index-1)
-      else
-        output.puts "Deleting all watched expressions"
-        expressions.clear
-      end
-    end
-
-    def list
-      if expressions.empty?
-        output.puts "No watched expressions"
-      else
-        _pry_.pager.open do |pager|
-          pager.puts "Listing all watched expressions:"
-          pager.puts ""
-          expressions.each_with_index do |expr, index|
-            pager.print text.with_line_numbers(expr.to_s, index+1)
-          end
-          pager.puts ""
-        end
-      end
-    end
-
-    def eval_and_print_changed(output)
-      expressions.each do |expr|
-        expr.eval!
-        if expr.changed?
-          output.puts "#{text.blue "watch"}: #{expr.to_s}"
-        end
-      end
-    end
-
-    def add_expression(arguments)
-      expressions << Expression.new(_pry_, target, arg_string)
-      output.puts "Watching #{Code.new(arg_string).highlighted}"
-    end
-
-    def add_hook
-      hook = [:after_eval, :watch_expression]
-      unless _pry_.hooks.hook_exists?(*hook)
-        _pry_.hooks.add_hook(*hook) do |_, _pry_|
-          eval_and_print_changed _pry_.output
-        end
-      end
-    end
-  end
-
-  Pry::Commands.add_command(Pry::Command::WatchExpression)
-end