pry-em 0.1

data/LICENSE.MIT

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Conrad Irwin <conrad.irwin@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,44 @@
+# Introduction
+
+`pry-em` is a plugin for the Ruby shell [pry](http://pry.github.com) which allows you to poke around with objects in [EventMachine](http://rubyeventmachine.com). It's designed to make playing with async stuff as easy as pry!
+
+## How to use it?
+
+As with all pry plugins, you can just:
+
+    gem install pry-em
+
+Then, any time you want to run a command that returns a deferrable, prefix it by `em:`. For example:
+
+    pry(main)> em: EM::HttpRequest.new("http://example.com/").get
+
+This does two things. Firstly, before running your command, it ensures that EventMachine is running. And Secondly, it sits and waits for your deferrable to succeed or fail before returning the result to you in `_`
+
+    pry(main)> em: EM::HttpRequest.new("http://example.com/").get
+    callback => #<EventMachine::HttpClient:0x25b36f8
+                  @bytes_remaining=0,
+                  …
+
+    pry(main)> em: EM::HttpRequest.new("http://examplefail/").get
+    errback => #<EventMachine::HttpClient:0x25b36f8
+                  @bytes_remaining=0,
+                  @error="unable to resolve server address",
+                  …
+
+If your deferrable takes a loong time to succeed or fail (where a long time is "more than 3 seconds" by default), a timeout error will be raised. You can configure the length of the timeout by putting a number of seconds into the prefix:
+
+    pry(main)> em 10: EM::HttpRequest.new("https://slow.domain.example.com/").get
+    RuntimeError: Timeout after 10 seconds
+    from /0/ruby/pry-em/lib/pry-em.rb:71:in `wait_for_deferrable'
+
+## How does it work? (aka. it's broken, why?!)
+
+The basic magic is to boot the EM reactor into a different thread from that which is running the Pry shell. When you want to run something that requires the reactor, we send it across to the eventmachine thread, and then enter a simple "sleep until done" loop.
+
+Unfortunately it's possibly (and in fact quite easy) to boot Pry into a thread which is already running the EM reactor. In this case, if we were to enter the "sleep until done" loop, we'd never make any progress, as the stuff that needed doing would be waiting for us to stop sleeping. If `pry-em` notices that this has happened, it will raise an Exception with a friendly message.
+
+## Metafoo
+
+`pry-em` is licensed under the MIT license, see LICENSE.MIT for details. Bug-reports, feature-requests and patches are most welcome.
+
+I'm indebted to @samstokes for many of the ideas behind `pry-em`.

data/lib/pry-em.rb

@@ -0,0 +1,79 @@
+EmCommands = Pry::CommandSet.new do
+
+  EM_DESCRIPTION = "Wait for a deferrable to succeed or fail, a timeout can be specified before the colon."
+  EM_CONFIG = {
+    :keep_retval  => true,
+    :interpolate  => false,
+    :listing      => "em[timeout=3]:",
+    :requires_gem => 'eventmachine'
+  }
+
+  command /\s*em\s*([0-9\.]*)\s*:(.*)/, EM_DESCRIPTION, EM_CONFIG do |timeout, source|
+
+    # Boot EM before eval'ing the source as it's likely to depend on the reactor.
+    run_em_if_necessary!
+
+    # This can happen for example if you do:
+    #  em: EM::HttpRequest.new("http://www.google.com/").get.callback{ binding.pry }
+    # There ought to be a solution, but it will involve shunting either Pry or EM
+    # onto a new thread.
+    if EM.reactor_thread == Thread.current
+      raise "Could not wait for deferrable, you're in the EM thread!
+              If you don't know what to do, try `cd ..`, or just hit ctrl-C until it dies."
+    end
+
+    deferrable = target.eval(source)
+
+    # TODO: Allow the user to configure the default timeout
+    timeout = timeout == "" ? 3 : Float(timeout)
+
+    wait_for_deferrable(deferrable, timeout) unless deferrable.nil?
+  end
+
+  helpers do
+    # Boot a new EventMachine reactor into another thread.
+    # This allows us to continue to interact with the user on the front-end thread,
+    # while they run event-machine commands in the background.
+    def run_em_if_necessary!
+      require 'eventmachine' unless defined?(EM)
+      Thread.new{ EM.run } unless EM.reactor_running?
+      sleep 0.01 until EM.reactor_running?
+    end
+
+    # Run a deferrable on an EM reactor in a different thread,
+    # sleep until it has finished, and then return the result.
+    #
+    # The result is defined to be as useful to an interactive shell user as possible:
+    #
+    # If the deferrable succeeds or fails with one argument, that one argument is
+    # returned; though if it succeeds or fails with many arguments, an array is returned.
+    #
+    def wait_for_deferrable(deferrable, timeout)
+
+      retval, finished = nil
+
+      EM::Timer.new(timeout) { finished ||= :timeout }
+
+      [:callback, :errback].each do |method|
+        begin
+          deferrable.__send__ method do |*result|
+            finished = method
+            retval = result.size > 1 ? result : result.first
+          end
+        rescue NoMethodError
+          output.warn "WARNING: is not deferrable? #{deferrable}"
+          break
+        end
+      end
+
+      sleep 0.01 until finished
+
+      raise "Timeout after #{timeout} seconds" if finished == :timeout
+
+      # TODO: This doesn't interact well with the pager.
+      output.print "#{finished} " #=> 
+      retval
+    end
+  end
+end
+Pry.config.commands.import EmCommands

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification 
+name: pry-em
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Conrad Irwin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-24 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: pry
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: em! is a synchronous wrapper around deferrables, so that you can interact with them as though they were normal function calls.
+email: conrad.irwin@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/pry-em.rb
+- README.markdown
+- LICENSE.MIT
+has_rdoc: true
+homepage: http://github.com/ConradIrwin/pry-em
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Provides an em! function that can be used to play with deferrable more easily.
+test_files: []
+