pry 0.7.7.2-i386-mingw32 → 0.8.0-i386-mingw32

data/Rakefile

@@ -21,6 +21,7 @@ def apply_spec_defaults(s)
   s.require_path = 'lib'
   s.add_dependency("ruby_parser",">=2.0.5")
   s.add_dependency("coderay",">=0.9.7")
+  s.add_dependency("slop",">=1.5.2")
   s.add_development_dependency("bacon",">=1.1.0")
   s.homepage = "http://banisterfiend.wordpress.com"
   s.has_rdoc = 'yard'
@@ -30,13 +31,13 @@ def apply_spec_defaults(s)
 end
 
 task :test do
-  sh "bacon -k #{direc}/test/test.rb"
+  sh "bacon #{direc}/test/test.rb"
 end
 
 desc "run pry"
 task :pry do
-  require "#{direc}/lib/pry.rb"
-  Pry.start
+  require "#{direc}/lib/pry"
+  binding.pry
 end
 
 desc "show pry version"
@@ -76,7 +77,7 @@ end
 namespace :jruby do
   spec = Gem::Specification.new do |s|
     apply_spec_defaults(s)
-    s.add_dependency("method_source","=0.2.0")
+    s.add_dependency("method_source",">=0.4.0")
     s.platform = "java"
   end
   

data/bin/pry

@@ -9,74 +9,66 @@ 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] 
+opts = Slop.parse do
+  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
+  on :e, :exec, "A line of code to execute in context before the session starts", true
+  on :f, "Surpress loading of ~/.pryrc"
+  on "no-color", "Disable syntax highlighting for session"
 
-  opts.on("--no-color", "Start session without syntax highlighting.") do 
-    Pry.color = false
+  on "simple-prompt", "Enable simple prompt mode" do
+    Pry.prompt = Pry::SIMPLE_PROMPT
   end
 
-  opts.on("--simple-prompt", "Simple prompt mode.") do 
-    Pry.prompt = Pry::SIMPLE_PROMPT
+  on :r, :require, "`require` a Ruby script at startup", true do |file|
+    require file
   end
 
-  opts.on("-I LOADPATH", "Specify $LOAD_PATH directory.") do  |load_path|
-    $LOAD_PATH << load_path
+  on :I, "Add a path to the $LOAD_PATH", true do |path|
+    $LOAD_PATH << path
   end
 
-  opts.on("-v", "--version", "Display the Pry version.") do
+  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
+  on(:c, :context,
+    "Start the session in the specified context. Equivalent to `context.pry` in a session.",
+    true,
+    :default => "TOPLEVEL_BINDING"
+    )
 
-  opts.on_tail("-h", "--help", "This message.") do 
-    puts opts
+  on :h, :help, "This message" do
+    puts help
     exit
   end
-end.parse!
+end
 
 # invoked via cli
 Pry.cli = true
 
+class Pry::Commands
+  command "reset", "Reset the REPL to a clean state." do
+    output.puts "Pry reset."
+    exec("pry")
+  end
+end
+
 # load ~/.pryrc, if not suppressed with -f option
-Pry.should_load_rc = false if !options[:loadrc]
+Pry.should_load_rc = !opts.f?
 
 # create the actual context
-context = Pry.binding_for(eval(options[:context_string]))
+context = Pry.binding_for(eval(opts[:context]))
 
 # run code passed with `-e`, if there is any.
-if options[:code]
-  Pry.new(:input => StringIO.new(options[:code]), :print => proc {}).rep(context)
+if opts.exec?
+  Pry.new(:input => StringIO.new(opts[:exec]), :print => proc {}).rep(context)
 end
 
 # start the session

data/lib/pry.rb

@@ -15,18 +15,25 @@ if RUBY_PLATFORM =~ /mswin/ || RUBY_PLATFORM =~ /mingw/
   begin
     require 'win32console'
   rescue LoadError
-    $stderr.puts "Need to `gem install win32console`" 
+    $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"
+require "#{direc}/pry/version"
+require "#{direc}/pry/hooks"
+require "#{direc}/pry/print"
+require "#{direc}/pry/command_base"
+require "#{direc}/pry/commands"
+require "#{direc}/pry/prompts"
+require "#{direc}/pry/custom_completions"
+require "#{direc}/pry/completion"
+require "#{direc}/pry/core_extensions"
+require "#{direc}/pry/pry_class"
+require "#{direc}/pry/pry_instance"
+
+
+# TEMPORARY HACK FOR BUG IN JRUBY 1.9 REGEX (which kills CodeRay)
+if RUBY_VERSION =~ /1.9/ && RUBY_ENGINE =~ /jruby/
+  Pry.color = false
+end

data/lib/pry/command_base.rb

@@ -1,9 +1,15 @@
+direc = File.dirname(__FILE__)
+require 'rubygems/dependency_installer'
+require "#{direc}/command_base_helpers"
+
 class Pry
 
   # Basic command functionality. All user-defined commands must
   # inherit from this class. It provides the `command` method.
   class CommandBase
     class << self
+      include CommandBaseHelpers
+
       attr_accessor :commands
       attr_accessor :opts, :output, :target
 
@@ -11,7 +17,7 @@ class Pry
       # 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).
@@ -39,17 +45,22 @@ class Pry
       #   # Greet somebody
       def command(names, description="No description.", options={}, &block)
         options = {
-          :keep_retval => false
+          :keep_retval => false,
+          :requires_gem => nil
         }.merge!(options)
-        
+
         @commands ||= {}
 
-        Array(names).each do |name|
-          commands[name] = {
-            :description => description,
-            :action => block,
-            :keep_retval => options[:keep_retval]
-          }
+        if command_dependencies_met?(options)
+          Array(names).each do |name|
+            commands[name] = {
+              :description => description,
+              :action => block,
+              :keep_retval => options[:keep_retval]
+            }
+          end
+        else
+          create_command_stub(names, description, options, block)
         end
       end
 
@@ -79,8 +90,15 @@ class Pry
       #     end
       #   end
       def run(name, *args)
-        action = opts[:commands][name][:action]
-        instance_exec(*args, &action)
+        command_processor =  CommandProcessor.new(target.eval('_pry_'))
+
+        if command_processor.system_command?(name)
+          command_processor.execute_system_command("#{name} #{args.join(' ')}", target)
+        else
+          raise "#{name.inspect} is not a valid pry command." unless opts[:commands].include? name
+          action = opts[:commands][name][:action]
+          instance_exec(*args, &action)
+        end
       end
 
       # Import commands from another command object.
@@ -121,30 +139,65 @@ class Pry
         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 "--"
+      if !cmd
+        output.puts
+        help_text = heading("Command List:") + "\n"
         command_info.each do |k, data|
-          output.puts "#{k}".ljust(18) + data[:description] if !data[:description].empty?
+          if !data[:stub_info]
+            help_text << ("#{k}".ljust(18) + data[:description] + "\n") if !data[:description].empty?
+          else
+            help_text << (bold("#{k}".ljust(18) + data[:description] + "\n")) if !data[:description].empty?
+          end
         end
+        stagger_output(help_text)
       else
-        if command_info[param]
-          output.puts command_info[param][:description]
+        if command_info[cmd]
+          output.puts command_info[cmd][:description]
         else
-          output.puts "No info for command: #{param}"
+          output.puts "No info for command: #{cmd}"
+        end
+      end
+    end
+
+    command "install", "Install a disabled command." do |name|
+      stub_info = commands[name][:stub_info]
+
+      if !stub_info
+        output.puts "Not a command stub. Nothing to do."
+        next
+      end
+
+      output.puts "Attempting to install `#{name}` command..."
+      gems_to_install = Array(stub_info[:requires_gem])
+
+      gem_install_failed = false
+      gems_to_install.each do |g|
+        next if gem_installed?(g)
+        output.puts "Installing `#{g}` gem..."
+
+        begin
+          Gem::DependencyInstaller.new.install(g)
+        rescue Gem::GemNotFoundException
+          output.puts "Required Gem: `#{g}` not found. Aborting command installation."
+          gem_install_failed = true
+          next
         end
       end
+      next if gem_install_failed
+
+      Gem.refresh
+      load "#{File.dirname(__FILE__)}/commands.rb"
+      output.puts "Installation of `#{name}` successful! Type `help #{name}` for information"
     end
 
     # Ensures that commands can be inherited
     def self.inherited(klass)
       klass.commands = commands.dup
     end
-    
+
   end
 end

data/lib/pry/command_base_helpers.rb

@@ -0,0 +1,241 @@
+class Pry
+  class CommandBase
+    module CommandBaseHelpers
+
+     private
+
+     def gem_installed?(gem_name)
+        require 'rubygems'
+        !!Gem.source_index.find_name(gem_name).first
+      end
+
+      def command_dependencies_met?(options)
+        return true if !options[:requires_gem]
+        Array(options[:requires_gem]).all? do |g|
+          gem_installed?(g)
+        end
+      end
+
+      def stub_proc(name, options)
+        gems_needed = Array(options[:requires_gem])
+        gems_not_installed = gems_needed.select { |g| !gem_installed?(g) }
+        proc do
+          output.puts "\n`#{name}` requires the following gems to be installed: `#{gems_needed.join(", ")}`"
+          output.puts "Command not available due to dependency on gems: `#{gems_not_installed.join(", ")}` not being met."
+          output.puts "Type `install #{name}` to install the required gems and activate this command."
+        end
+      end
+
+      def create_command_stub(names, description, options, block)
+        Array(names).each do |name|
+          commands[name] = {
+            :description => "Not available. Execute `#{name}` command for more information.",
+            :action => stub_proc(name, options),
+            :stub_info => options
+          }
+        end
+      end
+
+      #
+      # Color helpers:
+      #   gray, red, green, yellow, blue, purple, cyan, white,
+      #   and bright_red, bright_green, etc...
+      #
+      # ANSI color codes:
+      #   \033 => escape
+      #     30 => color base
+      #      1 => bright
+      #      0 => normal
+      #
+
+      COLORS = {
+         "black" => 0,
+         "red" => 1,
+         "green" => 2,
+         "yellow" => 3,
+         "blue" => 4,
+         "purple" => 5,
+         "magenta" => 5,
+         "cyan" => 6,
+         "white" => 7
+      }
+
+      COLORS.each do |color, i|
+        define_method color do |str|
+          Pry.color ? "\033[0;#{30+i}m#{str}\033[0m" : str
+        end
+
+        define_method "bright_#{color}" do |str|
+          Pry.color ? "\033[1;#{30+i}m#{str}\033[0m" : str
+        end
+      end
+
+      alias_method :grey, :bright_black
+      alias_method :gray, :bright_black
+
+      require 'set'
+      VALID_COLORS = Set.new(
+        COLORS.keys +
+        COLORS.keys.map{|k| "bright_#{k}" } +
+        ["grey", "gray"]
+      )
+
+      def bold(text)
+        Pry.color ? "\e[1m#{text}\e[0m" : text
+      end
+
+      #
+      # Colorize a string that has "color tags".
+      #
+      # Examples:
+      #    puts colorize("<light_green><magenta>*</magenta> Hey mom! I am <light_blue>SO</light_blue> colored right now.</light_green>")
+      #
+      def colorize(string)
+        stack = []
+
+        # split the string into tags and literal strings
+        tokens          = string.split(/(<\/?[\w\d_]+>)/)
+        tokens.delete_if { |token| token.size == 0 }
+
+        result        = ""
+
+        tokens.each do |token|
+
+          # token is an opening tag!
+
+          if /<([\w\d_]+)>/ =~ token and VALID_COLORS.include?($1) #valid_tag?($1)
+            stack.push $1
+
+          # token is a closing tag!
+
+          elsif /<\/([\w\d_]+)>/ =~ token and VALID_COLORS.include?($1) # valid_tag?($1)
+
+            # if this color is on the stack somwehere...
+            if pos = stack.rindex($1)
+              # close the tag by removing it from the stack
+              stack.delete_at pos
+            else
+              raise "Error: tried to close an unopened color tag -- #{token}"
+            end
+
+          # token is a literal string!
+
+          else
+
+            color = (stack.last || "white")
+            #color = BBS_COLOR_TABLE[color.to_i] if color =~ /^\d+$/
+            result << send(color, token) # colorize the result
+
+          end
+
+        end
+
+        result
+      end
+
+      def highlight(string, regexp, highlight_color=:bright_yellow)
+        highlighted = string.gsub(regexp) { |match| "<#{highlight_color}>#{match}</#{highlight_color}>" }
+      end
+
+      # formatting
+      def heading(text)
+        text = "#{text}\n--"
+        Pry.color ? "\e[1m#{text}\e[0m": text
+      end
+
+      def page_size
+        27
+      end
+
+      # a simple pager for systems without `less`. A la windows.
+      def simple_pager(text)
+        text_array = text.lines.to_a
+        text_array.each_slice(page_size) do |chunk|
+          output.puts chunk.join
+          break if chunk.size < page_size
+          if text_array.size > page_size
+            output.puts "\n<page break> --- Press enter to continue ( q<enter> to break ) --- <page break>"
+            break if $stdin.gets.chomp == "q"
+          end
+        end
+      end
+
+      # Try to use `less` for paging, if it fails then use
+      # simple_pager. Also do not page if Pry.pager is falsey
+      # FIXME! Another JRuby hack
+      def stagger_output(text)
+        if text.lines.count < page_size || !Pry.pager
+          output.puts text
+          return
+        end
+
+        # FIXME! Another JRuby hack
+        if Object.const_defined?(:RUBY_ENGINE) && RUBY_ENGINE =~ /jruby/
+          simple_pager(text)
+        else
+          lesspipe { |less| less.puts text }
+        end
+      rescue Errno::ENOENT
+        simple_pager(text)
+      rescue Errno::EPIPE
+      end
+
+      #
+      # Create scrollable output via less!
+      #
+      # This command runs `less` in a subprocess, and gives you the IO to its STDIN pipe
+      # so that you can communicate with it.
+      #
+      # Example:
+      #
+      #   lesspipe do |less|
+      #     50.times { less.puts "Hi mom!" }
+      #   end
+      #
+      # The default less parameters are:
+      # * Allow colour
+      # * Don't wrap lines longer than the screen
+      # * Quit immediately (without paging) if there's less than one screen of text.
+      #
+      # You can change these options by passing a hash to `lesspipe`, like so:
+      #
+      #   lesspipe(:wrap=>false) { |less| less.puts essay.to_s }
+      #
+      # It accepts the following boolean options:
+      #    :color  => Allow ANSI colour codes?
+      #    :wrap   => Wrap long lines?
+      #    :always => Always page, even if there's less than one page of text?
+      #
+      def lesspipe(*args)
+        if args.any? and args.last.is_a?(Hash)
+          options = args.pop
+        else
+          options = {}
+        end
+
+        output = args.first if args.any?
+
+        params = []
+        params << "-R" unless options[:color] == false
+        params << "-S" unless options[:wrap] == true
+        params << "-F" unless options[:always] == true
+        if options[:tail] == true
+          params << "+\\>"
+          $stderr.puts "Seeking to end of stream..."
+        end
+        params << "-X"
+
+        IO.popen("less #{params * ' '}", "w") do |less|
+          if output
+            less.puts output
+          else
+            yield less
+          end
+        end
+      end
+
+    end
+  end
+end
+
+