pry 0.6.7-i386-mingw32

data/bin/pry

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+# (C) John Mair (banisterfiend)
+# MIT license
+
+begin
+  require 'pry'
+rescue LoadError
+  require 'rubygems'
+  require 'pry'
+end
+require 'optparse'
+
+# defaults
+options = {
+  :context_string => "TOPLEVEL_BINDING",
+  :loadrc => true
+}
+
+OptionParser.new do |opts|
+  opts.banner = %{Usage: pry [OPTIONS] 
+Start a Pry session.
+See: `https://github.com/banister` for more information.
+--
+}
+  opts.on("-r", "--require FILE", "`require` a Ruby script at startup.") do |file|
+    require file
+  end
+
+  opts.on("-e", "--exec CODE", "A line of Ruby code to execute in context before the session starts.") do |code|
+    options[:code] = code
+  end
+
+  opts.on("-f", "Suppress loading of ~/.pryrc") do 
+    options[:loadrc] = false
+  end
+
+  opts.on("--color", "Start session with syntax highlighting on.") do 
+    Pry.color = true
+  end
+
+  opts.on("--simple-prompt", "Simple prompt mode.") do 
+    Pry.prompt = Pry::SIMPLE_PROMPT
+  end
+
+  opts.on("-I LOADPATH", "Specify $LOAD_PATH directory.") do  |load_path|
+    $LOAD_PATH << load_path
+  end
+
+  opts.on("-v", "--version", "Display the Pry version.") do
+    puts "Pry version #{Pry::VERSION} on Ruby #{RUBY_VERSION}"
+    exit
+  end
+
+  opts.on("-c", "--context CONTEXT",
+          "Start the session in the specified context. Equivalent to `context.pry` in a session.") do |context|
+
+    # save the context name
+    options[:context_string] = context
+  end
+
+  opts.on_tail("-h", "--help", "This message.") do 
+    puts opts
+    exit
+  end
+end.parse!
+
+rcpath = File.expand_path("~/.pryrc")
+
+# load ~/.pryrc, if not suppressed with -f option
+load rcpath if File.exists?(rcpath) && options[:loadrc]
+
+# create the actual context
+context = Pry.binding_for(eval(options[:context_string]))
+
+# run code passed with `-e`, if there is any.
+if options[:code]
+  Pry.new(:input => StringIO.new(options[:code]), :print => proc {}).rep(context)
+end
+
+# start the session
+context.pry

data/examples/example_basic.rb

@@ -0,0 +1,17 @@
+direc = File.dirname(__FILE__)
+
+require 'rubygems'
+require "#{direc}/../lib/pry"
+
+# define a local.
+a = "a local variable"
+
+# defing a top-level method.
+def hello
+  puts "hello world!"
+end
+
+# Start pry session at top-level.
+# The local variable `a` and the `hello` method will
+# be accessible.
+pry

data/examples/example_command_override.rb

@@ -0,0 +1,35 @@
+direc = File.dirname(__FILE__)
+
+require 'rubygems'
+require "#{direc}/../lib/pry"
+
+# Inherit standard command set, but tweak them by importing some and
+# overriding others.
+# Illustrates use of `command`, `run`, and `import_from` commands.
+class MyCommands < Pry::CommandBase
+
+  # Override ls command
+  command "ls", "An unhelpful ls" do
+    output.puts "No, i refuse to display any useful information."
+  end
+
+  # bring in just the status command from Pry::Commands
+  import_from Pry::Commands, "status"
+
+  # analogy to Ruby's native alias_method idiom for decorating a method
+  alias_command "old_status", "status", ""
+  
+  # Invoke one command from within another using `run`
+  command "status", "Modified status."  do |x|
+    output.puts "About to show status, are you ready?"
+    run "old_status", x
+    output.puts "Finished showing status."
+  end
+
+  # bring in a few other commands
+  import_from Pry::Commands, "quit", "show-method"
+end
+
+# Start a Pry session using the commands defined in MyCommands
+# Type 'help' in Pry to get a list of the commands and their descriptions
+Pry.start(TOPLEVEL_BINDING, :commands => MyCommands)

data/examples/example_commands.rb

@@ -0,0 +1,39 @@
+direc = File.dirname(__FILE__)
+
+require 'rubygems'
+require "#{direc}/../lib/pry"
+
+class MathCommands < Pry::CommandBase
+  command "greet", "Greet a person, e.g: greet john" do |name|
+    output.puts "Good afternoon #{name.capitalize}! Do you like Math?"
+  end
+
+  command "add", "Add a list of numbers together, e.g: add 1 2 3 4" do |*args|
+    output.puts "Total: #{args.map(&:to_f).inject(&:+)}"
+  end
+
+  command "multiply", "Multiply a list of numbers together, e.g: multiply 1 2 3 4" do |*args|
+    output.puts "Total: #{args.map(&:to_f).inject(&:*)}"
+  end
+
+  # Explicitly giving a description of "" to prevent command being
+  # displayed in 'help'
+  command "exit", "" do
+    throw :breakout, 0
+  end
+
+  # Bring in the "!" method from Pry::Commands
+  import_from Pry::Commands, "!"
+end
+
+# Since we provide math commands, let's have mathematical
+# before_session and after_session hooks, and a mathematical prompt
+math_prompt = [proc { "math> " }, proc { "math* " }]
+math_hooks = {
+  :before_session => proc { |output, *| output.puts "Welcome! Let's do some math! Type 'help' for a list of commands." },
+  :after_session => proc { |output, *| output.puts "Goodbye!" }
+}
+
+# Start a Pry session using the commands defined in MyCommands
+# Type 'help' in Pry to get a list of the commands and their descriptions
+Pry.start(TOPLEVEL_BINDING, :commands => MathCommands, :prompt => math_prompt, :hooks => math_hooks)

data/examples/example_hooks.rb

@@ -0,0 +1,12 @@
+direc = File.dirname(__FILE__)
+
+require 'rubygems'
+require "#{direc}/../lib/pry"
+
+my_hooks = {
+  :before_session => proc { |out, obj| out.puts "Opening #{obj}." },
+  :after_session => proc { |out, obj| out.puts "Closing #{obj}." }
+}
+           
+# Start a Pry session using the hooks hash defined in my_hooks
+Pry.start(TOPLEVEL_BINDING, :hooks => my_hooks)

data/examples/example_image_edit.rb

@@ -0,0 +1,71 @@
+# Note: this requires you to have Gosu and TexPlay installed.
+# `gem install gosu`
+# `gem install texplay`
+# 
+# Extra instructions for installing Gosu on Linux can be found here:
+# http://code.google.com/p/gosu/wiki/GettingStartedOnLinux
+#
+# Instructions for using TexPlay can be found here:
+# http://banisterfiend.wordpress.com/2008/08/23/texplay-an-image-manipulation-tool-for-ruby-and-gosu/
+#
+# Have fun! :)
+
+direc = File.dirname(__FILE__)
+
+require 'rubygems'
+require "texplay"
+require "#{direc}/../lib/pry"
+
+WIDTH = 640
+HEIGHT = 480
+
+IMAGE_PROMPT = [ proc { "(image edit)> " }, proc { "(image edit)* " } ]
+
+class ImageCommands < Pry::CommandBase
+  command "drawing_methods", "Show a list of TexPlay methods" do
+    output.puts "#{Pry.view(TexPlay.public_instance_methods)}"
+  end
+
+  command "exit", "Exit the program." do
+    output.puts "Thanks for dropping by!"
+    exit
+  end
+
+  import_from Pry::Commands, "ls", "!"
+end
+
+class WinClass < Gosu::Window
+
+  def initialize
+    super(WIDTH, HEIGHT, false)
+    @img = TexPlay.create_image(self, 200, 200).clear :color => :black
+    @img.rect 0, 0, @img.width - 1, @img.height - 1
+
+    @binding = Pry.binding_for(@img)
+    
+    @pry_instance = Pry.new(:commands => ImageCommands, :prompt => IMAGE_PROMPT)
+  end
+
+  def draw
+    @img.draw_rot(WIDTH / 2, HEIGHT / 2, 1, 0, 0.5, 0.5) 
+  end
+
+  def update
+    exit if button_down?(Gosu::KbEscape)
+
+    # We do not want a REPL session as the loop prevents the image
+    # being updated; instead we do a REP session, and let the image
+    # update each time the user presses enter. We maintain the same
+    # binding object to keep locals between calls to `Pry#rep()`
+    @pry_instance.rep(@binding)
+  end
+end
+
+puts "Welcome to ImageEdit; type `help` for a list of commands and `drawing_methods` for a list of drawing methods available."
+puts "--"
+puts "Example: Try typing 'circle width/2, height/2, 95, :color => :blue, :fill => true'"
+puts "If you want to save your image, type: save(\"img.png\")"
+
+w = WinClass.new
+w.show
+

data/examples/example_input.rb

@@ -0,0 +1,10 @@
+direc = File.dirname(__FILE__)
+
+require 'rubygems'
+require "#{direc}/../lib/pry"
+
+# Create a StringIO that contains the input data
+str_input = StringIO.new("puts 'hello world!'\nputs \"I am in \#{self}\"\nexit")
+
+# Start a Pry session on the Fixnum 5 using the input data in str_input
+Pry.start(5, :input => str_input)

data/examples/example_input2.rb

@@ -0,0 +1,32 @@
+direc = File.dirname(__FILE__)
+
+require 'rubygems'
+require "#{direc}/../lib/pry"
+
+# Create a StringIO that contains the input data for all the Pry objects
+cmds = <<-CMDS
+cd 1
+status
+puts 'hello from 1!!'
+cd 2
+nesting
+puts 'hello from 2!!'
+_pry_.parent.input = Readline
+back
+exit-all
+CMDS
+
+# create our StringIO object
+str_input = StringIO.new(cmds)
+
+# set global input to str_input, this means that all pry sessions
+# adopt this object as their input object.
+Pry.input = str_input
+
+# Start the session reading from str_input.
+# Note that because `Pry.input` is set to `str_input` all nested pry
+# sessions will read from `str_input` too. All pry sessions are there
+# for non-interactive, except for `pry(1)` which starts off
+# non-interactive but is set to be interactive by pry(2) (using
+# _pry_.parent.input = Readline)
+0.pry

data/examples/example_output.rb

@@ -0,0 +1,14 @@
+direc = File.dirname(__FILE__)
+
+require 'rubygems'
+require "#{direc}/../lib/pry"
+
+# Create a StringIO to contain the output data
+str_output = StringIO.new
+
+# Start a Pry session on the Fixnum 5 using str_output to store the
+# output (not writing to $stdout)
+Pry.start(5, :output => str_output)
+
+# Display all the output accumulated during the session
+puts str_output.string

data/examples/example_print.rb

@@ -0,0 +1,9 @@
+direc = File.dirname(__FILE__)
+
+require 'rubygems'
+require "#{direc}/../lib/pry"
+
+my_print = proc { |out, value| out.puts "Output is: #{value.inspect}" }
+           
+# Start a Pry session using the print object defined in my_print
+Pry.start(TOPLEVEL_BINDING, :print => my_print)

data/examples/example_prompt.rb

@@ -0,0 +1,12 @@
+direc = File.dirname(__FILE__)
+
+require 'rubygems'
+require "#{direc}/../lib/pry"
+
+# Remember, first prompt in array is the main prompt, second is the wait
+# prompt (used for multiline input when more input is required)
+my_prompt = [ proc { |obj, *| "inside #{obj}> " },
+           proc { |obj, *| "inside #{obj}* "} ]
+           
+# Start a Pry session using the prompt defined in my_prompt
+Pry.start(TOPLEVEL_BINDING, :prompt => my_prompt)

data/lib/pry.rb

@@ -0,0 +1,32 @@
+# (C) John Mair (banisterfiend) 2011
+# MIT License
+
+direc = File.dirname(__FILE__)
+
+$LOAD_PATH << File.expand_path(direc)
+
+require "method_source"
+require 'shellwords'
+require "readline"
+require "stringio"
+require "coderay"
+
+if RUBY_PLATFORM =~ /mswin/ || RUBY_PLATFORM =~ /mingw/
+  begin
+    require 'win32console'
+  rescue LoadError
+    $stderr.puts "Need to `gem install win32console`" 
+    exit 1
+  end
+end
+
+require "pry/version"
+require "pry/hooks"
+require "pry/print"
+require "pry/command_base"
+require "pry/commands"
+require "pry/prompts"
+require "pry/completion"
+require "pry/core_extensions"
+require "pry/pry_class"
+require "pry/pry_instance"

data/lib/pry/command_base.rb

@@ -0,0 +1,150 @@
+class Pry
+
+  # Basic command functionality. All user-defined commands must
+  # inherit from this class. It provides the `command` method.
+  class CommandBase
+    class << self
+      attr_accessor :commands
+      attr_accessor :opts, :output, :target
+
+      # private because we want to force function style invocation. We require
+      # that the location where the block is defined has the `opts`
+      # method in scope.
+      private
+      
+      # Defines a new Pry command.
+      # @param [String, Array] names The name of the command (or array of
+      #   command name aliases).
+      # @param [String] description A description of the command.
+      # @param [Hash] options The optional configuration parameters.
+      # @option options [Boolean] :keep_retval Whether or not to use return value
+      #   of the block for return of `command` or just to return `nil`
+      #   (the default).
+      # @yield The action to perform. The parameters in the block
+      #   determines the parameters the command will receive. All
+      #   parameters passed into the block will be strings. Successive
+      #   command parameters are separated by whitespace at the Pry prompt.
+      # @example
+      #   class MyCommands < Pry::CommandBase
+      #     command "greet", "Greet somebody" do |name|
+      #       puts "Good afternoon #{name.capitalize}!"
+      #     end
+      #   end
+      #
+      #   # From pry:
+      #   # pry(main)> _pry_.commands = MyCommands
+      #   # pry(main)> greet john
+      #   # Good afternoon John!
+      #   # pry(main)> help greet
+      #   # Greet somebody
+      def command(names, description="No description.", options={}, &block)
+        options = {
+          :keep_retval => false
+        }.merge!(options)
+        
+        @commands ||= {}
+
+        Array(names).each do |name|
+          commands[name] = {
+            :description => description,
+            :action => block,
+            :keep_retval => options[:keep_retval]
+          }
+        end
+      end
+
+      # Delete a command or an array of commands.
+      # Useful when inheriting from another command set and pruning
+      # those commands down to the ones you want.
+      # @param [Array<String>] names The command name or array
+      #   of command names you want to delete
+      # @example Deleteing inherited commands
+      #   class MyCommands < Pry::Commands
+      #     delete "show_method", "show_imethod", "show_doc", "show_idoc"
+      #   end
+      #   Pry.commands = MyCommands
+      def delete(*names)
+        names.each { |name| commands.delete(name) }
+      end
+
+      # Execute a command (this enables commands to call other commands).
+      # @param [String] name The command to execute
+      # @param [Array] args The parameters to pass to the command.
+      # @example Wrap one command with another
+      #   class MyCommands < Pry::Commands
+      #     command "ls2" do
+      #       output.puts "before ls"
+      #       run "ls"
+      #       output.puts "after ls"
+      #     end
+      #   end
+      def run(name, *args)
+        action = opts[:commands][name][:action]
+        instance_exec(*args, &action)
+      end
+
+      # Import commands from another command object.
+      # @param [Pry::CommandBase] klass The class to import from (must
+      #   be a subclass of `Pry::CommandBase`)
+      # @param [Array<String>] names The commands to import.
+      # @example
+      #   class MyCommands < Pry::CommandBase
+      #     import_from Pry::Commands, "ls", "show_method", "cd"
+      #   end
+      def import_from(klass, *names)
+        imported_hash = Hash[klass.commands.select { |k, v| names.include?(k) }]
+        commands.merge!(imported_hash)
+      end
+
+      # Create an alias for a command.
+      # @param [String] new_command The alias name.
+      # @param [String] orig_command The original command name.
+      # @param [String] desc The optional description.
+      # @example
+      #   class MyCommands < Pry::CommandBase
+      #     alias_command "help_alias", "help"
+      #   end
+      def alias_command(new_command_name, orig_command_name, desc=nil)
+        commands[new_command_name] = commands[orig_command_name].dup
+        commands[new_command_name][:description] = desc if desc
+      end
+
+      # Set the description for a command (replacing the old
+      # description.)
+      # @param [String] name The command name.
+      # @param [String] description The command description.
+      # @example
+      #   class MyCommands < Pry::CommandBase
+      #     desc "help", "help description"
+      #   end
+      def desc(name, description)
+        commands[name][:description] = description
+      end
+    end
+    
+    command "help", "This menu." do |cmd|
+      command_info = opts[:commands]
+      param = cmd
+
+      if !param
+        output.puts "Command list:"
+        output.puts "--"
+        command_info.each do |k, data|
+          output.puts "#{k}".ljust(18) + data[:description] if !data[:description].empty?
+        end
+      else
+        if command_info[param]
+          output.puts command_info[param][:description]
+        else
+          output.puts "No info for command: #{param}"
+        end
+      end
+    end
+
+    # Ensures that commands can be inherited
+    def self.inherited(klass)
+      klass.commands = commands.dup
+    end
+    
+  end
+end