jruby-rack 0.9.7

data/History.txt

@@ -0,0 +1,109 @@
+== 0.9.6
+
+- JRUBY_RACK-22: Ensure we call #close on the body per the Rack spec.
+- Set jruby.management.enabled true when creating a runtime. JRuby 1.5
+  will default this flag to false, but you probably still want JMX
+  capability inside an appserver.
+- Miscellaneous spec cleanup due to changes in JRuby 1.5
+
+== 0.9.5
+
+- Upgrade to Rack 1.0.0. However, if you supply Rack in your
+  application (either via rubygems or by vendoring it), it will take
+  precedence -- JRuby-Rack's bundled copy is only loaded as a
+  fallback. This allows you to upgrade Rack without having to wait for
+  a new JRuby-Rack release.
+- Implement Rack-based java servlet session mechanism. You'll have to
+  turn on java servlet sessions by setting
+    ActionController::Base.session_store = :java_servlet_store
+  in your config/initializers/session_store.rb.
+- JRUBY_RACK-7: Implement a rewindable 'rack.input' shim between the
+  servlet input stream and the Rack environment. Below a certain
+  byte-size threshold, the input is entirely buffered in memory. Above
+  the threshold, the input is written to a tempfile. The default
+  threshold is 64k, and can be controlled by the system property
+  'jruby.rack.request.size.threshold.bytes'.
+- The previous non-rewindable input behavior can be re-instated by
+  setting the system property 'jruby.rack.input.rewindable' to false.
+  Despite being out of spec, environments such as Google AppEngine
+  require this behavior because writing to a tempfile is not possible.
+- JRUBY_RACK-4: deal with threading and to_io by assigning IO object
+  to an instance variable instead of defining a singleton method on
+  the metaclass/singleton class
+- JRUBY_RACK-17: Fix SCRIPT_NAME/PATH_INFO in root context (Chris
+  Read)
+- JRUBY_RACK-10, JRUBY_RACK-15: Fix request channel read issue w/
+  POSTs and multiparts (Michael Pitman, Lenny Marks)
+- JRUBY_RACK-14: Override both Servlet service methods (Michael
+  Pitman)
+
+== 0.9.4
+
+- PLEASE NOTE: Prior to 0.9.4, jruby-rack would try to use the java
+  servlet session store by default. This caused more confusion than
+  it's worth; so the default Rails cookie session store has been
+  reinstated for this release.
+- Upgrade bundled Rack version to 0.9.1
+- Introduce RackLogger, defaults to log to servlet context but can be
+  made to point to stdout by setting -Djruby.rack.logging=stdout (for
+  Google AppEngine)
+- Detect Rails 2.3 rack machinery and dispatch to it rather than the
+  legacy CGI shim.
+- TODO: Still missing a java servlet Rack::Session adapter for Rails
+  2.3. Should have it for next release.
+- Update example Rails application to Rails 2.3.2, include bits for
+  deployment to Google AppEngine using Warbler.
+- RackApplication-related core Java classes have been insulated from
+  the servlet API, so that (parts of) JRuby-Rack can be used outside
+  of a servlet container. If your application or library is coupled to
+  these classes, you'll likely be broken with this release. See Nick
+  for details.
+- Fix TLD to be more compatible (Fred McHale).
+- Switched main code repository to kenai.com. Github.com still
+  available as a mirror and for forking.
+- EXPERIMENTAL: Beginnings of a JMS API (more details to come)
+- REMOVAL: All the goldspike compatibility bits have been removed. You
+  should upgrade your application to use a web.xml similar to what
+  comes with Warbler.
+
+== 0.9.3
+
+- Merb updates for 1.0 compatibility
+- Patch race condition in runtime pooling that allowed more than max
+  number of runtimes
+- Fix bug with backref interpretation and windows paths
+- JRUBY-2908: Add fallback for when servletContext.getRealPath doesn't
+  work (Joern Hartmann)
+- Add extra prevention to ensure that IO descriptor keys do not leak in
+  the runtime's cache of descriptors (see also JRUBY-3185)
+- Switched to dual rake/maven build process
+- Switched main code repository to github (for now)
+
+== 0.9.2
+
+- Upgrade to Rack 0.4.0
+- Only chdir at startup when the /WEB-INF directory exists (fix for jetty-rails)
+- Fix typos in rails tag tld
+- Add getRuntime to RackApplication for use by non-web embedded applications
+- Use a shared application factory for Rails if max runtimes == 1 (to support multi-threaded Rails)
+- Change from jruby.initial.runtimes to jruby.min.runtimes to be consistent w/ Warbler
+
+== 0.9.1
+
+- Change each runtime's notion of current directory to /WEB-INF, so you can do
+  loads and requires relative to WEB-INF
+- JRUBY-2507: Update Rails boot override to not pre-load action_controller
+- Don't assume or set cache_template_loading to true, rely on Rails to do it for us
+- Set ENV['HTTPS'] = 'on' for Rails depending on servlet request scheme (Lenny Marks)
+- Fix request URI -- must include query string
+- Updated to be built and tested against JRuby 1.1.3
+- Ensure that gem environment is set up for plain rack apps too
+- JRUBY-2594: Fix URI-escaping issue (e.g., when spaces are in the path)
+- Make use of 'Rails.public_path' in Rails 2.1
+- JRUBY-2620: Fix issue with non-string headers
+- Support integer and date headers directly
+- Examples: Rails updated to 2.1, Camping and Sinatra examples added/working
+
+== 0.9
+
+- First public release.

data/LICENSE.txt

@@ -0,0 +1,24 @@
+#--
+# The MIT License
+#
+# Copyright (c) 2010 Engine Yard, Inc.
+# Copyright (c) 2007-2009 Sun Microsystems, Inc.
+#
+# 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,280 @@
+# JRuby-Rack
+
+- http://jruby-rack.kenai.com/
+
+JRuby-Rack is a lightweight adapter for the Java servlet environment
+that allows any Rack-based application to run unmodified in a Java
+servlet container. JRuby-Rack supports Rails, Merb, as well as any
+Rack-compatible Ruby web framework.
+
+For more information on Rack, visit http://rack.rubyforge.org.
+
+# Getting Started
+
+The easiest way to use JRuby-Rack is to get [Warbler][1]. Warbler
+bundles the latest version of JRuby-Rack and ensures it gets placed in
+your WAR file when it gets built.
+
+If you're assembling your own WAR using other means, you'll need to
+drop the [latest JRuby-Rack jar][2] into the WEB-INF/lib directory and
+configure the RackFilter in your application's web.xml. Example
+web.xml snippets are as follows.
+
+## For Rails
+
+Here's sample web.xml configuration for Rails. Note the environment
+and min/max runtime parameters. For multi-threaded Rails with a single
+runtime, set min/max both to 1. Otherwise, define the size of the
+runtime pool as you wish.
+
+    <context-param>
+      <param-name>rails.env</param-name>
+      <param-value>production</param-value>
+    </context-param>
+
+    <context-param>
+      <param-name>jruby.min.runtimes</param-name>
+      <param-value>1</param-value>
+    </context-param>
+
+    <context-param>
+      <param-name>jruby.max.runtimes</param-name>
+      <param-value>1</param-value>
+    </context-param>
+
+    <filter>
+      <filter-name>RackFilter</filter-name>
+      <filter-class>org.jruby.rack.RackFilter</filter-class>
+    </filter>
+    <filter-mapping>
+      <filter-name>RackFilter</filter-name>
+      <url-pattern>/*</url-pattern>
+    </filter-mapping>
+
+    <listener>
+      <listener-class>org.jruby.rack.rails.RailsServletContextListener</listener-class>
+    </listener>
+
+## For Other Rack Applications
+
+Here's a sample web.xml configuration for a Sinatra application. The
+main difference is to place the rackup script for assembling the
+Rack-based application in the 'rackup' parameter. Be sure to escape
+angle-brackets for XML.
+
+    <context-param>
+      <param-name>rackup</param-name>
+      <param-value>
+        require 'rubygems'
+        gem 'sinatra', '~&gt; 0.9'
+        require './lib/demo'
+        set :run, false
+        set :environment, :production
+        run Sinatra::Application
+      </param-value>
+    </context-param>
+
+    <filter>
+      <filter-name>RackFilter</filter-name>
+      <filter-class>org.jruby.rack.RackFilter</filter-class>
+    </filter>
+    <filter-mapping>
+      <filter-name>RackFilter</filter-name>
+      <url-pattern>/*</url-pattern>
+    </filter-mapping>
+
+    <listener>
+      <listener-class>org.jruby.rack.RackServletContextListener</listener-class>
+    </listener>
+
+# Features
+
+## Servlet Filter
+
+JRuby-Rack's main mode of operation is as a servlet filter. This
+allows requests for static content to pass through and be served by
+the application server. Dynamic requests only happen for URLs that
+don't have a corresponding file, much like many Ruby applications
+expect. The application can also be configured to dispatch through a
+servlet instead of a filter if it suits your environment better.
+
+## Servlet environment integration
+
+- Servlet context is accessible to any application both through the
+  global variable $servlet_context and the Rack environment variable
+  java.servlet_context.
+- Servlet request object is available in the Rack environment via the
+  key java.servlet_request.
+- Servlet request attributes are passed through to the Rack
+  environment.
+- Rack environment variables and headers can be overridden by servlet
+  request attributes.
+- Java servlet sessions are available as a session store for both
+  Rails and Merb. Session attributes with String keys and String,
+  numeric, boolean, or java object values are automatically copied to
+  the servlet session for you.
+
+## Rails
+
+Several aspects of Rails are automatically set up for you.
+
+- The Rails controller setting ActionController::Base.relative_url_root
+  is set for you automatically according to the context root where
+  your webapp is deployed.
+- Rails logging output is redirected to the application server log.
+- Page caching and asset directories are configured appropriately.
+
+## JRuby Runtime Management
+
+JRuby runtime management and pooling is done automatically by the
+framework. In the case of Rails, runtimes are pooled. For Merb and
+other Rack applications, a single runtime is created and shared for
+every request.
+
+## Servlet Context Init Parameters
+
+JRuby-Rack can be configured by setting context init parameters in
+web.xml.
+
+- `rackup`: Rackup script for configuring how the Rack application is
+  mounted. Required for Rack-based applications other than Rails or
+  Merb. Can be omitted if a `config.ru` is included in the application
+  root.
+- `jruby.min.runtimes`: For non-threadsafe Rails applications using a
+  runtime pool, specify an integer minimum number of runtimes to hold
+  in the pool.
+- `jruby.max.runtimes`: For non-threadsafe Rails applications, an
+  integer maximum number of runtimes to keep in the pool.
+- `jruby.init.serial`: When using runtime pooling, indicate that the
+  runtime pool should be created serially in the foreground rather
+  than spawning background threads. For environments where creating
+  threads is not permitted.
+- `public.root`: Relative path to the location of your application's
+  static assets. Defaults to `/`.
+- `gem.path`: Relative path to the bundled gem repository. Defaults to
+  `/WEB-INF/gems`.
+- `rails.root`, `merb.root`: Root path to the location of the Rails or
+  Merb application files. Defaults to `/WEB-INF`.
+- `rails.env`: Specify the Rails environment to run. Defaults
+  to 'production'.
+- `merb.environment`: Specify the merb environment to run. Defaults to
+  `production`.
+
+# Building
+
+Checkout the JRuby Rack code and cd to that directory.
+
+    git clone git://kenai.com/jruby-rack~main jruby-rack
+    cd jruby-rack
+
+You can choose to build with either Maven or Rake. Either of the
+following two will suffice (but see the NOTE below).
+
+    mvn install
+    jruby -S rake
+
+The generated jar should be located here: target/jruby-rack-*.jar.
+
+## Rails Step-by-step
+
+This example shows how to create and deploy a simple Rails app using
+the embedded Java database H2 to a WAR using Warble and JRuby Rack.
+JRuby Rack is now included in the latest release of Warbler (0.9.9),
+but you can build your own jar from source and substitute it if you
+like.
+
+Install Rails and the driver and ActiveRecord adapters for the H2
+database:
+
+    jruby -S gem install rails activerecord-jdbch2-adapter
+
+Install Warbler:
+
+    jruby -S gem install warbler
+
+Make the "Blog" application
+
+    jruby -S rails blog
+    cd blog
+
+Copy this configuration into config/database.yml:
+
+    development:
+      adapter: jdbch2
+      database: db/development_h2_database
+
+    test:
+      adapter: jdbch2
+      database: db/test_h2_database
+
+    production:
+      adapter: jdbch2
+      database: db/production_h2_database
+
+Generate a scaffold for a simple model of blog comments.
+
+    jruby script/generate scaffold comment name:string body:text
+
+Run the database migration that was just created as part of the scaffold.
+
+    jruby -S rake db:migrate
+
+Start your application on the Rails default port 3000 using Mongrel/
+and make sure it works:
+
+    jruby script/server
+
+Generate a custom Warbler WAR configuration for the blog application
+
+    jruby -S warble config
+
+Generate a production version of the H2 database for the blog
+application:
+
+    RAILS_ENV=production jruby -S rake db:migrate
+
+Edit this file: config/warble.rb and add the following line after
+these comments:
+
+    # Additional files/directories to include, above those in config.dirs
+    # config.includes = FileList["db"]
+    config.includes = FileList["db/production_h2*"]
+
+This will tell Warble to include the just initialized production H2
+database in the WAR.
+
+Continue editing config/warble.rb and add the following line after
+these comments:
+
+    # Gems to be packaged in the webapp.  Note that Rails gems are added to this
+    # list if vendor/rails is not present, so be sure to include rails if you
+    # overwrite the value
+    # config.gems = ["activerecord-jdbc-adapter", "jruby-openssl"]
+    # config.gems << "tzinfo"
+    # config.gems["rails"] = "1.2.3"
+    config.gems << "activerecord-jdbch2-adapter"
+
+This will tell Warble to add the JDBC driver for H2 as well as the
+ActiveRecord JDBC and JDBC-H2 adapter Gems.
+
+Now generate the WAR file:
+
+    jruby -S warble war
+
+This task generates the file: blog.war at the top level of the
+application as well as an exploded version of the war located here:
+tmp/war.
+
+The war should be ready to deploy to your Java application server.
+
+# Thanks
+
+- All contributors! But also:
+- Dudley Flanders, for the Merb support
+- Robert Egglestone, for the original JRuby servlet integration
+  project, Goldspike
+- Chris Neukirchen, for Rack
+- Sun Microsystems, for early project support
+
+[1]: http://warbler.kenai.com/pages/Home
+[2]: http://repository.codehaus.org/org/jruby/rack/jruby-rack/

data/lib/jruby-rack.rb

@@ -0,0 +1,6 @@
+require 'jruby/rack/version'
+module JRubyJars
+  def self.jruby_rack_jar_path
+    File.expand_path("../jruby-rack-#{JRuby::Rack::VERSION}.jar", __FILE__)
+  end
+end

data/lib/jruby/rack/version.rb

@@ -0,0 +1,12 @@
+#--
+# Copyright (c) 2010 Engine Yard, Inc.
+# Copyright (c) 2007-2009 Sun Microsystems, Inc.
+# This source code is available under the MIT license.
+# See the file LICENSE.txt for details.
+#++
+
+module JRuby
+  module Rack
+    VERSION = "0.9.7"
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: jruby-rack
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+    - 0
+    - 9
+    - 7
+  version: 0.9.7
+platform: ruby
+authors: 
+  - Nick Sieger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-05 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: JRuby-Rack is a combined Java and Ruby library that adapts the Java Servlet API to Rack. For JRuby only.
+email: 
+  - nick@nicksieger.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - ./History.txt
+  - ./LICENSE.txt
+  - ./README.md
+  - ./lib/jruby-rack-0.9.7.jar
+  - ./lib/jruby-rack.rb
+  - ./lib/jruby/rack/version.rb
+has_rdoc: true
+homepage: http://jruby.org
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+requirements: []
+
+rubyforge_project: jruby-extras
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Rack adapter for JRuby and Servlet Containers
+test_files: []
+