pry-remote-enhanced 1.0.0

data/LICENSE

@@ -0,0 +1,21 @@
+pry-remote - Copyright (c) 2012 - Mon ouïe
+
+This software is provided 'as-is', without any express or
+implied warranty. In no event will the authors be held
+liable for any damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute
+it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented;
+   you must not claim that you wrote the original software.
+   If you use this software in a product, an acknowledgment
+   in the product documentation would be appreciated but
+   is not required.
+
+2. Altered source versions must be plainly marked as such,
+   and must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any
+   source distribution.

data/README.md

@@ -0,0 +1,65 @@
+# What is it?
+
+A way to start Pry remotely and to connect to it using DRb. This allows to
+access the state of the running program from anywhere.
+
+This repository is a fork of pry-remote with aims to:
+
+* Resolve existing issues in pry-remote
+* Refactor architecture to use more idiomatic Ruby
+* Add a testing suite
+* Improve support for Sidekiq and Foreman
+
+# Installation
+
+    gem install pry-remote-enhanced
+
+# Usage
+
+Here's a program starting pry-remote:
+
+    require 'pry-remote'
+
+    class Foo
+      def initialize(x, y)
+        binding.remote_pry
+      end
+    end
+
+    Foo.new 10, 20
+
+Running it will prompt you with a message telling you Pry is waiting for a
+program to connect itself to it:
+
+     [pry-remote] Waiting for client on drb://localhost:9876
+
+You can then connect yourself using ``pry-remote``:
+
+    $ pry-remote
+    From: example.rb @ line 7 in Foo#initialize:
+         2:
+         3: require 'pry-remote'
+         4:
+         5: class Foo
+         6:   def initialize(x, y)
+     =>  7:     binding.remote_pry
+         8:   end
+         9: end
+        10:
+        11: Foo.new 10, 20
+    pry(#<Foo:0x00000000d9b5e8>):1> self
+    => #<Foo:0x1efb3b0>
+    pry(#<Foo:0x00000001efb3b0>):2> ls -l
+    Local variables: [
+      [0] :_,
+      [1] :_dir_,
+      [2] :_file_,
+      [3] :_ex_,
+      [4] :_pry_,
+      [5] :_out_,
+      [6] :_in_,
+      [7] :x,
+      [8] :y
+    ]
+    pry(#<Foo:0x00000001efb3b0>):3> ^D
+

data/bin/pry-remote

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'pry-remote'
+PryRemote::CLI.new.run

data/lib/pry-remote.rb

@@ -0,0 +1,380 @@
+require 'pry'
+require 'slop'
+require 'drb'
+require 'readline'
+require 'open3'
+
+module PryRemote
+  DefaultHost = "127.0.0.1"
+  DefaultPort = 9876
+
+  # A class to represent an input object created from DRb. This is used because
+  # Pry checks for arity to know if a prompt should be passed to the object.
+  #
+  # @attr [#readline] input Object to proxy
+  InputProxy = Struct.new :input do
+    # Reads a line from the input
+    def readline(prompt)
+      case readline_arity
+      when 1 then input.readline(prompt)
+      else        input.readline
+      end
+    end
+
+    def completion_proc=(val)
+      input.completion_proc = val
+    end
+
+    def readline_arity
+      input.method_missing(:method, :readline).arity
+    rescue NameError
+      0
+    end
+  end
+
+  # Class used to wrap inputs so that they can be sent through DRb.
+  #
+  # This is to ensure the input is used locally and not reconstructed on the
+  # server by DRb.
+  class IOUndumpedProxy
+    include DRb::DRbUndumped
+
+    def initialize(obj)
+      @obj = obj
+    end
+
+    def completion_proc=(val)
+      if @obj.respond_to? :completion_proc=
+        @obj.completion_proc = proc { |*args, &block| val.call(*args, &block) }
+      end
+    end
+
+    def completion_proc
+      @obj.completion_proc if @obj.respond_to? :completion_proc
+    end
+
+    def readline(prompt)
+      if Readline == @obj
+        @obj.readline(prompt, true)
+      elsif @obj.method(:readline).arity == 1
+        @obj.readline(prompt)
+      else
+        $stdout.print prompt
+        @obj.readline
+      end
+    end
+
+    def puts(*lines)
+      @obj.puts(*lines)
+    end
+
+    def print(*objs)
+      @obj.print(*objs)
+    end
+
+    def printf(*args)
+      @obj.printf(*args)
+    end
+
+    def write(data)
+      @obj.write data
+    end
+
+    def <<(data)
+      @obj << data
+      self
+    end
+
+    # Some versions of Pry expect $stdout or its output objects to respond to
+    # this message.
+    def tty?
+      false
+    end
+  end
+
+  # Ensure that system (shell command) output is redirected for remote session.
+  System = proc do |output, cmd, _|
+    status = nil
+    Open3.popen3 cmd do |stdin, stdout, stderr, wait_thr|
+      stdin.close # Send EOF to the process
+
+      until stdout.eof? and stderr.eof?
+        if res = IO.select([stdout, stderr])
+          res[0].each do |io|
+            next if io.eof?
+            output.write io.read_nonblock(1024)
+          end
+        end
+      end
+
+      status = wait_thr.value
+    end
+
+    unless status.success?
+      output.puts "Error while executing command: #{cmd}"
+    end
+  end
+
+  ClientEditor = proc do |initial_content, line|
+    # Hack to use Pry::Editor
+    Pry::Editor.new(Pry.new).edit_tempfile_with_content(initial_content, line)
+  end
+
+  # A client is used to retrieve information from the client program.
+  Client = Struct.new(:input, :output, :thread, :stdout, :stderr,
+                      :editor) do
+    # Waits until both an input and output are set
+    def wait
+      sleep 0.01 until input and output and thread
+    end
+
+    # Tells the client the session is terminated
+    def kill
+      thread.run
+    end
+
+    # @return [InputProxy] Proxy for the input
+    def input_proxy
+      InputProxy.new input
+    end
+  end
+
+  class Server
+    def self.run(object, host = DefaultHost, port = DefaultPort, options = {})
+      new(object, host, port, options).run
+    end
+
+    def initialize(object, host = DefaultHost, port = DefaultPort, options = {})
+      @host    = host
+      @port    = port
+
+      @object  = object
+      @options = options
+
+      @client = PryRemote::Client.new
+      DRb.start_service uri, @client
+    end
+
+    # Code that has to be called for Pry-remote to work properly
+    def setup
+      @hooks = Pry::Hooks.new
+
+      @hooks.add_hook :before_eval, :pry_remote_capture do
+        capture_output
+      end
+
+      @hooks.add_hook :after_eval, :pry_remote_uncapture do
+        uncapture_output
+      end
+
+      # Before Pry starts, save the pager config.
+      # We want to disable this because the pager won't do anything useful in
+      # this case (it will run on the server).
+      Pry.config.pager, @old_pager = false, Pry.config.pager
+
+      # As above, but for system config
+      Pry.config.system, @old_system = PryRemote::System, Pry.config.system
+
+      Pry.config.editor, @old_editor = editor_proc, Pry.config.editor
+    end
+
+    # Code that has to be called after setup to return to the initial state
+    def teardown
+      # Reset config
+      Pry.config.editor = @old_editor
+      Pry.config.pager  = @old_pager
+      Pry.config.system = @old_system
+
+      puts "[pry-remote] Remote session terminated"
+
+      begin
+        @client.kill
+      rescue DRb::DRbConnError
+        puts "[pry-remote] Continuing to stop service"
+      ensure
+        puts "[pry-remote] Ensure stop service"
+        DRb.stop_service
+      end
+    end
+
+    # Captures $stdout and $stderr if so requested by the client.
+    def capture_output
+      @old_stdout, $stdout = if @client.stdout
+                               [$stdout, @client.stdout]
+                             else
+                               [$stdout, $stdout]
+                             end
+
+      @old_stderr, $stderr = if @client.stderr
+                               [$stderr, @client.stderr]
+                             else
+                               [$stderr, $stderr]
+                             end
+    end
+
+    # Resets $stdout and $stderr to their previous values.
+    def uncapture_output
+      $stdout = @old_stdout
+      $stderr = @old_stderr
+    end
+
+    def editor_proc
+      proc do |file, line|
+        File.write(file, @client.editor.call(File.read(file), line))
+      end
+    end
+
+    # Actually runs pry-remote
+    def run
+      puts "[pry-remote] Waiting for client on #{uri}"
+      @client.wait
+
+      puts "[pry-remote] Client received, starting remote session"
+      setup
+
+      Pry.start(@object, @options.merge(:input => client.input_proxy,
+                                        :output => client.output,
+                                        :hooks => @hooks))
+    ensure
+      teardown
+    end
+
+    # @return Object to enter into
+    attr_reader :object
+
+    # @return [PryServer::Client] Client connecting to the pry-remote server
+    attr_reader :client
+
+    # @return [String] Host of the server
+    attr_reader :host
+
+    # @return [Integer] Port of the server
+    attr_reader :port
+
+    # @return [String] URI for DRb
+    def uri
+      "druby://#{host}:#{port}"
+    end
+  end
+
+  # Parses arguments and allows to start the client.
+  class CLI
+    def initialize(args = ARGV)
+      params = Slop.parse args, :help => true do
+        banner "#$PROGRAM_NAME [OPTIONS]"
+
+        on :s, :server=, "Host of the server (#{DefaultHost})", :argument => :optional,
+           :default => DefaultHost
+        on :p, :port=, "Port of the server (#{DefaultPort})", :argument => :optional,
+           :as => Integer, :default => DefaultPort
+        on :w, :wait, "Wait for the pry server to come up",
+           :default => false
+        on :r, :persist, "Persist the client to wait for the pry server to come up each time",
+           :default => false
+        on :c, :capture, "Captures $stdout and $stderr from the server (true)",
+           :default => true
+        on :f, "Disables loading of .pryrc and its plugins, requires, and command history "
+      end
+
+      exit if params.help?
+
+      @host = params[:server]
+      @port = params[:port]
+
+      @wait = params[:wait]
+      @persist = params[:persist]
+      @capture = params[:capture]
+
+      Pry.initial_session_setup unless params[:f]
+    end
+
+    # @return [String] Host of the server
+    attr_reader :host
+
+    # @return [Integer] Port of the server
+    attr_reader :port
+
+    # @return [String] URI for DRb
+    def uri
+      "druby://#{host}:#{port}"
+    end
+
+    attr_reader :wait
+    attr_reader :persist
+    attr_reader :capture
+    alias wait? wait
+    alias persist? persist
+    alias capture? capture
+
+    def run
+      while true
+        connect
+        break unless persist?
+      end
+    end
+
+    # Connects to the server
+    #
+    # @param [IO] input  Object holding input for pry-remote
+    # @param [IO] output Object pry-debug will send its output to
+    def connect(input = Pry.config.input, output = Pry.config.output)
+      local_ip = UDPSocket.open {|s| s.connect(@host, 1); s.addr.last}
+      DRb.start_service "druby://#{local_ip}:0"
+      client = DRbObject.new(nil, uri)
+
+      cleanup(client)
+
+      input  = IOUndumpedProxy.new(input)
+      output = IOUndumpedProxy.new(output)
+
+      begin
+        client.input  = input
+        client.output = output
+      rescue DRb::DRbConnError => ex
+        if wait? || persist?
+          sleep 1
+          retry
+        else
+          raise ex
+        end
+      end
+
+      if capture?
+        client.stdout = $stdout
+        client.stderr = $stderr
+      end
+
+      client.editor = ClientEditor
+
+      client.thread = Thread.current
+
+      sleep
+      DRb.stop_service
+    end
+
+    # Clean up the client
+    def cleanup(client)
+      begin
+        # The method we are calling here doesn't matter.
+        # This is a hack to close the connection of DRb.
+        client.cleanup
+      rescue DRb::DRbConnError, NoMethodError
+      end
+    end
+  end
+end
+
+class Object
+  # Starts a remote Pry session
+  #
+  # @param [String]  host Host of the server
+  # @param [Integer] port Port of the server
+  # @param [Hash] options Options to be passed to Pry.start
+  def remote_pry(host = PryRemote::DefaultHost, port = PryRemote::DefaultPort, options = {})
+    PryRemote::Server.new(self, host, port, options).run
+  end
+
+  # a handy alias as many people may think the method is named after the gem
+  # (pry-remote)
+  alias pry_remote remote_pry
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: pry-remote-enhanced
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Joseph Jaber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: slop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: A modern fork of pry-remote
+email: mail@josephjaber.com
+executables:
+- pry-remote
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/pry-remote.rb
+- README.md
+- LICENSE
+- bin/pry-remote
+homepage: http://github.com/josephjaber/pry-remote
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23.2
+signing_key: 
+specification_version: 3
+summary: A modern fork of pry-remote
+test_files: []