rubylet-rack 2.0.0.pre1-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 @@
+2.0.0.pre1

data/lib/rubylet/rack.rb

@@ -0,0 +1,5 @@
+require 'rubylet/rack/dechunking_body'
+require 'rubylet/rack/errors'
+require 'rubylet/rack/ext'
+require 'rubylet/rack/rewindable_io'
+require 'rubylet/rack/session/container_store'

data/lib/rubylet/rack/dechunking_body.rb

@@ -0,0 +1,45 @@
+module Rubylet
+  module Rack
+    # Rails and possibly others manually set 'Transfer-Encoding:
+    # chunked' and then send the body as chunks.  Java servlet
+    # environment expects the server to handle chunking as needed
+    # (e.g. when a response overflows the buffer and must be flushed to
+    # the client before the servlet has closed the stream).
+    #
+    # This class makes the rather large assumption that {body#each}
+    # iterates through the chunks, so we don't actually do much parsing.
+    #
+    # FIXME: ignores encoding?
+    class DechunkingBody
+      EOL = "\r\n".freeze
+
+      CHUNK_START = Regexp.compile /^((\h+)#{Regexp.quote(EOL)})/
+
+      def initialize(body)
+        @body = body
+      end
+
+      def each
+        @body.each do |chunk|
+          yield chunk_to_part(chunk)
+        end
+      end
+
+      def close
+        @body.close
+      end
+
+      private
+
+      def chunk_to_part(chunk)
+        if chunk =~ CHUNK_START
+          chunk_start = $1.bytesize
+          chunk_length = $2.to_i(16)
+          chunk.byteslice(chunk_start, chunk_length)
+        else
+          chunk
+        end
+      end
+    end
+  end
+end

data/lib/rubylet/rack/errors.rb

@@ -0,0 +1,25 @@
+# Implements the rack.errors interface, logging everything via
+# ServletContext#log
+module Rubylet
+  module Rack
+    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
+end

data/lib/rubylet/rack/logger.rb

@@ -0,0 +1,40 @@
+require 'rubylet/rack/errors'
+
+# TODO: should this wrap slf4j or something?  Or is it typically overridden
+# by the rack application?
+module Rubylet
+  module Rack
+    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
+end

data/lib/rubylet/rack/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::Rack
+  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/rack/rewindable_io.rb

@@ -0,0 +1,66 @@
+require 'rubylet/rack/tee_io'
+require 'rubylet/rack/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::Rack
+  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/rack/session.rb

@@ -0,0 +1,63 @@
+# A Rack compatible session object that forwards to an underlying
+# +javax.servlet.http.HttpSession+.
+module Rubylet; module Rack
+  class Session
+    # @param [javax.servlet.http.HttpServletRequest] req
+    # @param [Hash] options
+    # @option options [Integer] :expire_after The max inactive interval, in seconds
+    def initialize(req, options={})
+      @javaSession = req.getSession
+
+      if @javaSession.isNew
+        if exp = options[:expire_after]
+          req.setMaxInactiveInterval exp.to_i
+        end
+      end
+    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
+
+    # This method is not required by the Rack SPEC for session
+    # objects, but Rails calls it anyway in +actionpack (3.2.9)
+    # lib/action_dispatch/middleware/flash.rb:258:in `call'+
+    def has_key?(key)
+      !(fetch(key).nil?)
+    end
+    alias_method :include?, :has_key?
+    alias_method :key?, :has_key?
+    alias_method :member?, :has_key?
+
+    # Used by Rails but not required by Rack.
+    def destroy
+      @javaSession.invalidate
+    end
+
+    def to_hash
+      hash = {}
+      @javaSession.getAttributeNames.each do
+        |key| hash[key] = @javaSession.getAttribute(key)
+      end
+      hash
+    end
+
+    def inspect
+      to_hash.inspect
+    end
+  end
+end; end

data/lib/rubylet/rack/session/container_store.rb

@@ -0,0 +1,29 @@
+require 'rubylet/rack/session'
+
+# Rack middleware to make the servlet container's sessions available to ruby.
+module Rubylet
+  module Rack
+    class Session
+      class ContainerStore
+        def initialize(app, options={})
+          @app = app
+          @options = options
+        end
+
+        def call(env)
+          context(env)
+        end
+
+        # For Rack::Util::Context
+        def context(env, app=@app)
+          if req = env['java.servlet_request']
+            env['rack.session'] = Session.new(req, @options)
+          else
+            env['rack.errors'].puts 'java.servlet_request not found; cannot make session'
+          end
+          app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/rubylet/rack/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::Rack
+  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/rack/dechunking_body_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'rubylet/rack/dechunking_body'
+
+module Rubylet::Rack
+  describe DechunkingBody do
+    def chunk(strs)
+      strs.map do |str|
+        str.bytesize.to_s(16) + "\r\n" + str + "\r\n"
+      end + ["0\r\n\r\n"]
+    end
+
+    def dechunk(body)
+      ''.tap do |str|
+        DechunkingBody.new(body).each { |part| str << part }
+      end
+    end
+    
+    it 'de-chunks a chunked body' do
+      data = ["some", "data", "\n in chunks."]
+      expected = data.join
+      assert_equal expected, dechunk(chunk(data))
+    end
+  end
+end

data/spec/rubylet/rack/mem_file_io_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'rubylet/rack/mem_file_io'
+
+module Rubylet::Rack
+
+  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/rack/rewindable_io_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'rubylet/rack/rewindable_io'
+require 'stringio'
+
+module Rubylet::Rack
+
+  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/rack/tee_io_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+require 'rubylet/rack/tee_io'
+require 'stringio'
+
+module Rubylet::Rack
+
+  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,5 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'minitest/matchers'
+
+module Rubylet; module Rack; end; end;

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: rubylet-rack
+version: !ruby/object:Gem::Version
+  prerelease: 6
+  version: 2.0.0.pre1
+platform: java
+authors:
+- Patrick Mahoney
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-03-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  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: :runtime
+- !ruby/object:Gem::Dependency
+  name: mechanize
+  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: mini_aether
+  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: 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: unf
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+    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:
+- pat@polycrystal.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- VERSION
+- MIT-LICENSE
+- lib/rubylet/rack/ext.jar
+- lib/rubylet/rack.rb
+- lib/rubylet/rack/dechunking_body.rb
+- lib/rubylet/rack/errors.rb
+- lib/rubylet/rack/logger.rb
+- lib/rubylet/rack/mem_file_io.rb
+- lib/rubylet/rack/rewindable_io.rb
+- lib/rubylet/rack/session.rb
+- lib/rubylet/rack/tee_io.rb
+- lib/rubylet/rack/session/container_store.rb
+- spec/spec_helper.rb
+- spec/rubylet/rack/dechunking_body_spec.rb
+- spec/rubylet/rack/mem_file_io_spec.rb
+- spec/rubylet/rack/rewindable_io_spec.rb
+- spec/rubylet/rack/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
+      segments:
+      - 0
+      hash: 2
+      version: !binary |-
+        MA==
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - !binary |-
+      Pg==
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+  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: []