pry 0.9.8pre2-i386-mingw32 → 0.9.8pre3-i386-mingw32

data/lib/pry/command_context.rb

@@ -1,53 +0,0 @@
-class Pry
-  # Command contexts are the objects runing each command.
-  # Helper modules can be mixed into this class.
-  class CommandContext
-
-    # represents a void return value for a command
-    VOID_VALUE = Object.new
-
-    # give it a nice inspect
-    def VOID_VALUE.inspect() "void" end
-
-    attr_accessor :command_name
-    attr_accessor :output
-    attr_accessor :target
-    attr_accessor :target_self
-    attr_accessor :captures
-    attr_accessor :eval_string
-    attr_accessor :arg_string
-    attr_accessor :opts
-    attr_accessor :command_set
-    attr_accessor :command_processor
-    attr_accessor :_pry_
-
-    # Run a command from another command.
-    # @param [String] command_string The string that invokes the command
-    # @param [Array] args Further arguments to pass to the command
-    # @example
-    #   run "show-input"
-    # @example
-    #   run ".ls"
-    # @example
-    #   run "amend-line",  "5", 'puts "hello world"'
-    def run(command_string, *args)
-      complete_string = "#{command_string} #{args.join(" ")}"
-      command_processor.process_commands(complete_string, eval_string, target)
-    end
-
-    def commands
-      command_set.commands
-    end
-
-    def text
-      Pry::Helpers::Text
-    end
-
-    def void
-      VOID_VALUE
-    end
-
-    include Pry::Helpers::BaseHelpers
-    include Pry::Helpers::CommandHelpers
-  end
-end

data/lib/pry/command_processor.rb

@@ -1,194 +0,0 @@
-require 'forwardable'
-
-class Pry
-  class CommandProcessor
-
-    # Wraps the return result of process_commands, indicates if the
-    # result IS a command and what kind of command (e.g void)
-    class Result
-      attr_reader :retval
-
-      def initialize(is_command, keep_retval = false, retval = nil)
-        @is_command, @keep_retval, @retval = is_command, keep_retval, retval
-      end
-
-      # Is the result a command?
-      # @return [Boolean]
-      def command?
-        @is_command
-      end
-
-      # Is the result a command and if it is, is it a void command?
-      # (one that does not return a value)
-      # @return [Boolean]
-      def void_command?
-        (command? && !keep_retval?) || retval == CommandContext::VOID_VALUE
-      end
-
-      # Is the return value kept for this command? (i.e :keep_retval => true)
-      # @return [Boolean]
-      def keep_retval?
-        @keep_retval
-      end
-    end
-
-    extend Forwardable
-
-    attr_accessor :pry_instance
-
-    def initialize(pry_instance)
-      @pry_instance = pry_instance
-    end
-
-    def_delegators :@pry_instance, :commands, :output
-
-    # Is the string a valid command?
-    # @param [String] val The string passed in from the Pry prompt.
-    # @param [Binding] target The context where the string should be
-    #   interpolated in.
-    # @return [Boolean] Whether the string is a valid command.
-    def valid_command?(val, target=binding)
-      !!(command_matched(val, target)[0])
-    end
-
-    # Convert the object to a form that can be interpolated into a
-    # Regexp cleanly.
-    # @return [String] The string to interpolate into a Regexp
-    def convert_to_regex(obj)
-      case obj
-      when String
-        Regexp.escape(obj)
-      else
-        obj
-      end
-    end
-
-    # Revaluate the string (str) and perform interpolation.
-    # @param [String] str The string to reevaluate with interpolation.
-    # @param [Binding] target The context where the string should be
-    #   interpolated in.
-    # @return [String] The reevaluated string with interpolations
-    #   applied (if any).
-    def interpolate_string(str, target)
-      dumped_str = str.dump
-      dumped_str.gsub!(/\\\#\{/, '#{')
-      target.eval(dumped_str)
-    end
-
-    # Determine whether a Pry command was matched and return command data
-    # and argument string.
-    # This method should not need to be invoked directly.
-    # @param [String] val The line of input.
-    # @param [Binding] target The binding to perform string
-    #   interpolation against.
-    # @return [Array] The command data and arg string pair
-    def command_matched(val, target)
-      _, cmd_data = commands.commands.find do |name, data|
-        prefix = convert_to_regex(Pry.config.command_prefix)
-        prefix = "(?:#{prefix})?" unless data.options[:use_prefix]
-
-        command_regex = /^#{prefix}#{convert_to_regex(name)}(?!\S)/
-
-        if command_regex =~ val
-          if data.options[:interpolate]
-            val.replace(interpolate_string(val, target))
-            command_regex =~ val # re-match with the interpolated string
-          end
-          true
-        end
-      end
-
-      [cmd_data, (Regexp.last_match ? Regexp.last_match.captures : nil), (Regexp.last_match ? Regexp.last_match.end(0) : nil)]
-    end
-
-    # Display a warning if a command collides with a local/method in
-    # the current scope.
-    # @param [String] command_name_match The name of the colliding command.
-    # @param [Binding] target The current binding context.
-    def check_for_command_name_collision(command_name_match, target)
-      if collision_type = target.eval("defined?(#{command_name_match})")
-        pry_instance.output.puts "#{Pry::Helpers::Text.bold('WARNING:')} Command name collision with a #{collision_type}: '#{command_name_match}'\n\n"
-      end
-    rescue Pry::RescuableException
-    end
-
-    # Process Pry commands. Pry commands are not Ruby methods and are evaluated
-    # prior to Ruby expressions.
-    # Commands can be modified/configured by the user: see `Pry::Commands`
-    # This method should not need to be invoked directly - it is called
-    # by `Pry#r`.
-    # @param [String] val The current line of input.
-    # @param [String] eval_string The cumulative lines of input for
-    #   multi-line input.
-    # @param [Binding] target The receiver of the commands.
-    # @return [Pry::CommandProcessor::Result] A wrapper object
-    #   containing info about the result of the command processing
-    #   (indicating whether it is a command and if it is what kind of
-    #   command it is.
-    def process_commands(val, eval_string, target)
-
-      command, captures, pos = command_matched(val, target)
-
-      # no command was matched, so return to caller
-      return Result.new(false) if !command
-
-      arg_string = val[pos..-1]
-
-      check_for_command_name_collision(val[0..pos].rstrip, target) if Pry.config.collision_warning
-
-      # remove the one leading space if it exists
-      arg_string.slice!(0) if arg_string.start_with?(" ")
-
-      if arg_string
-        args = command.options[:shellwords] ? Shellwords.shellwords(arg_string) : arg_string.split(" ")
-      else
-        args = []
-      end
-
-      options = {
-        :val => val,
-        :arg_string => arg_string,
-        :eval_string => eval_string,
-        :commands => commands.commands,
-        :captures => captures
-      }
-
-      ret = execute_command(target, command.name, options, *(captures + args))
-
-      Result.new(true, command.options[:keep_retval], ret)
-    end
-
-    # Execute a Pry command.
-    # This method should not need to be invoked directly.
-    # @param [Binding] target The target of the Pry session.
-    # @param [String] command The name of the command to be run.
-    # @param [Hash] options The options to set on the Commands object.
-    # @param [Array] args The command arguments.
-    # @return [Object] The value returned by the command
-    def execute_command(target, command, options, *args)
-      context = CommandContext.new
-
-      # set some useful methods to be used by the action blocks
-      context.opts        = options
-      context.target      = target
-      context.target_self = target.eval('self')
-      context.output      = output
-      context.captures    = options[:captures]
-      context.eval_string = options[:eval_string]
-      context.arg_string  = options[:arg_string]
-      context.command_set = commands
-      context._pry_ = @pry_instance
-
-      context.command_processor = self
-
-      ret = nil
-      catch(:command_done) do
-        ret = commands.run_command(context, command, *args)
-      end
-
-      options[:val].replace("")
-
-      ret
-    end
-  end
-end

data/test/test_command_processor.rb

@@ -1,176 +0,0 @@
-require 'helper'
-
-describe "Pry::CommandProcessor" do
-  before do
-    @pry = Pry.new
-    @pry.commands = Pry::CommandSet.new
-    @command_processor = Pry::CommandProcessor.new(@pry)
-  end
-
-  after do
-    @pry.commands = Pry::CommandSet.new
-  end
-
-  it 'should accurately determine if a command is valid' do
-    @pry.commands.command("test-command") {}
-    valid = @command_processor.valid_command? "test-command"
-    valid.should == true
-
-    valid = @command_processor.valid_command? "blah"
-    valid.should == false
-  end
-
-  it 'should correctly match a simple string command' do
-    @pry.commands.command("test-command") {}
-    command, captures, pos = @command_processor.command_matched "test-command", binding
-
-    command.name.should == "test-command"
-    captures.should == []
-    pos.should == "test-command".length
-  end
-
-  it 'should correctly match a simple string command with parameters' do
-    @pry.commands.command("test-command") { |arg|}
-    command, captures, pos = @command_processor.command_matched "test-command hello", binding
-
-    command.name.should == "test-command"
-    captures.should == []
-    pos.should == "test-command".length
-  end
-
-  it 'should not match when the relevant command does not exist' do
-    command, captures, pos = @command_processor.command_matched "test-command", binding
-
-    command.should == nil
-    captures.should == nil
-  end
-
-  it 'should correctly match a regex command' do
-    @pry.commands.command(/rue(.?)/) { }
-    command, captures, pos = @command_processor.command_matched "rue hello", binding
-
-    command.name.should == /rue(.?)/
-    captures.should == [""]
-    pos.should == 3
-  end
-
-  it 'should correctly match a regex command and extract the capture groups' do
-    @pry.commands.command(/rue(.?)/) { }
-    command, captures, pos = @command_processor.command_matched "rue5 hello", binding
-
-    command.name.should == /rue(.?)/
-    captures.should == ["5"]
-    pos.should == 4
-  end
-
-  it 'should correctly match a string command with spaces in its name' do
-    @pry.commands.command("test command") {}
-    command, captures, pos = @command_processor.command_matched "test command", binding
-
-    command.name.should == "test command"
-    captures.should == []
-    pos.should == command.name.length
-  end
-
-  it 'should correctly match a string command with spaces in its name with parameters' do
-    @pry.commands.command("test command") {}
-    command, captures, pos = @command_processor.command_matched "test command param1 param2", binding
-
-    command.name.should == "test command"
-    captures.should == []
-    pos.should == command.name.length
-  end
-
-  it 'should correctly match a command preceded by the command_prefix if one is defined' do
-    Pry.config.command_prefix = "%"
-
-    @pry.commands.command("test-command") {}
-    command, captures, pos = @command_processor.command_matched "%test-command hello", binding
-
-    command.name.should == "test-command"
-    captures.should == []
-    pos.should == "test-command".length + "%".length
-
-    Pry.config.command_prefix = ''
-  end
-
-  it 'should not match a command not preceded by the command_prefix if one is defined' do
-    Pry.config.command_prefix = "%"
-
-    @pry.commands.command("test-command") {}
-    command, captures, pos = @command_processor.command_matched "test-command hello", binding
-
-    command.should == nil
-    captures.should == nil
-
-    Pry.config.command_prefix = ''
-  end
-
-  it 'should match a command preceded by the command_prefix when :use_prefix => false' do
-    Pry.config.command_prefix = "%"
-
-    @pry.commands.command("test-command", "", :use_prefix => false) {}
-    command, captures, pos = @command_processor.command_matched "%test-command hello", binding
-
-    command.name.should == "test-command"
-    captures.should == []
-    pos.should == "test-command".length + "%".length
-
-    Pry.config.command_prefix = ''
-  end
-
-  it 'should match a command not preceded by the command_prefix when :use_prefix => false' do
-    Pry.config.command_prefix = "%"
-
-    @pry.commands.command("test-command", "", :use_prefix => false) {}
-    command, captures, pos = @command_processor.command_matched "test-command hello", binding
-
-    command.name.should == "test-command"
-    captures.should == []
-    pos.should == "test-command".length
-
-    Pry.config.command_prefix = ''
-  end
-
-  it 'should correctly match a regex command with spaces in its name' do
-    regex_command_name = /test\s+(.+)\s+command/
-    @pry.commands.command(regex_command_name) {}
-
-    sample_text = "test friendship command"
-    command, captures, pos = @command_processor.command_matched sample_text, binding
-
-    command.name.should == regex_command_name
-    captures.should == ["friendship"]
-    pos.should == sample_text.size
-  end
-
-  it 'should correctly match a complex regex command' do
-    regex_command_name = /\.(.*)/
-    @pry.commands.command(regex_command_name) {}
-
-    sample_text = ".cd ~/pry"
-    command, captures, pos = @command_processor.command_matched sample_text, binding
-
-    command.name.should == regex_command_name
-    captures.should == ["cd ~/pry"]
-    pos.should == sample_text.size
-  end
-
-  it 'should not interpolate commands that have :interpolate => false (interpolate_string should *not* be called)' do
-    @pry.commands.command("boast", "", :interpolate => false) {}
-
-    # remember to use '' instead of "" when testing interpolation or
-    # you'll cause yourself incredible confusion
-    lambda { @command_processor.command_matched('boast #{c}', binding) }.should.not.raise NameError
-  end
-
-  it 'should only execute the contents of an interpolation once' do
-    $obj = 'a'
-
-    redirect_pry_io(InputTester.new('cat #{$obj.succ!}'), StringIO.new) do
-      Pry.new.rep
-    end
-
-    $obj.should == 'b'
-  end
-end