rubylet 0.1.0-java

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Common Ground Publishing
+
+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/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/rubylet.rb

@@ -0,0 +1,2 @@
+require 'rubylet/servlet'
+require 'rubylet/environment'

data/lib/rubylet/environment.rb

@@ -0,0 +1,138 @@
+require 'monitor'
+
+require 'rubylet/errors'
+require 'rubylet/logger'
+require 'rubylet/session'
+
+class Rubylet::Environment < Hash
+  include MonitorMixin
+  
+  def initialize(req, servlet)
+    super()  # required to initialize MonitorMixin
+    
+    if req.respond_to?(:isAsyncSupported) && req.isAsyncSupported
+      @async_callback_condition = new_cond
+      @async_callback = nil
+      self['async.callback'] = method(:forward_to_async_callback)
+    end
+
+    load_headers(req)
+    load(req, servlet)
+  end
+  
+  def normalize(raw)
+    if raw =~ /^Content-(Type|Length)$/i
+      raw
+    else
+      'HTTP_' + raw
+    end.upcase.gsub(/-/, '_')
+  end
+  private :normalize
+
+  # Copied from JRuby-Rack rack/handler/servlet.rb
+  def load_headers(req)
+    req.getHeaderNames.each do |h|
+      self[normalize(h)] = req.getHeader(h)
+    end
+  end
+  private :load_headers
+
+  # Strip a lone slash and also reduce duplicate '/' to a single
+  # slash.
+  def clean_slashes(str)
+    no_dups = str.gsub(%r{/+}, '/')
+    no_dups == '/' ? '' : no_dups
+  end
+  private :clean_slashes
+  
+  # Register an async callback.  This block will be called
+  # when a Rack application calls the 'async.callback' proc.
+  #
+  # Calls to 'async.callback' will block until another
+  # thread registers a handler by calling this method.
+  def on_async_callback(&block)
+    synchronize do
+      @async_callback = block
+      @async_callback_condition.broadcast
+    end
+  end
+
+  def forward_to_async_callback(resp)
+    synchronize do
+      # wait until someone sets @async_callback
+      @async_callback_condition.wait_until { @async_callback }
+      # pass resp on to the callback
+      @async_callback.call(resp)
+    end
+  end
+  private :forward_to_async_callback
+
+  # Load the Rack environment from a servlet request and context.
+  #
+  # @param [javax.servlet.http.HttpServletRequest] req
+  # @param [javax.servlet.ServletContext context
+  def load(req, servlet)
+    context = servlet.context
+
+    self['REQUEST_METHOD'] = req.getMethod
+
+    # context path joined with servlet_path, but not nil and empty
+    # string rather than '/'
+    self['SCRIPT_NAME'] =
+      begin
+        context_path = req.context_path || '/'
+        servlet_path = req.servlet_path || ''
+        clean_slashes(context_path + servlet_path)
+      end
+
+    self['PATH_INFO']         = clean_slashes(req.path_info || '')
+    self['QUERY_STRING']      = req.getQueryString || ''
+    self['SERVER_NAME']       = req.getServerName
+    self['SERVER_PORT']       = req.getServerPort.to_s
+
+    self['rack.version']      = ::Rack::VERSION
+    self['rack.url_scheme']   = req.getScheme
+
+    # TODO: this is not rewindable in violation of the Rack
+    # spec.  Requiring rewind ability on every request seems
+    # a bit much, particularly since it would be trivial to
+    # wrap the io in a helper buffer as-needed, but should
+    # probably implement this eventually.
+    #
+    # @see http://rack.rubyforge.org/doc/SPEC.html
+    self['rack.input']        = req.getInputStream.to_io
+
+    self['rack.errors']       = Rubylet::Errors.new(context)
+    self['rack.multithread']  = true
+    self['rack.multiprocess'] = false
+    self['rack.run_once']     = false
+
+    if servlet.param('useSessions')
+      self['rack.session']      = Rubylet::Session.new(req)
+    end
+
+    if servlet.param('userLogger')
+      self['rack.logger']       = Rubylet::Logger.new(context)
+    end
+      
+    self['REMOTE_ADDR']       = req.getRemoteAddr
+    self['REMOTE_HOST']       = req.getRemoteHost
+    self['REMOTE_USER']       = req.getRemoteUser
+    self['REMOTE_PORT']       = req.getRemotePort.to_s
+    self['REQUEST_PATH']      = req.getPathInfo
+    # note, ruby side is URI, java side is URL
+    self['REQUEST_URI'] =
+      begin
+        q = req.getQueryString
+        req.getRequestURL.to_s + (q ? ('?' + q) : '')
+      end
+      
+    self['SERVER_PROTOCOL']   = req.getProtocol
+    self['SERVER_SOFTWARE']   = context.getServerInfo
+
+    self['java.context_path'] = req.getContextPath
+    self['java.path_info']    = req.getPathInfo
+    self['java.servlet_path'] = req.getServletPath
+  end
+  private :load
+end

data/lib/rubylet/errors.rb

@@ -0,0 +1,23 @@
+# Implements the rack.errors interface, logging everything via
+# ServletContext#log
+module Rubylet
+  class Errors
+    def initialize(context)
+      @context = context
+    end
+
+    def puts(obj)
+      write(obj.to_s)
+    end
+
+    def write(str)
+      @context.log(str)
+    end
+
+    # A no-op for ServletContext#log
+    def flush; end
+
+    # Spec says this must never be called
+    def close; end
+  end
+end

data/lib/rubylet/input.rb

@@ -0,0 +1,31 @@
+require 'java'
+require 'forwardable'
+
+# Wraps servlet InputStream with a buffer to support Rack required #rewind.
+class Rubylet::Input
+  extend Forwardable
+  
+  MAX_BUFFER = 500 * 1024  # 500 kiB
+  
+  def_delegators :@io, :gets, :read, :each, :close
+  
+  def initialize(req)
+    @stream = java.io.BufferedInputStream.new(req.getInputStream,
+                                              req.getContentLength)
+    if req.getContentLength > 0 && req.getContentLength < MAX_BUFFER
+      @stream.mark(req.getContentLength)
+    else
+      # TODO: buffer to a file or something; use jruby-rack's RewindableInputStream
+      req.getServletContext.log(
+        "WARN: input stream of size #{req.getContentLength}; " +
+        "rack #rewind only supported to first #{MAX_BUFFER/1024} kiB")
+      @stream.mark(MAX_BUFFER)
+    end
+    
+    @io = stream.to_io
+  end
+  
+  def rewind
+    @stream.reset
+  end
+end

data/lib/rubylet/logger.rb

@@ -0,0 +1,38 @@
+require 'rubylet/errors'
+
+# TODO: should this wrap slf4j or something?  Or is it typically overridden
+# by the rack application?
+module Rubylet
+  class Logger < Rubylet::Errors
+    
+    def info(message = nil, &block)
+      log(:info, message, &block)
+    end
+    
+    def debug(message = nil, &block)
+      log(:debug, message, &block)
+    end
+    
+    def warn(message = nil, &block)
+      log(:warn, message, &block)
+    end
+    
+    def error(message = nil, &block)
+      log(:error, message, &block)
+    end
+    
+    def fatal(message = nil, &block)
+      log(:fatal, message, &block)
+    end
+    
+    def log(level, message = nil, &block)
+      msg = if message
+              message
+            elsif block_given?
+              yield
+            end
+      
+      write("#{level.to_s.upcase}: #{msg}")
+    end
+  end
+end

data/lib/rubylet/mem_file_io.rb

@@ -0,0 +1,80 @@
+require 'tempfile'
+
+# A memory/file IO buffer.  Data will be written to a memory buffer up
+# to a limit, after which a file buffer is used.  Supports Rack input
+# stream operations.  Not threadsafe.
+module Rubylet
+  class MemFileIO
+    DEFAULT_LIMIT = 4096 * 4
+    
+    # @param [Integer] limit the max size of the first (memory) buffer
+    def initialize(limit = DEFAULT_LIMIT)
+      @limit = limit
+      @mem = StringIO.new
+      @file = nil
+    end
+
+    def puts(str)
+      for_write(str.size + $/.size).puts(str)
+    end
+
+    def write(str)
+      for_write(str.size).write(str)
+    end
+
+    def gets
+      for_read.gets
+    end
+
+    def read(length = nil, buffer = nil)
+      if buffer
+        for_read.read(length, buffer)
+      else
+        for_read.read(length)
+      end
+    end
+
+    def each(&block)
+      for_read.each(&block)
+    end
+
+    def rewind
+      for_read.rewind
+    end
+
+    def close
+      for_read.close
+    end
+
+    private
+
+    def for_read
+      @mem || @file
+    end
+
+    def switch_to_file
+      mem = @mem
+      @mem = nil
+      mem.rewind
+      @file = make_file(mem.read)
+    end
+
+    def for_write(size)
+      if @file
+        @file
+      elsif (@mem.size + size) <= @limit
+        @mem
+      else
+        switch_to_file
+        @file
+      end
+    end
+
+    def make_file(data)
+      file = Tempfile.new('MemFileBacking')
+      file.unlink
+      file.write(data)
+      file
+    end
+  end
+end

data/lib/rubylet/rewindable_io.rb

@@ -0,0 +1,66 @@
+require 'rubylet/tee_io'
+require 'rubylet/mem_file_io'
+require 'stringio'
+
+# Wraps an IO with a memory and file backed buffer to support Rack's
+# required #rewind.
+#
+# Only some IO methods are supported.
+module Rubylet
+  class RewindableIO
+    def initialize(io, limit = MemFileIO::DEFAULT_LIMIT)
+      @buf = MemFileIO.new(limit)
+      @io = TeeIO.new(io, @buf)
+    end
+
+    def gets
+      str = @buf.gets
+      if str.nil?                 # end of buffer
+        @io.gets
+      elsif str.end_with?($/)     # good, we got a whole line
+        str
+      else                        # partial line
+        str + (@io.gets || '')
+      end
+    end
+
+    def read(length = nil, buffer = nil)
+      if length.nil? && buffer.nil?
+        @buf.read + @io.read
+      elsif length.nil?
+        @buf.read(nil, buffer)
+        @io.read(nil, buffer)
+      elsif buffer.nil?
+        str = ''
+        @buf.read(length, str)
+        if (str.size == length)
+          @io.read(length - str.size, str)
+        end
+        str
+      else                        # both non-nil
+        size0 = buffer.size
+        @buf.read(length, buffer)
+        from_buf = buffer.size - size0
+        if (from_buf < length)
+          @io.read(length - from_buf, buffer)
+        end
+        buffer
+      end
+    end
+
+    def each
+      while s = gets
+        yield s
+      end
+    end
+
+    def rewind
+      @buf.rewind
+    end
+
+    def close
+      @buf.close
+      @io.close
+    end
+  end
+end

data/lib/rubylet/servlet.rb

@@ -0,0 +1,149 @@
+require 'java'
+require 'rack'
+
+module Rubylet
+  # Implements the Servlet API in Ruby as a Rack server.
+  class Servlet
+    include Java::JavaxServlet::Servlet
+
+    attr_reader :servlet_config, :app, :context
+    
+    # @param [javax.servlet.ServletConfig] servletConfig
+    def init(servletConfig)
+      @servlet_config = servletConfig
+      @context = servletConfig.getServletContext
+      
+      rackup_file = param('rackupFile') || 'config.ru'
+      @app, _opts = Rack::Builder.parse_file(rackup_file)
+
+      if defined?(Rails) && defined?(Rails::Application) && (@app < Rails::Application)
+        servlet_path = @servlet_config.getInitParameter('servletPath')
+        relative_root = if servlet_path 
+                          File.join(@context.context_path, servlet_path)
+                        else
+                          @context.context_path
+                        end
+        app.config.action_controller.relative_url_root = relative_root
+        ActionController::Base.config.relative_url_root = relative_root
+      end
+    end
+    
+    # def param(config, name)
+    #   config.getInitParameter(name) ||
+    #     config.getServletContext.getInitParameter(name)
+    # end
+
+    def param(name)
+      @servlet_config.getInitParameter(name) ||
+        @servlet_config.getServletContext.getInitParameter(name)
+    end
+    
+    def destroy
+      # no-op
+    end
+
+    def to_s
+      "#<#{self.class} @app=#{@app}>"
+    end
+
+    alias :servlet_info :to_s
+
+    # @param [javax.servlet.ServletRequest] req a Java servlet request,
+    # assumed to be an HttpServletRequest
+    #
+    # @param [javax.servlet.ServletResponse] resp a Java servlet response
+    # assumed to be an HttpServletResponse
+    def service(req, resp)
+      env = Environment.new(req, self)
+      
+      catch(:async) do
+        status, headers, body = app.call(env)  # may throw async
+        throw :async if status == -1  # alternate means of indicating async
+        respond(resp, env, status, headers, body)
+        return  # :async not thrown
+      end
+
+      # :async was thrown; this only works since Servlet 3.0
+      # web.xml must also have <async-supported>true<async-supported> in
+      # all servlets and filters in the chain.
+      #
+      # TODO: this works in proof-of-concept! anything more todo?
+      #
+      # TODO: Rack async doesn't seem to be standardized yet... In particular,
+      # Thin provides an 'async.close' that (I think) can be used to
+      # close the response connection after streaming in data asynchronously.
+      # For now, this code only allows a one-time deferal of the body (i.e.
+      # when 'async.callback' is called, the body is sent out and the
+      # connection closed immediately.)
+      #
+      # TODO: because of the above, there isn't a way to quickly send headers
+      # but then delay the body.
+      #
+      # Example Rack application:
+      #
+      #    require 'thread'
+      #
+      #    class AsyncExample
+      #      def call(env)
+      #        cb = env['async.callback']
+      #
+      #        Thread.new do
+      #          sleep 5                # long task, wait for message, etc.
+      #          body = ['Hello, World!']
+      #          cb.call [200, {'Content-Type' => 'text/plain'}, body]
+      #        end
+      #
+      #        throw :async
+      #      end
+      #    end
+      async_context = req.startAsync
+      env.on_async_callback do |(status, headers, body)|
+        resp = async_context.getResponse
+        respond(resp, env, status, headers, body)
+        async_context.complete
+      end
+    end
+
+    private
+
+    def respond(resp, env, status, headers, body)
+      resp.setStatus(status)
+      headers.each do |k, v|
+        resp.setHeader k, v
+      end
+      # commit the response and send the headers to the client
+      resp.flushBuffer
+
+      if body.respond_to? :to_path
+        #env['rack.logger'].warn {
+        #  "serving static file with ruby: #{body.to_path}"
+        #}
+
+        # TODO: faster to user pure java implementation?  Probably better to
+        # either not have ruby serve static files or to put some cache out
+        # front.
+        write_body(body, resp.getOutputStream) { |part| part.to_java_bytes }
+      else
+        write_body(body, resp.getWriter)
+      end
+    end
+
+    # Write each part of body with writer.  Optionally transform each
+    # part with the given block.  Flush the writer after each
+    # part. Ensure body is closed if it responds to :close.  Close the
+    # writer.
+    def write_body(body, writer)
+      begin
+        body.each do |part|
+          writer.write(block_given? ? yield(part) : part)
+          writer.flush
+        end
+      ensure
+        body.close if body.respond_to?(:close) rescue nil
+        writer.close
+      end
+    end
+  end
+end
+
+require 'rubylet/environment'

data/lib/rubylet/session.rb

@@ -0,0 +1,33 @@
+class Rubylet::Session
+
+  def initialize(req)
+    @javaSession = req.getSession
+  end
+  
+  def store(key, value)
+    @javaSession.setAttribute(key, value)
+  end
+  
+  alias_method :[]=, :store
+  
+  def fetch(key, default = nil)
+    @javaSession.getAttribute(key) || default
+  end
+  
+  alias_method :[], :fetch
+  
+  def delete(key)
+    @javaSession.removeAttribute(key)
+  end
+  
+  def clear
+    @javaSession.getAttributeNames.each {|key| delete(key) }
+  end
+
+  def to_hash
+    hash = {}
+    @javaSession.getAttributeNames.each {|key| hash[key] = @javaSession.getAttribute(key) }
+    hash
+  end
+  
+end

data/lib/rubylet/tee_io.rb

@@ -0,0 +1,43 @@
+# All reads on +io+ are copied to +out+.  Only supports IO methods
+# specified by Rack Input Stream spec.
+module Rubylet
+  class TeeIO
+    def initialize(io, out)
+      @io = io
+      @out = out
+    end
+
+    # Does not support custom separator per Rack spec
+    def gets
+      str = @io.gets
+      @out.write(str) if str
+      str
+    end
+
+    def read(length = nil, buffer = nil)
+      str = ''
+      ret = @io.read(length, str)
+      @out.write(str)
+      if buffer
+        buffer << str
+        if ret.object_id == str.object_id
+          buffer
+        else
+          ret
+        end
+      else
+        ret
+      end
+    end
+
+    def each
+      while s = gets
+        yield s
+      end
+    end
+
+    def close
+      @io.close
+    end
+  end
+end

data/spec/rubylet/mem_file_io_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'rubylet/mem_file_io'
+
+module Rubylet
+
+  describe MemFileIO do
+    
+    it 'writes data with puts' do
+      @io = MemFileIO.new
+      @io.puts('hello')
+      @io.rewind
+      @io.read.must_equal "hello#{$/}"
+    end
+
+    it 'writes data with write' do
+      @io = MemFileIO.new
+      @io.write('hello')
+      @io.rewind
+      @io.read.must_equal 'hello'
+    end
+
+    it 'allows multiple rewind' do
+      @io = MemFileIO.new
+
+      @io.write('hello')
+      @io.rewind
+      @io.read.must_equal 'hello'
+
+      @io.write('hello')
+      @io.rewind
+      @io.read.must_equal 'hellohello'
+    end
+
+    it 'overwrites? (FIXME: is this correct?)' do
+      @io = MemFileIO.new
+
+      @io.write('hello')
+      @io.rewind
+      @io.read.must_equal 'hello'
+
+      @io.rewind
+      @io.write('***')
+      @io.rewind
+      @io.read.must_equal '***lo'
+    end
+
+    it 'switches to backing file' do
+      @io = MemFileIO.new(4)
+      @io.write('1234')
+      @io.write('5678')
+      @io.rewind
+      @io.read.must_equal '12345678'
+    end
+
+    it 'returns nil on EOF' do
+      @io = MemFileIO.new
+      @io.read
+      @io.read(1).must_equal nil
+    end
+
+    it 'returns empty string on EOF' do
+      @io = MemFileIO.new
+      @io.read
+      @io.read.must_equal ''
+    end
+  end
+
+end

data/spec/rubylet/rewindable_io_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'rubylet/rewindable_io'
+require 'stringio'
+
+module Rubylet
+
+  describe RewindableIO do
+    
+    data = "some data\nwith newlines\nanother line"
+
+    before :each do
+      @io = StringIO.new
+      @io.write(data)
+      @io.rewind
+
+      @reio = RewindableIO.new(@io)
+    end
+
+    it 'rewinds' do
+      @reio.read.must_equal data
+      @reio.rewind
+      @reio.read.must_equal data
+    end
+
+    it 'rewinds with file spill over' do
+      expected = ''
+      10.times do
+        @io.write(data)
+        expected << data
+      end
+      @io.rewind
+
+      @reio = RewindableIO.new(@io, 32)
+      @reio.read.must_equal expected
+      @reio.rewind
+      @reio.read.must_equal expected
+    end
+  end
+end

data/spec/rubylet/tee_io_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+require 'rubylet/tee_io'
+require 'stringio'
+
+module Rubylet
+
+  describe TeeIO do
+
+    DATA = "some data\nwith newlines\nanother line"
+
+    before :each do
+      @io = StringIO.new
+      @io.write(DATA)
+      @io.rewind
+
+      @out = StringIO.new
+
+      @tee = TeeIO.new(@io, @out)
+    end
+    
+    it 'copies data on read' do
+      @tee.read
+      @out.rewind
+      @out.read.must_equal DATA
+    end
+
+    describe '#gets' do
+      it 'copies data on gets' do
+        @tee.gets
+        @out.rewind
+        @out.read.must_equal "some data\n"
+      end
+
+      it 'returns nil on EOF' do
+        @tee.read
+        @tee.gets.must_equal nil
+      end
+    end
+
+    it 'copies data on each' do
+      @tee.each {}
+      @out.rewind
+      @out.read.must_equal DATA
+    end
+
+    it 'copies data byte by byte' do
+      @tee.read(1)
+      @tee.read(1)
+      @out.rewind
+      @out.read.must_equal 'so'
+    end
+
+    it 'reads data into a given buffer' do
+      buf = String.new
+      ret = @tee.read nil, buf
+
+      ret.object_id.must_equal buf.object_id
+
+      buf.must_equal DATA
+      @out.rewind
+      @out.read.must_equal DATA
+    end
+
+    it 'returns nil on EOF' do
+      @tee.read
+      @tee.read(1).must_equal nil
+    end
+
+    it 'returns empty string on EOF' do
+      @tee.read
+      @tee.read.must_equal ''
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'minitest/matchers'

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: rubylet
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: 0.1.0
+platform: java
+authors:
+- CG Labs
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2012-12-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest-matchers
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: version
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MQ==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MQ==
+    none: false
+  prerelease: false
+  type: :development
+description: Java Servlet implementation that forwards to Rack application
+email:
+- eng@commongroundpublishing.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- VERSION
+- MIT-LICENSE
+- lib/rubylet.rb
+- lib/rubylet/mem_file_io.rb
+- lib/rubylet/environment.rb
+- lib/rubylet/rewindable_io.rb
+- lib/rubylet/input.rb
+- lib/rubylet/tee_io.rb
+- lib/rubylet/errors.rb
+- lib/rubylet/session.rb
+- lib/rubylet/logger.rb
+- lib/rubylet/servlet.rb
+- spec/spec_helper.rb
+- spec/rubylet/rewindable_io_spec.rb
+- spec/rubylet/mem_file_io_spec.rb
+- spec/rubylet/tee_io_spec.rb
+homepage:
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+      segments:
+      - 0
+      hash: 2
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+      segments:
+      - 0
+      hash: 2
+  none: false
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: Java Servlet implementation that forwards to Rack application
+test_files: []