virb 0.0.2

data/.gitignore

@@ -0,0 +1,2 @@
+pkg/
+.virb

data/README.md

@@ -0,0 +1,101 @@
+# Virb
+
+Virb is an interactive Vim mode for IRB, Rails console, and Pry.
+
+## Motivation
+
+The IRB is Ruby's interactive REPL. IRB is a very handy tool, but its
+text-editing capabilities are limited. Virb wraps an IRB session in a Vim
+session and gives you convenient ways to evaluate Ruby code from Vim.
+
+Virb inverts the approach taken by
+the [interactive_editor](https://github.com/jberkel/interactive_editor) gem and
+similar solutions which let you pop out into Vim from IRB and come back to IRB
+to see the results.  Virb keeps you in Vim at all times, calling IRB behind the
+scenes and fetching IBR's output to display inside Vim.
+
+## Install
+
+    gem install virb
+
+Virb requires Ruby 1.9 and Vim 7.2 or above. Virb has been tested only on OS X
+10.8 and Ubuntu Linux.
+
+
+## Using Virb 
+
+Start up Virb with the command
+
+    virb [file]
+
+The optional `file` is a text file that contains Ruby code that you
+would like to run interactively.
+
+Virb opens 2 Vim buffers. The bottom buffer is the interactive buffer, 
+where you can edit Ruby code and then send it to the underlying interactive
+Ruby session for evaluation. The top buffer is the output buffer, where you 
+can see the IRB session you are controlling from the interactive buffer.
+
+To evaluate code in the interactive buffer:
+
+To evaluate a line of code, put the cursor on it, and press ENTER in normal mode.
+
+To evaluate several lines of code, you can either
+
+1. select the lines in Vim's visual mode, and press ENTER to evaluate them;
+2. use an ed-style range command: `:[range]Virb`
+
+If IRB takes too long (more than about half a second) to evaluate your code,
+you may need to manually force the session buffer to update itself. You can
+force an update by pressing SPACE in normal mode.
+
+
+## Using Virb with Pry
+
+Make sure you have the `pry` gem installed. Then you can run this:
+
+    virb-pry [file]
+
+When virb opens, you should be able to send your code for evaluation to Pry and
+get Pry output in the virb session buffer.
+
+## How to wrap Rails console with Virb 
+
+If you want to use Virb with the standard Rails console:
+
+Put this in your Gemfile:
+
+    group :development do
+      gem 'virb'
+    end
+
+and start Rails console as you do normally. You should see the Virb interface
+open, where you can interact with the Ralis console through a Vim buffer and
+see its output in the other Vim buffer.
+
+If you want to use Virb with Pry and Rails console:
+
+Put this in your Gemfile:
+
+    group :development do
+      gem 'pry'
+      gem 'virb'
+    end
+
+and start Rails console like this:
+
+    VIRB=pry rails c
+
+
+## Caveats
+
+The normal command line options for `irb` and `pry` do not work with `virb`.
+
+
+## Author
+
+Virb was written by [Daniel Choi](http://danielchoi.com/software), an independent software developer based in Cambridge, Massachusetts.
+
+* [GitHub](http://github.com/danchoi)
+* [Twitter](http://twitter.com/danchoi)
+* I am available for short to medium-term consulting projects: [Email](mailto:dhchoi@gmail.com)

data/Rakefile

@@ -0,0 +1,34 @@
+require 'rake'
+require 'rake/testtask'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+desc "release and build and push new website"
+task :push => [:release, :web]
+
+desc "build and push website"
+task :web => :build_webpage do
+  puts "Building and pushing website"
+  Dir.chdir "../project-webpages" do
+    `scp out/virb.html zoe2@instantwatcher.com:~/danielchoi.com/public/software/`
+    `rsync -avz out/images-virb zoe2@instantwatcher.com:~/danielchoi.com/public/software/`
+    `rsync -avz out/stylesheets zoe2@instantwatcher.com:~/danielchoi.com/public/software/`
+    `rsync -avz out/lightbox2 zoe2@instantwatcher.com:~/danielchoi.com/public/software/`
+  end
+  `open http://danielchoi.com/software/virb.html`
+end
+
+desc "build webpage"
+task :build_webpage do
+  `cp README.md ../project-webpages/src/virb.README.markdown`
+  require "./lib/virb/version"
+  version = Virb::VERSION
+  puts "Version detected: #{version}"
+  Dir.chdir "../project-webpages" do
+    puts `ruby gen.rb virb #{version}`
+    `open out/virb.html`
+  end
+end
+
+task :default => :test
+

data/bin/virb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+if %w{ -h --help --version -v }.include?(ARGV[0])
+  require 'virb/version'
+  puts <<END
+virb #{Virb::VERSION}
+
+For instructions, please visit http://github.com/danchoi/virb
+Author: Daniel Choi 
+License: MIT
+END
+  exit
+end
+require 'virb/default' 
+IRB.start

data/bin/virb-pry

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+if %w{ -h --help --version -v }.include?(ARGV[0])
+  require 'virb/version'
+  puts <<END
+virb #{Virb::VERSION}
+
+For instructions, please visit http://github.com/danchoi/virb
+Author: Daniel Choi 
+License: MIT
+END
+  exit
+end
+require 'virb/pry' 
+Virb::Pry.start

data/lib/virb/default.rb

@@ -0,0 +1,459 @@
+#
+#   irb.rb - irb main module
+#       $Release Version: 0.9.6 $
+#       $Revision: 31641 $
+#       by Keiju ISHITSUKA(keiju@ruby-lang.org)
+#
+#   Modified for virb by Daniel Choi dhchoi@gmail.com
+# --
+#
+#
+#
+require "e2mmap"
+
+require 'stringio' 
+
+require "irb/init"
+require "irb/context"
+require "irb/extend-command"
+#require "irb/workspace"
+
+require "irb/ruby-lex"
+require "irb/input-method"
+require "irb/locale"
+
+`rm -rf .virb`
+`mkdir -p .virb`
+unless File.exist?('.virb/fifo')
+  `mkfifo .virb/fifo`
+end
+`touch .virb/session`
+
+STDOUT.sync = true
+
+$outfile = '.virb/session'
+STDERR.reopen "/dev/null" # this prevent logging to cursor location in rails c
+$infifo = '.virb/fifo'
+
+module IRB
+  class StdioInputMethod < InputMethod
+    def initialize
+      super
+      @line_no = 0
+      @line = []
+      @stdin = IO.open(STDIN.to_i, :external_encoding => IRB.conf[:LC_MESSAGES].encoding, :internal_encoding => "-")
+      @stdout = IO.open(STDOUT.to_i, 'w', :external_encoding => IRB.conf[:LC_MESSAGES].encoding, :internal_encoding => "-")
+    end
+
+    def gets
+      print @prompt
+      line = @stdin.gets
+      print line  # this is added by dan choi to ensure echoing of executed code in session window
+      @line[@line_no += 1] = line
+    end
+
+    def eof?
+      @stdin.eof?
+    end
+
+    def readable_atfer_eof?
+      true
+    end
+
+    def line(line_no)
+      @line[line_no]
+    end
+
+    def encoding
+      @stdin.external_encoding
+    end
+  end
+end
+
+module IRB
+
+  class Abort < Exception;end
+
+  #
+  @CONF = {}
+
+  def IRB.conf
+    @CONF
+  end
+
+  # IRB version method
+  def IRB.version
+    if v = @CONF[:VERSION] then return v end
+
+    require "irb/version"
+    rv = @RELEASE_VERSION.sub(/\.0/, "")
+    @CONF[:VERSION] = format("irb %s(%s)", rv, @LAST_UPDATE_DATE)
+  end
+
+  def IRB.CurrentContext
+    IRB.conf[:MAIN_CONTEXT]
+  end
+
+  # initialize IRB and start TOP_LEVEL irb
+  def IRB.start(ap_path = nil)
+
+    vimscript = File.join(File.dirname(__FILE__), '..', 'virb.vim')
+
+    # strip args so IRB doesn't think it's loading a file
+    args = ARGV.dup
+    while ARGV.shift
+      # pass
+    end
+
+
+    fork do
+      original_start ap_path
+    end
+
+    exec("vim -S #{vimscript} #{args.join(' ')} && rm -rf .virb && kill 0")
+  end
+
+  def IRB.original_start(ap_path = nil)
+    $0 = File::basename(ap_path, ".rb") if ap_path
+
+    IRB.setup(ap_path)
+
+    if @CONF[:SCRIPT]
+      irb = Irb.new(nil, @CONF[:SCRIPT])
+    else
+      irb = Irb.new
+    end
+
+    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
+    @CONF[:MAIN_CONTEXT] = irb.context
+
+    trap("SIGINT") do
+      irb.signal_handle
+    end
+
+    begin
+      catch(:IRB_EXIT) do
+        irb.eval_input
+      end
+    ensure
+      irb_at_exit
+    end
+#    print "\n"
+
+
+  end
+
+  def IRB.irb_at_exit
+    @CONF[:AT_EXIT].each{|hook| hook.call}
+  end
+
+  def IRB.irb_exit(irb, ret)
+    throw :IRB_EXIT, ret
+  end
+
+  def IRB.irb_abort(irb, exception = Abort)
+    if defined? Thread
+      irb.context.thread.raise exception, "abort then interrupt!"
+    else
+      raise exception, "abort then interrupt!"
+    end
+  end
+
+  #
+  # irb interpreter main routine
+  #
+  class Irb
+    def initialize(workspace = nil, input_method = StdioInputMethod.new , output_method = nil)
+
+      # input_method is hard to override
+
+      @context = Context.new(self, workspace, input_method, output_method)
+      @context.main.extend ExtendCommandBundle
+      @signal_status = :IN_IRB
+
+      @scanner = RubyLex.new
+      @scanner.exception_on_syntax_error = false
+      
+      @outfile = File.open($outfile, 'w')
+      $stderr = @outfile
+      $stdout = @outfile
+    end
+    attr_reader :context
+    attr_accessor :scanner
+
+    def eval_input
+      @scanner.set_prompt do
+        |ltype, indent, continue, line_no|
+        if ltype
+          f = @context.prompt_s
+        elsif continue
+          f = @context.prompt_c
+        elsif indent > 0
+          f = @context.prompt_n
+        else
+          f = @context.prompt_i
+        end
+        f = "" unless f
+        if @context.prompting?
+          @context.io.prompt = p = prompt(f, ltype, indent, line_no)
+        else
+          @context.io.prompt = p = ""
+        end
+        if @context.auto_indent_mode
+          unless ltype
+            ind = prompt(@context.prompt_i, ltype, indent, line_no)[/.*\z/].size +
+              indent * 2 - p.size
+            ind += 2 if continue
+            @context.io.prompt = p + " " * ind if ind > 0
+          end
+        end
+      end
+
+      # puts @context.io.inspect
+      fd = IO.sysopen($infifo)
+      @newio = IO.new(fd)
+      @context.io.instance_variable_set(:@stdin, @newio)
+      #@context.io.instance_variable_set(:@stdout, @outfile)
+
+      @scanner.set_input(@context.io) do
+        signal_status(:IN_INPUT) do
+
+          if @newio.nil? || @newio.eof?
+            fd = IO.sysopen($infifo)
+            @newio = IO.new(fd)
+            @context.io.instance_variable_set(:@stdin, @newio)
+          end
+
+          if l = @context.io.gets
+            print l if @context.verbose?
+          else
+            if @context.ignore_eof? and @context.io.readable_after_eof?
+              l = "\n"
+              if @context.verbose?
+                printf "Use \"exit\" to leave %s\n", @context.ap_name
+              end
+            else
+              print "\n"
+            end
+          end
+          l
+        end
+      end
+
+      @scanner.each_top_level_statement do |line, line_no|
+        signal_status(:IN_EVAL) do
+          begin
+            line.untaint
+
+            # This is to handle puts etc which print to stdout instead
+            # of returning a value
+            stringio = StringIO.new
+            $stdout = stringio
+            @context.evaluate(line, line_no)
+            $stdout = @outfile
+
+            stringio.rewind
+            print stringio.read
+            output_value if @context.echo?
+
+            exc = nil
+          rescue Interrupt => exc
+          rescue SystemExit, SignalException
+            raise
+          rescue Exception => exc
+          end
+          if exc
+            print exc.class, ": ", exc, "\n"
+            if exc.backtrace[0] =~ /irb(2)?(\/.*|-.*|\.rb)?:/ && exc.class.to_s !~ /^IRB/ &&
+                !(SyntaxError === exc)
+              irb_bug = true
+            else
+              irb_bug = false
+            end
+
+            messages = []
+            lasts = []
+            levels = 0
+            for m in exc.backtrace
+              m = @context.workspace.filter_backtrace(m) unless irb_bug
+              if m
+                if messages.size < @context.back_trace_limit
+                  messages.push "\tfrom "+m
+                else
+                  lasts.push "\tfrom "+m
+                  if lasts.size > @context.back_trace_limit
+                    lasts.shift
+                    levels += 1
+                  end
+                end
+              end
+            end
+            print messages.join("\n"), "\n"
+            unless lasts.empty?
+              printf "... %d levels...\n", levels if levels > 0
+              print lasts.join("\n")
+            end
+            print "Maybe IRB bug!\n" if irb_bug
+          end
+          if $SAFE > 2
+            abort "Error: irb does not work for $SAFE level higher than 2"
+          end
+        end
+      end
+    end
+
+    # DANCHOI
+    def print *s
+      @outfile.print *s
+      @outfile.flush
+    end
+
+    def suspend_name(path = nil, name = nil)
+      @context.irb_path, back_path = path, @context.irb_path if path
+      @context.irb_name, back_name = name, @context.irb_name if name
+      begin
+        yield back_path, back_name
+      ensure
+        @context.irb_path = back_path if path
+        @context.irb_name = back_name if name
+      end
+    end
+
+    def suspend_workspace(workspace)
+      @context.workspace, back_workspace = workspace, @context.workspace
+      begin
+        yield back_workspace
+      ensure
+        @context.workspace = back_workspace
+      end
+    end
+
+    def suspend_input_method(input_method)
+      back_io = @context.io
+      @context.instance_eval{@io = input_method}
+      begin
+        yield back_io
+      ensure
+        @context.instance_eval{@io = back_io}
+      end
+    end
+
+    def suspend_context(context)
+      @context, back_context = context, @context
+      begin
+        yield back_context
+      ensure
+        @context = back_context
+      end
+    end
+
+    def signal_handle
+      unless @context.ignore_sigint?
+        print "\nabort!\n" if @context.verbose?
+        exit
+      end
+
+      case @signal_status
+      when :IN_INPUT
+        print "^C\n"
+        raise RubyLex::TerminateLineInput
+      when :IN_EVAL
+        IRB.irb_abort(self)
+      when :IN_LOAD
+        IRB.irb_abort(self, LoadAbort)
+      when :IN_IRB
+        # ignore
+      else
+        # ignore other cases as well
+      end
+    end
+
+    def signal_status(status)
+      return yield if @signal_status == :IN_LOAD
+
+      signal_status_back = @signal_status
+      @signal_status = status
+      begin
+        yield
+      ensure
+        @signal_status = signal_status_back
+      end
+    end
+
+    def prompt(prompt, ltype, indent, line_no)
+      p = prompt.dup
+      p.gsub!(/%([0-9]+)?([a-zA-Z])/) do
+        case $2
+        when "N"
+          @context.irb_name
+        when "m"
+          @context.main.to_s
+        when "M"
+          @context.main.inspect
+        when "l"
+          ltype
+        when "i"
+          if $1
+            format("%" + $1 + "d", indent)
+          else
+            indent.to_s
+          end
+        when "n"
+          if $1
+            format("%" + $1 + "d", line_no)
+          else
+            line_no.to_s
+          end
+        when "%"
+          "%"
+        end
+      end
+      p
+    end
+
+    def output_value
+      # printf @context.return_format, @context.inspect_last_value
+      r = sprintf @context.return_format, @context.inspect_last_value
+      print r
+    end
+
+    def inspect
+      ary = []
+      for iv in instance_variables
+        case (iv = iv.to_s)
+        when "@signal_status"
+          ary.push format("%s=:%s", iv, @signal_status.id2name)
+        when "@context"
+          ary.push format("%s=%s", iv, eval(iv).__to_s__)
+        else
+          ary.push format("%s=%s", iv, eval(iv))
+        end
+      end
+      format("#<%s: %s>", self.class, ary.join(", "))
+    end
+  end
+
+  # Singleton method
+  def @CONF.inspect
+    IRB.version unless self[:VERSION]
+
+    array = []
+    for k, v in sort{|a1, a2| a1[0].id2name <=> a2[0].id2name}
+      case k
+      when :MAIN_CONTEXT, :__TMP__EHV__
+        array.push format("CONF[:%s]=...myself...", k.id2name)
+      when :PROMPT
+        s = v.collect{
+          |kk, vv|
+          ss = vv.collect{|kkk, vvv| ":#{kkk.id2name}=>#{vvv.inspect}"}
+          format(":%s=>{%s}", kk.id2name, ss.join(", "))
+        }
+        array.push format("CONF[:%s]={%s}", k.id2name, s.join(", "))
+      else
+        array.push format("CONF[:%s]=%s", k.id2name, v.inspect)
+      end
+    end
+    array.join("\n")
+  end
+end
+

data/lib/virb/pry.rb

@@ -0,0 +1,81 @@
+`rm -rf .virb`
+`mkdir -p .virb`
+unless File.exist?('.virb/fifo')
+  `mkfifo .virb/fifo`
+end
+`touch .virb/session`
+
+module Virb
+  class Pry
+    class Fifo
+      def initialize
+        reinit_fifo
+      end
+      def reinit_fifo
+        fd = IO.sysopen(".virb/fifo")
+        @io = IO.new(fd, 'r')
+      end
+      def readline(current_prompt)
+        $stdout.print current_prompt
+        if @io.eof?
+          reinit_fifo
+        end
+        x = @io.gets
+        $stdout.print x
+        x
+      end
+      def rewind
+      end
+    end
+
+    # fakes a tty stdout
+    class Output
+      def initialize
+        @out = File.open(".virb/session", "w")
+        @out.sync = true
+      end
+      def print s
+        @out.print s
+      end
+      def puts s
+        @out.puts s
+      end
+      def write s
+        @out.write s
+      end
+      def flush
+        @out.flush
+      end
+      def tty?
+        true
+      end
+    end
+
+    def self.start
+      pgid = Process.getpgid(Process.pid())
+
+      pid = fork do
+        ENV['TERM'] = 'dumb'
+        require 'pry'
+
+        out = Virb::Pry::Output.new
+        $stdout = out
+        $stderr = out
+
+        ::Pry.cli = true
+        ::Pry.color = false
+        ::Pry.config.pager = false
+        ::Pry.config.print = ::Pry::SIMPLE_PRINT
+        ::Pry.config.auto_indent = false # turns off ansi control escape sequences
+        input = Fifo.new
+        ::Pry.input = input
+        ::Pry.config.output = out
+        ::Pry.start(TOPLEVEL_BINDING.eval('self'))
+      end
+
+      args = ARGV.dup
+      vimscript = File.join(File.dirname(__FILE__), '..', 'virb.vim')
+      exec("vim -S #{vimscript} #{args.join(' ')} && rm -rf .virb && kill 0")
+    end
+  end
+end

data/lib/virb/pry_commands.rb

@@ -0,0 +1,205 @@
+module PryRails
+  Commands = Pry::CommandSet.new do
+    create_command "show-routes", "Print out all defined routes in match order, with names." do
+      group "Rails"
+
+      def options(opt)
+        opt.banner unindent <<-USAGE
+          Usage: show-routes [-G]
+
+          show-routes displays the current Rails app's routes.
+        USAGE
+
+        opt.on :G, "grep", "Filter output by regular expression", :argument => true
+      end
+
+      def process
+        Rails.application.reload_routes!
+        all_routes = Rails.application.routes.routes
+
+        all_routes = begin
+          begin
+            # rails 4
+            require 'action_dispatch/routing/inspector'
+            inspector = ActionDispatch::Routing::RoutesInspector.new
+          rescue LoadError => e
+            # rails 3.2
+            require 'rails/application/route_inspector'
+            inspector = Rails::Application::RouteInspector.new
+          end
+          inspector.format(all_routes)
+        rescue LoadError => e
+          # rails 3.0 and 3.1. cribbed from
+          # https://github.com/rails/rails/blob/3-1-stable/railties/lib/rails/tasks/routes.rake
+          routes = all_routes.collect do |route|
+
+            reqs = route.requirements.dup
+            reqs[:to] = route.app unless route.app.class.name.to_s =~ /^ActionDispatch::Routing/
+              reqs = reqs.empty? ? "" : reqs.inspect
+
+            {:name => route.name.to_s, :verb => route.verb.to_s, :path => route.path, :reqs => reqs}
+          end
+
+          # Skip the route if it's internal info route
+          routes.reject! { |r| r[:path] =~ %r{/rails/info/properties|^/assets} }
+
+          name_width = routes.map{ |r| r[:name].length }.max
+          verb_width = routes.map{ |r| r[:verb].length }.max
+          path_width = routes.map{ |r| r[:path].length }.max
+
+          routes.map do |r|
+            "#{r[:name].rjust(name_width)} #{r[:verb].ljust(verb_width)} #{r[:path].ljust(path_width)} #{r[:reqs]}"
+          end
+        end
+
+        output.puts all_routes.grep(Regexp.new(opts[:G] || ".")).join "\n"
+      end
+    end
+
+    create_command "show-models", "Print out all defined models, with attribrutes." do
+      group "Rails"
+
+      def options(opt)
+        opt.banner unindent <<-USAGE
+          Usage: show-models
+
+          show-models displays the current Rails app's models.
+        USAGE
+
+        opt.on :G, "grep", "Color output red by regular expression", :argument => true
+      end
+
+      def process
+        Rails.application.eager_load!
+
+        if defined?(ActiveRecord::Base)
+          models = ActiveRecord::Base.descendants.map do |mod|
+            model_string = mod.to_s + "\n"
+            if mod.table_exists?
+              model_string << mod.columns.map { |col| "  #{col.name}: #{col.type.to_s}" }.join("\n")
+            else
+              model_string << "  Table doesn't exist"
+            end
+            mod.reflections.each do |model,ref|
+              model_string << "\n  #{ref.macro.to_s} #{model}"
+              model_string << " through #{ref.options[:through]}" unless ref.options[:through].nil?
+            end
+            model_string
+          end.join("\n")
+        elsif defined?(Mongoid::Document)
+          models = get_files.map do |path|
+            mod = extract_class_name(path)
+            model_string = "\033[1;34m#{mod.to_s}\033[0m\n"
+            begin
+              if mod.constantize.included_modules.include?(Mongoid::Document)
+                model_string << mod.constantize.fields.values.sort_by(&:name).map { |col|
+                  "  #{col.name}: \033[1;33m#{col.options[:type].to_s.downcase}\033[0m"
+                }.join("\n")
+                mod.constantize.relations.each do |model,ref|
+                  model_string << "\n  #{kind_of_relation(ref.relation.to_s)} \033[1;34m#{model}\033[0m"
+                  model_string << ", autosave" if ref.options[:autosave]
+                  model_string << ", autobuild" if ref.options[:autobuild]
+                  model_string << ", validate" if ref.options[:validate]
+                  model_string << ", dependent-#{ref.options[:dependent]}" if ref.options[:dependent]
+                end
+              else
+                model_string << "  Collection doesn't exist"
+              end
+              model_string
+
+            rescue Exception
+              STDERR.puts "Warning: exception #{$!} raised while trying to load model class #{path}"
+            end
+          end.join("\n")
+        end
+
+        models.gsub!(Regexp.new(opts[:G] || ".", Regexp::IGNORECASE)) { |s| text.red(s) } unless opts[:G].nil?
+        output.puts models
+      end
+
+      def get_files(prefix ='')
+        Dir.glob(prefix << "app/models/**/*.rb")
+      end
+
+      def extract_class_name(filename)
+        filename.split('/')[2..-1].collect { |i| i.camelize }.join('::').chomp(".rb")
+      end
+
+      def kind_of_relation(string)
+        case string.gsub('Mongoid::Relations::', '')
+        when 'Referenced::Many' then 'has_many'
+        when 'Referenced::One' then 'has_one'
+        when 'Referenced::In' then 'belongs_to'
+        when 'Embedded::Many' then 'embeds_many'
+        when 'Embedded::One' then 'embeds_one'
+        when 'Embedded::In' then 'embedded_in'
+        end
+      end
+    end
+
+    create_command "show-middleware" do
+      group "Rails"
+
+      def options(opt)
+        opt.banner unindent <<-USAGE
+          Usage: show-middleware [-G]
+
+          show-middleware shows the Rails app's middleware.
+
+          If this pry REPL is attached to a Rails server, the entire middleware
+          stack is displayed.  Otherwise, only the middleware Rails knows about is
+          printed.
+        USAGE
+
+        opt.on :G, "grep", "Filter output by regular expression", :argument => true
+      end
+
+      def process
+        # assumes there is only one Rack::Server instance
+        server = nil
+        ObjectSpace.each_object(Rack::Server) do |object|
+          server = object
+        end
+
+        middlewares = []
+
+        if server
+          stack = server.instance_variable_get("@wrapped_app")
+          middlewares << stack.class.to_s
+
+          while stack.instance_variable_defined?("@app") do
+            stack = stack.instance_variable_get("@app")
+            # Rails 3.0 uses the Application class rather than the application
+            # instance itself, so we grab the instance.
+            stack = Rails.application  if stack == Rails.application.class
+            middlewares << stack.class.to_s  if stack != Rails.application
+          end
+        else
+          middleware_names = Rails.application.middleware.map do |middleware|
+            # After Rails 3.0, the middleware are wrapped in a special class
+            # that responds to #name.
+            if middleware.respond_to?(:name)
+              middleware.name
+            else
+              middleware.inspect
+            end
+          end
+          middlewares.concat middleware_names
+        end
+        middlewares << Rails.application.class.to_s
+        print_middleware middlewares.grep(Regexp.new(opts[:G] || "."))
+      end
+
+      def print_middleware(middlewares)
+        middlewares.each do |middleware|
+          string = if middleware == Rails.application.class.to_s
+            "run #{middleware}.routes"
+          else
+            "use #{middleware}"
+          end
+          output.puts string
+        end
+      end
+    end
+  end
+end

data/lib/virb/railtie.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+module Virb
+  class Railtie < Rails::Railtie
+    if ENV['VIRB'] == 'pry'
+      require 'pry'
+      require 'virb/pry'
+      console do
+        if Rails::VERSION::MAJOR == 3
+          Rails::Console::IRB = Virb::Pry
+          unless defined? Virb::Pry::ExtendCommandBundle
+            Virb::Pry::ExtendCommandBundle = Module.new
+          end
+        end  
+        if Rails::VERSION::MAJOR == 4
+          Rails.application.config.console = Virb::Pry
+        end  
+
+        if (Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR >= 2) || Rails::VERSION::MAJOR == 4
+          require 'rails/console/app'
+          require 'rails/console/helpers'
+          TOPLEVEL_BINDING.eval('self').extend ::Rails::ConsoleMethods
+        end
+      end
+      require "virb/pry_commands"
+      ::Pry.commands.import PryRails::Commands
+
+      # do this to prevent the sql output from going to vim interactive buffer
+      STDERR.reopen("/dev/null")
+
+    else
+      require 'virb/default'
+      console do
+        if Rails::VERSION::MAJOR == 3
+          Rails::Console::IRB = IRB
+        end  
+        if Rails::VERSION::MAJOR == 4
+          Rails.application.config.console = IRB
+        end  
+
+        if (Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR >= 2) || Rails::VERSION::MAJOR == 4
+          require 'rails/console/app'
+          require 'rails/console/helpers'
+          TOPLEVEL_BINDING.eval('self').extend ::Rails::ConsoleMethods
+        end
+      end
+    end
+  end
+end

data/lib/virb/version.rb

@@ -0,0 +1,3 @@
+module Virb
+  VERSION = '0.0.2'
+end

data/lib/virb.rb

@@ -0,0 +1,6 @@
+
+
+if defined?(Rails)
+  require 'virb/railtie'
+end
+

data/lib/virb.vim

@@ -0,0 +1,84 @@
+"=================================================
+" File: virb.vim
+" Description: A Vim shell for irb and rails console
+" Author: Daniel Choi <dhchoi@gmail.com>
+" ================================================
+
+if exists("g:loaded_virb") || &cp
+    finish
+endif
+let g:loaded_virb = 1
+
+let s:fifo = ".virb/fifo"
+
+" split into two windows: a session buffer and a interactive buffer
+
+function! s:focus_virb_output_window()
+  if bufwinnr(s:virb_output_bufnr) == winnr()
+    return
+  end
+  let winnr = bufwinnr(s:virb_output_bufnr)
+  if winnr == -1
+    " create window
+    split! .virb/session
+    exec "buffer" . s:virb_output_bufnr
+  else
+    exec winnr . "wincmd w"
+  endif
+endfunc
+
+function! VirbStatusLine()
+  let line =  "%<*virb interactive buffer*   %r%=%-14.(%l,%c%V%)\ %P"
+  return line
+endfunc
+
+split! .virb/session
+setlocal autoread
+let s:virb_output_bufnr = bufnr('%')
+setlocal nomodifiable
+setlocal nu
+
+" in interactive buffer
+wincmd p
+setlocal nu
+setlocal statusline=%!VirbStatusLine()
+command! -bar -range Virb :<line1>,<line2>call Virb()
+
+" main execution function
+func! Virb() range
+  let s:mtime = getftime(".virb/session")
+  let cmd = ":".a:firstline.",".a:lastline."w >> .virb/fifo"
+  exec cmd
+  if $VIRB == 'pry'
+    " a little slower
+    :sleep 600m
+  else
+    :sleep 400m
+  endif
+  :call VirbRefresh()
+endfunc
+
+func! VirbRefresh()
+  :call s:focus_virb_output_window()
+  ":exec ":checktime ".s:virb_output_bufnr
+  :e!
+  :normal G
+  syn match irbprompt /^irb\S\+\(>\|\*\).*$/ 
+  " [2] pry(main)>
+  syn match irbprompt /^\[\d\+\] pry.*$/ 
+  hi def link irbprompt         Comment
+  :wincmd p
+endfunc
+
+if !hasmapto('<Plug>VirbRun')
+  " this is global
+  nnoremap <cr> :call Virb()<cr>
+  vnoremap <cr> :call Virb()<cr>
+endif
+
+if !hasmapto('<Plug>VirbRefresh')
+  " this is global
+  nnoremap <space> :checkt<CR>
+endif
+
+

data/notes

@@ -0,0 +1,42 @@
+todo
+- Virb command
+
+
+Pry
+
+
+See pry.rb for start of Pry integration
+
+
+def redirect_pry_io(new_in, new_out = StringIO.new)
+  old_in = Pry.input
+  old_out = Pry.output
+
+  Pry.input = new_in
+  Pry.output = new_out
+  begin
+    yield
+  ensure
+    Pry.input = old_in
+    Pry.output = old_out
+  end
+end
+
+InputTester.new("exit-all")
+
+
+
+class InputTester
+  def initialize(*actions)
+    @orig_actions = actions.dup
+    @actions = actions
+  end
+
+  def readline(*)
+    @actions.shift
+  end
+
+  def rewind
+    @actions = @orig_actions.dup
+  end
+end

data/virb.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+$:.push File.expand_path("../lib", __FILE__)
+require 'virb/version'
+Gem::Specification.new do |s|
+  s.name        = "virb"
+  s.version     = Virb::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.required_ruby_version = '>= 1.9.0'
+
+  s.authors     = ["Daniel Choi"]
+  s.email       = ["dhchoi@gmail.com"]
+  s.homepage    = "http://danielchoi.com/software/virb.html"
+  s.summary     = %q{A Vim shell for irb and rails console}
+  s.description = %q{A Vim shell for irb and rails console}
+
+  s.rubyforge_project = "virb"
+
+  s.files  = `git ls-files`.split("\n")
+  s.executables   = ['virb', 'virb-pry']
+  # s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: virb
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Daniel Choi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-24 00:00:00.000000000 Z
+dependencies: []
+description: A Vim shell for irb and rails console
+email:
+- dhchoi@gmail.com
+executables:
+- virb
+- virb-pry
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- README.md
+- Rakefile
+- bin/virb
+- bin/virb-pry
+- images/virb1.png
+- images/virb2.png
+- images/virb3.png
+- lib/virb.rb
+- lib/virb.vim
+- lib/virb/default.rb
+- lib/virb/pry.rb
+- lib/virb/pry_commands.rb
+- lib/virb/railtie.rb
+- lib/virb/version.rb
+- notes
+- virb.gemspec
+homepage: http://danielchoi.com/software/virb.html
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: virb
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A Vim shell for irb and rails console
+test_files: []