mind_control 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9d3b0a0e916eeadf4ef8d8d7bf4ceafe05c45fcf
+  data.tar.gz: f93222fed2eb383935dfc31b8bdebbf5386652b4
+SHA512:
+  metadata.gz: dea7601b54a74ac38a745dbf604a537f079f87f16c011e5bb4890be00ce1d677e1d3bac34a1c40ed44bd9435af3cc6ce3bb8ef56a863e7ebf8ba15c9bbe9e038
+  data.tar.gz: 22ba438dfddb4cbac25c4192889a5491af89041e63bd22b4f85a3302f48457a72aafc7e76b5e556279aebb713343fe768a5a7195bd9b4a4ba401f25465520abb

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.rvmrc

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Denis Diachkov
+
+MIT License
+
+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.md

@@ -0,0 +1,105 @@
+# Mind Control
+
+Embeddable runtime Pry-based REPL console for long-running programs.
+
+Features:
+
+- Executes code without interruption of the host program;
+- Full fledged Pry console with code highlighting and completion;
+- Allows multiple connections;
+- EventMachine integration;
+- Has very few dependencies (no DRb or EventMachine);
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "mind_control"
+```
+
+## Requirements
+
+- Ruby 1.9+;
+- *NIX operating system (uses UNIX sockets);
+
+## Usage
+
+To start console server:
+
+```ruby
+require "mind_control"
+MindControl.start
+```
+
+You can also set Pry target (`something.pry`):
+
+```ruby
+...
+MindControl.start :target => something
+```
+
+Or Pry options:
+
+```ruby
+...
+MindControl.start :pry => { .. options for pry instance .. }
+```
+
+Or set program name (see "Connection"):
+
+```ruby
+...
+MindControl.start :name => "some name"
+```
+
+### Connection
+
+Run in terminal:
+
+```console
+$ bundle exec mind_control
+```
+
+You will be prompted with a list of currently running MindControlled processes.
+
+Or, if you already know name or PID of process:
+
+```console
+$ bundle exec mind_control name_or_pid
+```
+
+### Capture output
+
+You can capture STDOUT/STDERR of host program. To do that execute `capture-output` in REPL.
+
+```text
+[1] pry(main)> capture-output --help
+
+Usage: capture_output [ --no-stdout | --no-stderr ] [ -f, --filter <regexp> ]
+
+Captures host program STDOUT and STDERR and prints it to user.
+
+        --no-stdout      Do not capture STDOUT.
+        --no-stderr      Do not capture STDERR.
+    -f, --filter         Filter output with given regular expression.
+    -h, --help           Show this message.
+```
+
+### EventMachine
+
+MindControl can be used with EventMachine. Just require file and set `EventMachine` as target and
+all commands will be evaluated in the context of running reactor.
+
+```ruby
+require "mind_control"
+require "mind_control/em"
+
+MindControl.start :target => EventMachine
+```
+
+## TODO
+
+- Better readme;
+- Tests;
+- Get rid of Engrish;

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList[ "test/test*.rb" ]
+  t.verbose = true
+end

data/bin/mind_control

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+Signal.trap( :INT ) { exit }
+
+# Add gem's lib dir to load path
+$LOAD_PATH.unshift File.expand_path( "../../lib", __FILE__ )
+
+require "slop"
+require "mind_control"
+
+# Parse options
+begin
+  options = Slop.parse!( help: true ) do
+    banner "Usage: #{File.basename( $0 )} [socket name] [options]"
+    on "d", "sockets-dir=", "Set sockets search path."
+  end
+rescue Slop::MissingArgumentError => e
+  abort e.message
+end
+
+# Console interface
+cui = MindControl::CUI.new
+
+# Get list of running MindControlled processes
+running_processes =
+  MindControl::Client.get_running_processes( options[ "sockets-dir" ] || MindControl::DEFAULT_SOCKETS_DIR )
+
+unless running_processes.any?
+  cui.show_error "No running processes found!"
+  exit
+end
+
+process =
+  # If filter given
+  if filter = ARGV[ 0 ]
+    # Filter processes by substring in name or pid equality
+    filtered_processes = running_processes.select! { |p| p.name.include?( filter ) || p.pid.to_s == filter.to_i }
+
+    # If filter matches 1 process -- connect to it, otherwise ask user to select process from filtered list
+    filtered_processes.size == 1 ? filtered_processes[ 0 ] : cui.select_process( filtered_processes )
+  else
+    # Ask user to select process
+    cui.select_process( running_processes )
+  end
+
+begin
+  cui.show_debug "Connecting to #{process.name} via #{process.socket} ..."
+  MindControl::Client.connect( process )
+rescue Exception => e
+  cui.show_error e.message
+end

data/lib/mind_control/client.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+require "mind_control"
+require "socket"
+
+module MindControl
+  ##
+  # MindControl client.
+  #
+  module Client
+    extend self
+
+    # Running process struct.
+    Process = Struct.new( :name, :pid, :socket )
+
+    ##
+    # Returns running processes.
+    #
+    # @param [String] sockets_dir Directory with MindControl sockets.
+    # @return [Array<MindControl::Client::Process>]
+    #
+    def get_running_processes( sockets_dir )
+      Dir.glob( File.join( sockets_dir, "*.sock" )).map do |file|
+        name, pid = File.basename( file, ".sock" ).split( "." )
+        Process.new( name, pid, file )
+      end
+    end
+
+    ##
+    # Connect to given process.
+    # @param [MindControl::Client::Process] process Process to connect to.
+    #
+    def connect( process )
+      UNIXSocket.open( process.socket ) do |socket|
+        socket.send_io STDIN
+        socket.send_io STDOUT
+
+        # Wait for disconnect
+        socket.recv( 0 )
+      end
+    end
+  end
+end

data/lib/mind_control/cui.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+require "highline"
+
+module MindControl
+  ##
+  # Console User Interface.
+  #
+  class CUI
+    attr_reader :highline
+
+    ##
+    # @param [IO] stdin (STDIN) Console input.
+    # @param [IO] stdout (STDOUT) Console output.
+    #
+    def initialize( stdin = STDIN, stdout = STDOUT )
+      @highline = ::HighLine.new( stdin, stdout )
+    end
+
+    ##
+    # Ask user to select process from list.
+    #
+    # @param [Array<MindControl::Client::Process>] process_list
+    # @return [MindControl::Client::Process]
+    #
+    def select_process( process_list )
+      highline.choose do |menu|
+        menu.header    = "Select process"
+        menu.select_by = :index
+
+        process_list.each do |process|
+          menu.choice( "#{process.name} (PID: #{process.pid})" ) { process }
+        end
+      end
+    end
+
+    ##
+    # Show debug message.
+    # @param [String] message
+    #
+    def show_debug( message )
+      highline.say HighLine::String.new( message ).white
+    end
+
+    ##
+    # Show error message.
+    # @param [String] message
+    #
+    def show_error( message )
+      highline.say HighLine::String.new( message ).red
+    end
+  end
+end

data/lib/mind_control/em.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+require "thread"
+
+module EventMachine
+  ##
+  # Context for Pry.
+  #
+  def self.__binding__
+    @binding ||= EventMachine.send( :binding ).tap do |binding|
+      orig_eval = binding.method( :eval )
+
+      ##
+      # Eval code in reactor context and return result.
+      #
+      binding.define_singleton_method :eval do |*args, &block|
+        raise "Reactor not running!" unless EventMachine.reactor_running?
+
+        # Channel between our and reactor threads
+        queue = ::Queue.new
+
+        # In reactor context
+        EventMachine::next_tick do
+          # In case of fibered code we should create Fiber
+          Fiber.new {
+            begin
+              queue.push orig_eval.call( *args, &block )
+            rescue Exception => e
+              # Return errors too
+              queue.push e
+            end
+          }.resume
+        end
+
+        # Wait for result
+        return queue.pop.tap do |result|
+          raise result if result.is_a?( Exception )
+        end
+      end
+    end
+  end
+end

data/lib/mind_control/loggable.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+require "logger"
+
+module MindControl
+  ##
+  # Mixin for event logging.
+  #
+  module Loggable
+
+    #
+    # Add all logging methods from standard Logger class.
+    #
+
+    { :debug => Logger::Severity::DEBUG,
+      :info  => Logger::Severity::INFO,
+      :warn  => Logger::Severity::WARN,
+      :error => Logger::Severity::ERROR,
+      :fatal => Logger::Severity::FATAL }.each do |name, severity|
+
+      ##
+      # @param [String] message Event text.
+      #
+      define_method name do |message = nil, &block|
+        raise ArgumentError, "block is missing" if !message && !block
+        logger.add severity, message, facility, &block if logger # NB: log ONLY if logger is set
+      end
+    end
+
+    private
+
+    ##
+    # Returns global logger.
+    # @return [Logger, nil]
+    #
+    def logger
+      MindControl.logger
+    end
+
+    ##
+    # Returns log facility for current class: demodulized snake_cased class name.
+    # @return [String]
+    #
+    def facility
+      @facility ||= self.class.name.split( "::" ).last.gsub( /([a-z])([A-Z])/, "\\1_\\2" ).downcase
+    end
+  end
+end

data/lib/mind_control/pry_commands/capture_output.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+require "thread"
+
+MindControl::PryCommands.create_command "capture-output" do
+  description "Captures host program STDOUT and STDERR."
+
+  banner <<-BANNER
+    Usage: capture_output [ --no-stdout | --no-stderr ] [ -f, --filter <regexp> ]
+
+    Captures host program STDOUT and STDERR and prints it to user.
+  BANNER
+
+  command_options :shellwords => false
+
+  def options( opt )
+    opt.on :"no-stdout", "Do not capture STDOUT."
+    opt.on :"no-stderr", "Do not capture STDERR."
+    opt.on :f, :filter=, "Filter output with given regular expression."
+  end
+
+  def process
+    raise CommandError, "You can't use --no-stdout simultaneously with --no-stderr" \
+      if opts[ :"no-stdout" ] && opts[ :"no-stderr" ]
+
+    # Line filter
+    filter = opts[ :filter ] ? Regexp.new( opts[ :filter ]) : nil
+
+    line_buffer = Hash.new
+
+    capture_output do |kind, string|
+      # Ignoring user specified outputs
+      next if kind == :stdout && opts[ :"no-stdout" ]
+      next if kind == :stderr && opts[ :"no-stderr" ]
+
+      # Buffering input
+      buffer  = line_buffer[ kind ] ||= ""
+      buffer << string
+
+      # Print buffered lines
+      while eol = buffer.index( "\n" )
+        line = buffer.slice!( 0 .. eol )
+
+        next if filter && line !~ filter
+
+        # Display STDERR in red
+        output.write "\e[31m" if kind == :stderr
+        output.write line
+
+        # We work in raw mode and we need manually move carret to next line
+        output.write "\e[0m\e[E"
+      end
+    end
+  end
+
+  ##
+  # Capture writes to STDOUT/STDERR and yield it.
+  #
+  def capture_output( &block )
+    output_queue = Queue.new
+
+    # Save original write implementation
+    orig_stdout_write = STDOUT.method( :write )
+    orig_stderr_write = STDERR.method( :write )
+
+    #
+    # Hijack #write method and push input string to queue.
+    #
+
+    STDOUT.define_singleton_method :write do |string|
+      orig_stdout_write.call( string ).tap do
+        output_queue << [ :stdout, string ]
+      end
+    end
+
+    STDERR.define_singleton_method :write do |string|
+      orig_stderr_write.call( string ).tap do
+        output_queue << [ :stderr, string ]
+      end
+    end
+
+    # Separate thread to push strings to block in background.
+    capture_thread = Thread.new {
+      loop do
+        block.call( *output_queue.pop )
+      end
+    }
+
+    # Wait for Ctrl+c
+    loop do
+      break if _pry_.input.getch == ?\C-c
+    end
+  ensure
+    capture_thread.kill
+
+    # Restore original write implementation.
+    STDOUT.define_singleton_method :write, orig_stdout_write
+    STDERR.define_singleton_method :write, orig_stderr_write
+  end
+end

data/lib/mind_control/pry_commands.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+module MindControl
+  PryCommands = ::Pry::CommandSet.new
+end
+
+# Load our custom commands
+Dir.glob( File.expand_path( "../pry_commands/**/*.rb", __FILE__ )).each do |file|
+  require file
+end

data/lib/mind_control/pry_monkey_patches.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+require "pry/pager"
+
+::Pry::Pager.instance_eval do
+  alias :vanilla_page :page
+
+  # Redefine standard paging method, so it will always write text to current MindControl
+  # output instead of calling system pager or writing to host program $stdout.
+  def self.page( text, pager = nil )
+    if pry_instance = Pry.current[ :mind_control_pry_instance ]
+      pry_instance.output.puts( text )
+    else
+      vanilla_page( text, pager )
+    end
+  end
+end

data/lib/mind_control/repl.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+require "pry"
+require "coolline"
+require "mind_control/pry_monkey_patches"
+require "mind_control/pry_commands"
+
+module MindControl
+  ##
+  # Pry based REPL.
+  #
+  class REPL
+    ##
+    # @param [Object, Proc] target The receiver of the Pry session.
+    # @param [Hash] options The optional configuration parameters for Pry.
+    #
+    def initialize( target, options = {} )
+      @target  = target
+      @options = options
+    end
+
+    ##
+    # Start REPL session.
+    #
+    # @param [IO] stdin The object to use for input.
+    # @param [IO] stdout The object to use for output.
+    #
+    def start( stdin, stdout )
+      # NB: We cannot use Readline, because it always uses STDOUT / STDIN.
+      input = CoollineAdapter.new( stdin, stdout )
+
+      # Default command set
+      commands = @options[ :commands ] || ::Pry::CommandSet.new.import( ::Pry::Commands )
+
+      # Import our MindControl commands
+      commands.import MindControl::PryCommands
+
+      # Target can be callable
+      target = @target.respond_to?( :call ) ? @target.call : @target
+
+      # NB: input/input can't be changed via pry options!
+      pry = ::Pry.new @options.merge( :commands => commands, :input => input, :output => stdout )
+
+      # Store pry instance in thread-local context so that we can later determine
+      # whether we are running inside MindControl session or not.
+      ::Pry.current[ :mind_control_pry_instance ] = pry
+
+      # Start session
+      pry.repl target
+    end
+
+    ##
+    # Adapter for Coolline for use with Pry.
+    #
+    class CoollineAdapter
+      attr_reader :cool
+
+      ##
+      # @param [IO] stdin The object to use for input.
+      # @param [IO] stdout The object to use for output.
+      #
+      def initialize( input, output )
+        # Setup Coolline
+        @cool = Coolline.new do |cool|
+          cool.input  = input
+          cool.output = output
+          cool.word_boundaries = [ " ", "\t", ",", ";", '"', "'", "`", "<", ">", "=", ";", "|", "{", "}", "(", ")", "-" ]
+
+          # By default Coolline will kill host program on Ctrl+c. Override it.
+          ctrl_c_handler = cool.handlers.find { |handler| handler.char == ?\C-c }
+          ctrl_c_handler.block = lambda { |instance|
+            # Just close Pry
+            instance.instance_variable_set "@should_exit", true
+          }
+        end
+      end
+
+      ##
+      # Read user input with given prompt.
+      #
+      # @param [String] prompt
+      # @return [String]
+      #
+      def readline( prompt )
+        cool.readline prompt
+      end
+
+      ##
+      # Read char from input in raw mode.#
+      #
+      # @return [Fixnum]
+      #
+      def getch
+        cool.input.getch
+      end
+
+      def completion_proc=( proc )
+        cool.completion_proc = proc do
+          proc.call cool.completed_word
+        end
+      end
+    end
+  end
+end

data/lib/mind_control/server.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+require "mind_control/repl"
+require "mind_control/loggable"
+require "socket"
+require "thread"
+require "fileutils"
+require "etc"
+
+module MindControl
+  ##
+  # Listens UNIX socket and starts REPL sessions.
+  #
+  class Server
+    include Loggable
+
+    attr_reader :socket_path
+    attr_reader :repl
+
+    ##
+    # @param [String] socket_path Absolute path of UNIX socket.
+    # @param [#start] repl Instance of REPL (@see MindControl::REPL).
+    #
+    def initialize( socket_path, repl )
+      @socket_path, @repl = socket_path, repl
+    end
+
+    ##
+    # Start server.
+    #
+    def start
+      return if running?
+
+      info "Starting MindControl server on #{socket_path} ..."
+
+      # Storage for client threads
+      client_threads = ThreadGroup.new
+
+      # Start acceptor thread
+      @server_thread = Thread.new do
+        begin
+          start_server_loop( socket_path ) do |client_socket|
+            # Process client in new thread
+            client_threads.add Thread.new {
+              begin
+                handle_client_connection( client_socket, get_client_id( client_socket ))
+              ensure
+                # We MUST close the socket
+                client_socket.close
+              end
+            }
+          end
+        ensure
+          # Kill all client threads on server stop
+          client_threads.list.each( &:kill )
+        end
+      end
+
+      # We should known if our server failed
+      @server_thread.abort_on_exception = true
+    end
+
+    ##
+    # Stop server.
+    #
+    def stop
+      return unless running?
+
+      info "Stopping MindControl server ..."
+
+      # Kill acceptor thread
+      @server_thread.kill
+      @server_thread.join
+      @server_thread = nil
+    end
+
+    ##
+    #  Server is running?
+    #
+    def running?
+      @server_thread && @server_thread.alive?
+    end
+
+    ##
+    # Starts UNIX server, accepts clients and yields its sockets in loop.
+    #
+    # @param [String] socket_path Path to UNIX socket to bind to.
+    # @yeilds [UNIXSocket]
+    #
+    def start_server_loop( socket_path, &block )
+      # Remove old file
+      FileUtils.rm_f socket_path
+      FileUtils.mkdir_p File.dirname( socket_path )
+
+      UNIXServer.open( socket_path ) do |server|
+        loop do
+          # Wait for client
+          block.call server.accept
+        end
+      end
+    ensure
+      # Cleanup
+      FileUtils.rm socket_path
+    end
+
+    ##
+    # Return id string for connected client.
+    #
+    # @param [UNIXSocket] socket Client socket.
+    # @return [String]
+    #
+    def get_client_id( socket )
+      # UNIX socket return effective UID/GID for connected client
+      euid, _ = socket.getpeereid
+
+      # Find record in /etc/passwd
+      user_info = Etc.getpwuid euid
+
+      return "#{user_info.name} (#{user_info.gecos})"
+    end
+
+    ##
+    # Starts REPL session in separate thread for connected client.
+    #
+    # @param [Socket] socket Client socket.
+    # @param [String] client_id ID string for connected client.
+    #
+    def handle_client_connection( socket, client_id )
+      info "Starting new MindControl session for user #{client_id} ..."
+
+      # Client will send us his STDIN and STDOUT
+      client_stdin, client_stdout = socket.recv_io, socket.recv_io
+
+      # Start REPL
+      repl.start client_stdin, client_stdout
+
+      info "MindControl session for user #{client_id} has ended!"
+    rescue Exception => e
+      error_message = "REPL exception: #{e.message} (#{e.class.name})\n#{e.backtrace.join( "\n" )}"
+      error error_message
+
+      # Send error to client
+      client_stdout.puts error_message if client_stdout
+    end
+  end
+end

data/lib/mind_control/version.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+module MindControl
+  VERSION = "0.1.0"
+end

data/lib/mind_control.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+module MindControl
+  autoload :REPL,   "mind_control/repl"
+  autoload :Server, "mind_control/server"
+  autoload :Client, "mind_control/client"
+  autoload :CUI,    "mind_control/cui"
+
+  # Default directory for UNIX socket files.
+  DEFAULT_SOCKETS_DIR = "/tmp/ruby_mind_control"
+
+  # Global logger.
+  class << self; attr_accessor :logger; end
+
+  ##
+  # Start MindControl server.
+  #
+  # @param [Hash] options
+  #   @option options [Object] :target (TOPLEVEL_BINDING)
+  #     REPL target context.
+  #
+  #   @option option [Hash] :pry ({})
+  #     Options for Pry instance.
+  #
+  #   @option options [String] :name ($PROGRAM_NAME)
+  #     Program name.
+  #
+  #   @option options [String] :sockets_dir (DEFAULT_SOCKETS_DIR)
+  #     Directory where control socket will be created.
+  #
+  def self.start( options = {} )
+    raise "MindControl already started!" if @server && @server.running?
+
+    # Name that will be displayed in process list of mind-control client.
+    # The default is process name of the host program (eg. "ruby").
+    process_name = options[ :name ] || $PROGRAM_NAME
+
+    # Some shared temp directory for sockets.
+    socket_dir = options[ :sockets_dir ] || DEFAULT_SOCKETS_DIR
+
+    # Construct unique socket path for current process
+    socket_name = "#{process_name}.#{Process.pid}.sock"
+    socket_path = File.join( socket_dir, socket_name )
+
+    # Construct REPL (NB: same settings for all connections!)
+    repl = MindControl::REPL.new( options[ :target ] || TOPLEVEL_BINDING, options[ :pry ] || {} )
+
+    # Start server
+    @server = MindControl::Server.new( socket_path, repl )
+    @server.start
+
+    return nil
+  end
+
+  ##
+  # Stop MindControl server.
+  #
+  def self.stop
+    return unless @server
+
+    @server.stop
+    @server = nil
+  end
+end

data/mind_control.gemspec

@@ -0,0 +1,29 @@
+# encoding: utf-8
+lib = File.expand_path( "../lib", __FILE__ )
+$LOAD_PATH.unshift( lib ) unless $LOAD_PATH.include? lib
+require "mind_control/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "mind_control"
+  spec.version       = MindControl::VERSION
+  spec.authors       = [ "Denis Diachkov" ]
+  spec.email         = [ "d.diachkov@gmail.com" ]
+  spec.summary       = "Embeddable runtime Pry-based REPL console"
+  spec.homepage      = "https://github.com/ddiachkov/mind_control"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split( $/ )
+  spec.executables   = spec.files.grep( %r{^bin/} ) { |f| File.basename f }
+  spec.test_files    = spec.files.grep( %r{^(test|spec|features)/} )
+  spec.require_paths = [ "lib" ]
+
+  spec.add_dependency "highline", "~> 1.6"
+  spec.add_dependency "pry", "~> 0.9"
+  spec.add_dependency "coolline", "~> 0.4"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "mocha"
+  spec.add_development_dependency "eventmachine"
+end

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification
+name: mind_control
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Denis Diachkov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: coolline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- d.diachkov@gmail.com
+executables:
+- mind_control
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/mind_control
+- lib/mind_control.rb
+- lib/mind_control/client.rb
+- lib/mind_control/cui.rb
+- lib/mind_control/em.rb
+- lib/mind_control/loggable.rb
+- lib/mind_control/pry_commands.rb
+- lib/mind_control/pry_commands/capture_output.rb
+- lib/mind_control/pry_monkey_patches.rb
+- lib/mind_control/repl.rb
+- lib/mind_control/server.rb
+- lib/mind_control/version.rb
+- mind_control.gemspec
+homepage: https://github.com/ddiachkov/mind_control
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Embeddable runtime Pry-based REPL console
+test_files: []