trinidad_jars 0.3.2 → 0.3.3

data/lib/trinidad/jars.rb

@@ -4,7 +4,8 @@ $:.unshift(TRINIDAD_LIBS) unless
 
 module Trinidad
   require 'tomcat-core'
-  TOMCAT_VERSION = '7.0.2' unless defined?(Trinidad::TOMCAT_VERSION)
+  TRINIDAD_JARS_VERSION = '0.3.3'
+  TOMCAT_VERSION = '7.0.4' unless defined?(Trinidad::TOMCAT_VERSION)
 
   module Tomcat
     include_package 'org.apache.catalina'

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
     - 0
     - 3
-    - 2
-  version: 0.3.2
+    - 3
+  version: 0.3.3
 platform: ruby
 authors: 
   - David Calavera
@@ -14,45 +14,31 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-26 00:00:00 +02:00
-default_executable: trinidad
+date: 2010-11-11 00:00:00 -06:00
+default_executable: 
 dependencies: []
 
-description: 
+description: Bundled version of Tomcat packed for Trinidad
 email: calavera@apache.org
-executables: 
-  - trinidad
+executables: []
+
 extensions: []
 
-extra_rdoc_files: 
-  - LICENSE
-  - README.rdoc
+extra_rdoc_files: []
+
 files: 
   - lib/trinidad/jars.rb
   - trinidad-libs/tomcat-core.jar
-  - LICENSE
-  - README.rdoc
-  - spec/spec_helper.rb
-  - spec/fixtures/trinidad_foo_extension.rb
-  - spec/fixtures/trinidad_override_tomcat_extension.rb
-  - spec/trinidad/command_line_parser_spec.rb
-  - spec/trinidad/extensions_spec.rb
-  - spec/trinidad/fakeapp.rb
-  - spec/trinidad/server_spec.rb
-  - spec/trinidad/web_app_lifecycle_listener_spec.rb
-  - spec/trinidad/web_app_spec.rb
-  - bin/trinidad
 has_rdoc: true
-homepage: http://calavera.github.com/trinidad
+homepage: http://github.com/calavera/trinidad
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-  - --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
   - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
@@ -60,7 +46,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
           - 0
         version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
@@ -70,17 +55,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: trinidad_jars
-rubygems_version: 1.3.7
+rubygems_version: 1.3.6
 signing_key: 
-specification_version: 3
-summary: Common jars for Trinidad
-test_files: 
-  - spec/spec_helper.rb
-  - spec/fixtures/trinidad_foo_extension.rb
-  - spec/fixtures/trinidad_override_tomcat_extension.rb
-  - spec/trinidad/command_line_parser_spec.rb
-  - spec/trinidad/extensions_spec.rb
-  - spec/trinidad/fakeapp.rb
-  - spec/trinidad/server_spec.rb
-  - spec/trinidad/web_app_lifecycle_listener_spec.rb
-  - spec/trinidad/web_app_spec.rb
+specification_version: 2
+summary: Tomcat's jars packed for Trinidad
+test_files: []
+

data/LICENSE

@@ -1,26 +0,0 @@
-== Trinidad
-
-Copyright (c) 2009 David Calavera
-
-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.
-
-== Additional Bundled Software
-
-Apache Tomcat is licensed according to the terms of Apache License, Version 2.0 (current). See http://www.apache.org/licenses/LICENSE-2.0 for details.

data/README.rdoc

@@ -1,74 +0,0 @@
-= trinidad
-
-Trinidad allows you to run a rails or rackup applications within an embedded Apache Tomcat container.
-
-Mail list: http://groups.google.com/group/rails-trinidad
-Bug tracker: http://github.com/calavera/trinidad/issues
-
-== INSTALL:
-
-  jgem install trinidad
-
-== USAGE:
-
-Rails applications:
-
-    $ cd myrailsapp
-    $ jruby -S trinidad
-
-Rack applications:
-
-    $ cd myrackapplication
-
-    $ jruby -S trinidad -r path_to_rackup/rackup_file
-
-    or if the name of the file is config.ru
-
-    $ jruby -S trinidad -r path_to_rackup
-
-    or if config.ru is in the base directory
-
-    $ jruby -S trinidad -r
-
-    or if config.ru is under the directory WEB-INF
-
-    $ jruby -S trinidad
-
-== CONFIGURATION:
-
-Trinidad allows you to configure some parameters when the server is started from the command line, the following is a list of the currently supported options:
-
-  * -p, --port PORT             =>  port to bind to.
-  * -e, --env ENVIRONMENT       =>  rails environment.
-  * -c, --context CONTEXT       =>  application context path.
-  * --lib, --jars LIBS_DIR      =>  directory containing jars.
-  * --classes CLASSES_DIR       =>  directory containing classes.
-  * -r, --rackup [RACKUP_FILE]  =>  run a provided rackup file instead of a rails application, by default it's config.ru.
-  * --public PUBLIC_DIR         =>  specify the public directory for your application, by default it's 'public'.
-  * -t, --threadsafe            =>  shortcut to work in threadsafe mode. Setting jruby_min_runtimes and jruby_max_runtimes to 1 in the configuration file the server behaves as the same way.
-  * -l, --load EXTENSION_NAME   =>  loads an extension to use its command line options.
-
-The server can also be configured from a yaml file. If a file is not especified, the server tries to load the file <em>config/trinidad.yml</em>. Within this file you can add other options like jruby.min.runtimes(:jruby_min_runtimes) or jruby.max.runtimes(:jruby_max_runtimes).
-
-  jruby -S trinidad -f
-  jruby -S trinidad --config my_custom_configuration.yml
-
-You can also specify a default web.xml to config your web application. By default the server tries to load the file <em>config/web.xml</em> but you can modify this path adding the option <em>default_web_xml</em> within your configuration file. 
-
-Other advanced options can be found in the wiki: http://wiki.github.com/calavera/trinidad/advanced-configuration
-
-== EXTENSIONS:
-
-From the version 0.8.0 Trinidad allows to extend the server with more Tomcat features, here there is a list with the current available extensions:
-
-* Database connection pooling: http://github.com/calavera/trinidad-dbpool
-* Daemon, run Trinidad as a daemon: http://github.com/calavera/trinidad_daemon_extension
-* Hot deploy, do hot deploys monitorizing a temporal file, ala Passenger: http://github.com/calavera/trinidad_hotdeploy_extension
-* Sandbox, management console and REST api: http://github.com/calavera/trinidad_sandbox_extension
-* Logging, enhance the Trinidad's logging system: http://github.com/calavera/trinidad_logging_extension
-
-You can find further information on how to write your own extension in the wiki: http://wiki.github.com/calavera/trinidad/extensions
-
-== Copyright
-
-Copyright (c) 2010 David Calavera<calavera@apache.org>. See LICENSE for details.

data/bin/trinidad

@@ -1,9 +0,0 @@
-#!/usr/bin/env jruby
-
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-$:.unshift(File.dirname(__FILE__) + '/../trinidad-libs')
-
-require "trinidad"
-
-opts = Trinidad::CommandLineParser.parse(ARGV)
-Trinidad::Server.new(opts).start

data/spec/fixtures/trinidad_foo_extension.rb

@@ -1,23 +0,0 @@
-module Trinidad
-  module Extensions
-    class FooWebAppExtension < WebAppExtension
-      def configure(tomcat, app_context)
-        app_context.doc_base = 'foo_app_extension' if app_context
-      end
-    end
-
-    class FooServerExtension < ServerExtension
-      def configure(tomcat)
-        @options
-      end
-    end
-
-    class FooOptionsExtension < OptionsExtension
-      def configure(parser, default_options)
-        parser.on('--foo') do
-          default_options[:bar] = true
-        end
-      end
-    end
-  end
-end

data/spec/fixtures/trinidad_override_tomcat_extension.rb

@@ -1,11 +0,0 @@
-module Trinidad
-  module Extensions
-    class OverrideTomcatServerExtension < ServerExtension
-      def configure(tomcat)
-        Trinidad::Tomcat::Tomcat.new
-      end
-
-      def override_tomcat?; true; end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,21 +0,0 @@
-begin
-  require 'spec'
-rescue LoadError
-  require 'rubygems'
-  gem 'rspec'
-  require 'spec'
-end
-
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-$:.unshift(File.dirname(__FILE__) + '/../trinidad-libs')
-$:.unshift(File.dirname(__FILE__) + '/fixtures')
-
-require 'java'
-require 'trinidad'
-require 'mocha'
-
-Spec::Runner.configure do |config|
-  config.mock_with :mocha
-end
-
-MOCK_WEB_APP_DIR = File.join(File.dirname(__FILE__), 'web_app_mock')

data/spec/trinidad/command_line_parser_spec.rb

@@ -1,124 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/fakeapp'
-
-include FakeApp
-
-describe Trinidad::CommandLineParser do
-  subject { Trinidad::CommandLineParser }
-
-  it "overrides classes option" do
-    args = "--classes my_classes".split
-
-    options = subject.parse(args)
-    options[:classes_dir].should == 'my_classes'
-  end
-
-  it "overrides libs option with lib option" do
-    args = "--lib my_libs".split
-
-    options = subject.parse(args)
-    options[:libs_dir].should == 'my_libs'
-  end
-
-  it "overrides libs option with jar option" do
-    args = "--jars my_jars".split
-
-    options = subject.parse(args)
-    options[:libs_dir].should == 'my_jars'
-  end
-
-  it "uses config/trinidad.yml as the default configuration file name" do
-    FakeFS do
-      create_default_config_file
-      options = subject.parse(['-f'])
-
-      options[:config].should == 'config/trinidad.yml'
-      options[:port].should == 8080
-    end
-  end
-
-  it "overrides the config file when it's especified" do
-    FakeFS do
-      create_custom_config_file
-      args = "-f config/tomcat.yml".split
-
-      options = subject.parse(args)
-      options[:environment].should == 'production'
-    end
-  end
-
-  it "adds default ssl port to options" do
-    args = '--ssl'.split
-
-    options = subject.parse(args)
-    options[:ssl].should == {:port => 8443}
-  end
-
-  it "adds custom ssl port to options" do
-    args = '--ssl 8843'.split
-
-    options = subject.parse(args)
-    options[:ssl].should == {:port => 8843}
-  end
-
-  it "adds ajp connection with default port to options" do
-    args = '--ajp'.split
-
-    options = subject.parse(args)
-    options[:ajp].should == {:port => 8009}
-  end
-
-  it "adds ajp connection with coustom port to options" do
-    args = '--ajp 8099'.split
-
-    options = subject.parse(args)
-    options[:ajp].should == {:port => 8099}
-  end
-
-  it "merges ajp options from the config file" do
-    FakeFS do
-      create_custom_config_file
-      args = "--ajp 8099 -f config/tomcat.yml".split
-
-      options = subject.parse(args)
-      options[:ajp][:port].should == 8099
-      options[:ajp][:secure].should == true
-    end
-  end
-
-  it "uses default rackup file to configure the server" do
-    args = "--rackup".split
-    options = subject.parse(args)
-    options[:rackup].should == 'config.ru'
-  end
-
-  it "uses a custom rackup file if it's provided" do
-    args = "--rackup custom_config.ru".split
-    options = subject.parse(args)
-    options[:rackup].should == 'custom_config.ru'
-  end
-
-  it "uses a custom public directory" do
-    args = "--public web".split
-    options = subject.parse(args)
-    options[:public].should == 'web'
-  end
-
-  it "works on threadsafe mode using the shortcut" do
-    args = '--threadsafe'.split
-    options = subject.parse(args)
-    options[:jruby_min_runtimes].should == 1
-    options[:jruby_max_runtimes].should == 1
-  end
-
-  it "loads a given extension to add its options to the parser" do
-    args = "--load foo --foo".split
-    options = subject.parse(args)
-    options.has_key?(:bar).should be_true
-  end
-
-  it "adds the application directory path with the option --dir" do
-    args = "--dir #{MOCK_WEB_APP_DIR}".split
-    subject.parse(args)[:web_app_dir].should == MOCK_WEB_APP_DIR
-  end
-end

data/spec/trinidad/extensions_spec.rb

@@ -1,58 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require 'optparse'
-
-describe Trinidad::Extensions do
-
-  before(:each) do
-    @extensions = {:foo => {:bar => :bazz}}
-  end
-
-  it "configures the server with new stuff" do
-    lambda {Trinidad::Extensions.configure_server_extensions(@extensions, nil)}.should_not raise_error
-    lambda {Trinidad::Extensions.const_get(:FooServerExtension)}.should_not raise_error
-  end
-
-  it "configures the webapp with new stuff" do
-    lambda {Trinidad::Extensions.configure_webapp_extensions(@extensions, nil, nil)}.should_not raise_error
-    lambda {Trinidad::Extensions.const_get(:FooWebAppExtension)}.should_not raise_error
-  end
-
-  it "adds options to the command line parser" do
-    options = {}
-    parser = OptionParser.new
-    lambda {
-      Trinidad::Extensions.configure_options_extensions({:foo => {}}, parser, options)
-    }.should_not raise_error
-
-    lambda {
-      parser.parse! ['--foo']
-      options.has_key?(:bar).should be_true
-    }.should_not raise_error
-  end
-
-  it "allows to override the tomcat's instance" do
-    extensions = {:override_tomcat => {}}
-    tomcat = Trinidad::Tomcat::Tomcat.new
-
-    extended = Trinidad::Extensions.configure_server_extensions(extensions, tomcat)
-    extended.should_not equal(tomcat)
-  end
-
-  it "ignores extensions that don't exist for that scope" do
-    extensions = {:override_tomcat => {}}
-    tomcat = Trinidad::Tomcat::Tomcat.new
-
-    lambda {
-      Trinidad::Extensions.configure_webapp_extensions(extensions, tomcat, nil)
-    }.should_not raise_error
-  end
-
-  it "raises an error when the extension doesn't exist" do
-    extensions = {:foo_bar => {}}
-    tomcat = Trinidad::Tomcat::Tomcat.new
-
-    lambda {
-      Trinidad::Extensions.configure_webapp_extensions(extensions, tomcat, nil)
-    }.should raise_error
-  end
-end

data/spec/trinidad/fakeapp.rb

@@ -1,87 +0,0 @@
-require 'fakefs/safe'
-module FakeApp
-  def create_default_config_file
-    @default ||= config_file 'config/trinidad.yml', <<-EOF
----
-  port: 8080
-EOF
-  end
-
-  def create_custom_config_file
-    @custom ||= config_file 'config/tomcat.yml', <<-EOF
----
-  environment: production
-  ajp:
-    port: 8099
-    secure: true
-EOF
-  end
-
-  def create_rails_web_xml
-    @rails_web_xml ||= config_file 'config/web.xml', <<-EOF
-<?xml version="1.0" encoding="UTF-8"?>
-<web-app>
-    <servlet>
-        <servlet-name>RackServlet</servlet-name>
-        <servlet-class>org.jruby.rack.RackServlet</servlet-class>
-    </servlet>
-
-    <servlet-mapping>
-        <servlet-name>RackServlet</servlet-name>
-        <url-pattern>/*</url-pattern>
-    </servlet-mapping>
-
-    <listener>
-      <listener-class>org.jruby.rack.rails.RailsServletContextListener</listener-class>
-    </listener>
-
-</web-app>
-EOF
-  end
-
-  def create_rackup_web_xml
-    @rackup_web_xml ||= config_file 'config/web.xml', <<-EOF
-<?xml version="1.0" encoding="UTF-8"?>
-<web-app>
-    <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>
-
-    <servlet>
-        <servlet-name>RackServlet</servlet-name>
-        <servlet-class>org.jruby.rack.RackServlet</servlet-class>
-    </servlet>
-
-    <servlet-mapping>
-        <servlet-name>RackServlet</servlet-name>
-        <url-pattern>/*</url-pattern>
-    </servlet-mapping>
-
-    <listener>
-      <listener-class>org.jruby.rack.RackServletContextListener</listener-class>
-    </listener>
-
-</web-app>
-EOF
-  end
-
-  def create_rackup_file(path = 'config')
-    @rackup ||= config_file File.join(path, 'config.ru'), <<-EOF
-require 'rubygems'
-require 'sinatra'
-
-run App
-EOF
-  end
-
-  private 
-  def config_file(path, content)
-    File.open(path, 'w') {|io| io.write(content) }
-  end
-end

data/spec/trinidad/server_spec.rb

@@ -1,178 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-JSystem = java.lang.System
-JContext = javax.naming.Context
-
-describe Trinidad::Server do
-
-  it "always uses symbols as configuration keys" do
-    server = Trinidad::Server.new({'port' => 4000})
-    server.config[:port].should == 4000
-  end
-
-  it "enables catalina naming" do
-    Trinidad::Server.new
-    JSystem.get_property(JContext.URL_PKG_PREFIXES).should  include("org.apache.naming")
-    JSystem.get_property(JContext.INITIAL_CONTEXT_FACTORY).should == "org.apache.naming.java.javaURLContextFactory"
-    JSystem.get_property("catalina.useNaming").should == "true"
-  end
-
-  it "disables ssl when config param is nil" do
-    server = Trinidad::Server.new
-    server.ssl_enabled?.should be_false
-  end
-
-  it "disables ajp when config param is nil" do
-    server = Trinidad::Server.new
-    server.ajp_enabled?.should be_false
-  end
-
-  it "enables ssl when config param is a number" do
-    begin
-      server = Trinidad::Server.new({:ssl => {:port => 8443},
-        :web_app_dir => MOCK_WEB_APP_DIR})
-
-      server.ssl_enabled?.should be_true
-      File.exist?('ssl').should be_true
-    ensure
-      require 'fileutils'
-      FileUtils.rm_rf(File.expand_path('../../ssl', File.dirname(__FILE__)))
-    end
-  end
-
-  it "enables ajp when config param is a number" do
-    server = Trinidad::Server.new({:ajp => {:port => 8009}})
-
-    server.ajp_enabled?.should be_true
-  end
-
-  it "includes a connector with https scheme when ssl is enabled" do
-    server = Trinidad::Server.new({:ssl => {:port => 8443},
-      :web_app_dir => MOCK_WEB_APP_DIR})
-
-    connectors = server.tomcat.service.find_connectors
-    connectors.should have(1).connector
-    connectors[0].scheme.should == 'https'
-  end
-
-  it "includes a connector with protocol AJP when ajp is enabled" do
-    server = Trinidad::Server.new({:ajp => {:port => 8009}})
-
-    connectors = server.tomcat.service.find_connectors
-    connectors.should have(1).connector
-    connectors[0].protocol.should == 'AJP/1.3'
-  end
-
-  it "loads one application for each option present into :web_apps" do
-    server = Trinidad::Server.new({
-      :web_apps => {
-        :mock1 => {
-          :context_path => '/mock1',
-          :web_app_dir => MOCK_WEB_APP_DIR
-        },
-        :mock2 => {
-          :web_app_dir => MOCK_WEB_APP_DIR
-        },
-        :default => {
-          :web_app_dir => MOCK_WEB_APP_DIR
-        }
-      }
-    })
-
-    context_loaded = server.tomcat.host.find_children
-    context_loaded.should have(3).web_apps
-
-    expected = ['/mock1', '/mock2', '/']
-    context_loaded.each do |context|
-      expected.delete(context.path).should == context.path
-    end
-  end
-
-  it "loads the default application from the current directory if :web_apps is not present" do
-    server = Trinidad::Server.new({:web_app_dir => MOCK_WEB_APP_DIR})
-
-    default_context_should_be_loaded(server.tomcat.host.find_children)
-  end
-
-  it "removes default servlets from the application" do
-    server = Trinidad::Server.new({:web_app_dir => MOCK_WEB_APP_DIR})
-    app = server.tomcat.host.find_child('/')
-
-    app.find_child('default').should be_nil
-    app.find_child('jsp').should be_nil
-
-    app.find_servlet_mapping('*.jsp').should be_nil
-    app.find_servlet_mapping('*.jspx').should be_nil
-
-    app.process_tlds.should be_false
-  end
-
-  it "uses the default HttpConnector when http is not configured" do
-    server = Trinidad::Server.new({:web_app_dir => MOCK_WEB_APP_DIR})
-    server.http_configured?.should be_false
-
-    server.tomcat.connector.protocol_handler_class_name.should == 'org.apache.coyote.http11.Http11Protocol'
-  end
-
-  it "uses the NioConnector when the http configuration sets nio to true" do
-    server = Trinidad::Server.new({
-      :web_app_dir => MOCK_WEB_APP_DIR,
-      :http => {:nio => true}
-    })
-    server.http_configured?.should be_true
-
-    server.tomcat.connector.protocol_handler_class_name.should == 'org.apache.coyote.http11.Http11NioProtocol'
-  end
-
-  it "configures NioConnector with http option values" do
-    server = Trinidad::Server.new({
-      :web_app_dir => MOCK_WEB_APP_DIR,
-      :http => {
-        :nio => true,
-        'maxKeepAliveRequests' => 4,
-        'socket.bufferPool' => 1000
-      }
-    })
-    connector = server.tomcat.connector
-    connector.get_property('maxKeepAliveRequests').should == 4
-    connector.get_property('socket.bufferPool').should == '1000'
-  end
-
-  it "adds the WebAppLifecycleListener to each webapp" do
-    server = Trinidad::Server.new({:web_app_dir => MOCK_WEB_APP_DIR})
-    app_context = server.tomcat.host.find_child('/')    
-
-    app_context.find_lifecycle_listeners.map {|l| l.class.name }.should include('Trinidad::WebAppLifecycleListener')
-  end
-
-  it "loads application extensions from the root of the configuration" do
-    server = Trinidad::Server.new({
-      :web_app_dir => MOCK_WEB_APP_DIR,
-      :extensions => { :foo => {} }
-    })
-
-    app_context = server.tomcat.host.find_child('/')
-    app_context.doc_base.should == 'foo_app_extension'
-  end
-
-  it "doesn't create a default keystore when the option SSLCertificateFile is present in the ssl configuration options" do
-    require 'fileutils'
-    FileUtils.rm_rf 'ssl'
-
-    server = Trinidad::Server.new({
-      :ssl => {
-        :port => 8443,
-        :SSLCertificateFile => '/usr/local/ssl/server.crt'
-      },
-      :web_app_dir => MOCK_WEB_APP_DIR})
-
-    File.exist?('ssl').should be_false
-  end
-
-  def default_context_should_be_loaded(children)
-    children.should have(1).web_apps
-    children[0].doc_base.should == MOCK_WEB_APP_DIR
-    children[0].path.should == '/'
-    children[0]
-  end
-end

data/spec/trinidad/web_app_lifecycle_listener_spec.rb

@@ -1,179 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/fakeapp'
-
-include FakeApp
-
-# adding accessor for tests
-class Trinidad::WebAppLifecycleListener
-  attr_accessor :context
-end
-
-import org.apache.catalina.Lifecycle
-
-describe Trinidad::WebAppLifecycleListener do
-  before do
-    @mock = mock
-    @mock.stubs(:type).returns(Lifecycle::BEFORE_START_EVENT)
-    @mock.stubs(:lifecycle).returns(Trinidad::Tomcat::StandardContext.new)
-
-    @tomcat = Trinidad::Tomcat::Tomcat.new
-    @tomcat.host.app_base = Dir.pwd
-  end
-
-  it "ignores the event when it's not BEFORE_START_EVENT" do
-    listener = Trinidad::WebAppLifecycleListener.new(nil)
-    @mock.stubs(:type).returns(Lifecycle::BEFORE_STOP_EVENT)
-    lambda {
-      listener.lifecycleEvent(@mock)
-    }.should_not raise_error
-  end
-
-  it "tries to initialize the context when the event is BEFORE_START_EVENT" do
-    listener = Trinidad::WebAppLifecycleListener.new(nil)
-    lambda {
-      listener.lifecycleEvent(@mock)
-    }.should raise_error
-  end
-
-  it "doesn't load a default web xml when the deployment descriptor is not provided" do
-    listener = Trinidad::WebAppLifecycleListener.new(Trinidad::RailsWebApp.new({}, {}))
-    listener.configure_deployment_descriptor.should be_nil
-  end
-
-  it "loads a default web xml when the deployment descriptor is provided" do
-    FakeFS do
-      create_rails_web_xml
-
-      listener = Trinidad::WebAppLifecycleListener.new(Trinidad::RailsWebApp.new({}, {
-        :web_app_dir => Dir.pwd,
-        :default_web_xml => 'config/web.xml'
-      }))
-      listener.context = Trinidad::Tomcat::StandardContext.new
-
-      expected_xml = File.join(Dir.pwd, 'config/web.xml')
-      listener.configure_deployment_descriptor.should == expected_xml
-      listener.context.default_web_xml.should == expected_xml
-
-      listener.context.find_lifecycle_listeners.
-        map {|l| l.class.name }.should include('Java::OrgApacheCatalinaStartup::ContextConfig')
-    end
-  end
-
-  it "adds the rack servlet and the mapping for /*" do
-    listener = Trinidad::WebAppLifecycleListener.new(Trinidad::RailsWebApp.new({}, {}))
-    listener.context = Trinidad::Tomcat::StandardContext.new
-
-    listener.configure_rack_servlet
-
-    servlet = listener.context.find_child('RackServlet')
-    servlet.should_not be_nil
-    servlet.servlet_class.should == 'org.jruby.rack.RackServlet'
-
-    listener.context.find_servlet_mapping('/*').should == 'RackServlet'
-  end
-
-  it "configures the rack context listener from the web app" do
-    listener = Trinidad::WebAppLifecycleListener.new(Trinidad::RackupWebApp.new({}, {}))
-    listener.context = Trinidad::Tomcat::StandardContext.new
-    listener.configure_rack_listener
-
-    listener.context.find_application_listeners.should include('org.jruby.rack.RackServletContextListener')
-  end
-
-  it "adds context parameters from the web app" do
-    listener = Trinidad::WebAppLifecycleListener.new(Trinidad::RailsWebApp.new({}, {
-      :jruby_min_runtimes => 1
-    }))
-    listener.context = Trinidad::Tomcat::StandardContext.new
-    listener.configure_init_params
-
-    listener.context.find_parameter('jruby.min.runtimes').should == '1'
-  end
-
-  it "ignores parameters already present in the deployment descriptor" do
-    listener = Trinidad::WebAppLifecycleListener.new(Trinidad::RailsWebApp.new({}, {
-      :jruby_max_runtimes => 1,
-      :web_app_dir => MOCK_WEB_APP_DIR,
-      :default_web_xml => 'config/web.xml'
-    }))
-    listener.init_defaults(@tomcat.add_webapp('/', Dir.pwd))
-
-    listener.context.find_parameter('jruby.max.runtimes').should be_nil
-    listener.context.start
-    listener.context.find_parameter('jruby.max.runtimes').should == '8'
-  end
-
-  it "doesn't load classes into a jar when the libs directory is not present" do
-    web_app = Trinidad::RailsWebApp.new({}, {})
-
-    listener = Trinidad::WebAppLifecycleListener.new(web_app)
-    listener.add_application_jars(web_app.class_loader)
-
-    lambda {
-      web_app.class_loader.find_class('org.ho.yaml.Yaml')
-    }.should raise_error
-  end
-
-  it "loads classes into a jar when the libs directory is provided" do
-    web_app = Trinidad::RailsWebApp.new({}, {
-      :web_app_dir => MOCK_WEB_APP_DIR,
-      :libs_dir => 'lib'
-    })
-
-    listener = Trinidad::WebAppLifecycleListener.new(web_app)
-    listener.add_application_jars(web_app.class_loader)
-
-    lambda {
-      web_app.class_loader.find_class('org.ho.yaml.Yaml').should_not be_nil
-    }.should_not raise_error
-  end
-
-  it "doesn't load java classes when the classes directory is not present" do
-    web_app = Trinidad::RailsWebApp.new({}, {})
-
-    listener = Trinidad::WebAppLifecycleListener.new(web_app)
-    listener.add_application_java_classes(web_app.class_loader)
-
-    lambda {
-      web_app.class_loader.find_class('HelloTomcat')
-    }.should raise_error
-  end
-
-  it "loads java classes when the classes directory is provided" do
-    web_app = Trinidad::RailsWebApp.new({}, {
-      :web_app_dir => MOCK_WEB_APP_DIR,
-      :classes_dir => 'classes'
-    })
-
-    listener = Trinidad::WebAppLifecycleListener.new(web_app)
-    listener.add_application_java_classes(web_app.class_loader)
-
-    lambda {
-      web_app.class_loader.find_class('HelloTomcat').should_not be_nil
-    }.should_not raise_error
-  end
-
-  it "creates a WebappLoader with the JRuby class loader" do
-    web_app = Trinidad::RailsWebApp.new({}, {})
-
-    listener = Trinidad::WebAppLifecycleListener.new(web_app)
-    listener.context = Trinidad::Tomcat::StandardContext.new
-    listener.configure_context_loader
-
-    loader = listener.context.loader
-
-    loader.should be_instance_of(Java::OrgApacheCatalinaLoader::WebappLoader)
-  end
-
-  it "loads the default application from the current directory using the rackup file if :web_apps is not present" do
-    web_app = Trinidad::RackupWebApp.new({
-      :web_app_dir => MOCK_WEB_APP_DIR,
-      :rackup => 'config.ru'
-    }, {})
-    listener = Trinidad::WebAppLifecycleListener.new(web_app)
-    listener.context = Trinidad::Tomcat::StandardContext.new
-    listener.configure_init_params
-
-    listener.context.find_parameter('rackup.path').should == "config.ru"
-  end
-end

data/spec/trinidad/web_app_spec.rb

@@ -1,175 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/fakeapp'
-
-include FakeApp
-
-describe Trinidad::WebApp do
-  it "creates a RailsWebApp if rackup option is not present" do
-    app = Trinidad::WebApp.create({}, {})
-    app.should be_an_instance_of(Trinidad::RailsWebApp)
-  end
-
-  it "creates a RackupWebApp if rackup option is present" do
-    app = Trinidad::WebApp.create({}, {:rackup => 'config.ru'})
-    app.should be_an_instance_of(Trinidad::RackupWebApp)
-  end
-
-  it "ignores rack_servlet when a deployment descriptor already provides it" do
-    FakeFS do
-      create_rails_web_xml
-
-      app = Trinidad::WebApp.create({}, {
-        :web_app_dir => Dir.pwd,
-        :default_web_xml => 'config/web.xml'
-      })
-      app.servlet.should be_nil
-    end
-  end
-
-  it "ignores rack_listener when a deployment descriptor already provides it" do
-    FakeFS do
-      create_rails_web_xml
-
-      app = Trinidad::WebApp.create({}, {
-        :web_app_dir => Dir.pwd,
-        :default_web_xml => 'config/web.xml'
-      })
-      app.rack_listener.should be_nil
-    end
-  end
-
-  it "uses rack_servlet as the default servlet when a deployment descriptor is not provided" do
-    app = Trinidad::WebApp.create({}, {})
-    app.servlet.should_not be_nil
-    app.servlet[:name].should == 'RackServlet'
-    app.servlet[:class].should == 'org.jruby.rack.RackServlet'
-  end
-
-  it "uses rack_listener as the default listener when a deployment descriptor is not provided" do
-    app = Trinidad::WebApp.create({}, {})
-    app.rack_listener.should == 'org.jruby.rack.rails.RailsServletContextListener'
-  end
-
-  it "loads the context parameters from the configuration when a deployment descriptor is not provided" do
-    app = Trinidad::WebApp.create({}, {
-      :jruby_min_runtimes => 1,
-      :jruby_max_runtimes => 1,
-      :public => 'foo',
-      :environment => :production
-    })
-    parameters = app.init_params
-    parameters['jruby.min.runtimes'].should == '1'
-    parameters['jruby.initial.runtimes'].should == '1'
-    parameters['jruby.max.runtimes'].should == '1'
-    parameters['public.root'].should == '/foo'
-    parameters['rails.env'].should == 'production'
-    parameters['rails.root'].should == '/'
-  end
-
-  it "adds the rackup script as a context parameter when it's provided" do
-    FakeFS do
-      create_rackup_file
-      app = Trinidad::WebApp.create({}, {
-        :web_app_dir => Dir.pwd,
-        :rackup => 'config/config.ru'
-      })
-
-      parameters = app.init_params
-      parameters['rackup.path'].should == 'config/config.ru'
-    end
-  end
-
-  it "ignores parameters from configuration when the deployment descriptor already contains them" do
-    FakeFS do
-      create_rackup_web_xml
-
-      app = Trinidad::WebApp.create({}, {
-        :web_app_dir => Dir.pwd,
-        :default_web_xml => 'config/web.xml',
-        :jruby_min_runtimes => 2,
-        :jruby_max_runtimes => 5
-      })
-      parameters = app.init_params
-
-      parameters['jruby.min.runtimes'].should be_nil
-      parameters['jruby.max.runtimes'].should be_nil
-    end
-  end
-
-  it "ignores the deployment descriptor when it doesn't exist" do
-    app = Trinidad::WebApp.create({}, {
-      :web_app_dir => Dir.pwd,
-      :default_web_xml => 'config/web.xml'
-    })
-    app.default_deployment_descriptor.should be_nil
-  end
-
-  it "doesn't load any web.xml when the deployment descriptor doesn't exist" do
-    app = Trinidad::WebApp.create({}, {
-      :web_app_dir => Dir.pwd,
-      :default_web_xml => 'config/web.xml'
-    })
-    app.rack_servlet_configured?.should be_false
-    app.rack_listener_configured?.should be_false
-  end
-
-  it "uses `public` as default public root directory" do
-    app = Trinidad::WebApp.create({}, {})
-    app.public_root.should == 'public'
-  end
-
-  it "uses extensions from the global configuration" do
-    config = { :extensions => {:hotdeploy => {}} }
-    app = Trinidad::WebApp.create(config, {})
-    app.extensions.should include(:hotdeploy)
-  end
-
-  it "overrides global extensions with application extensions" do
-    config = { :extensions => {:hotdeploy => {}} }
-    app_config = { :extensions => {:hotdeploy => {:delay => 30000}} }
-    app = Trinidad::WebApp.create(config, app_config)
-    app.extensions[:hotdeploy].should include(:delay)
-  end
-
-  it "creates a rackup application when the rackup file is under WEB-INF directory" do
-    FakeFS do
-      create_rackup_file('WEB-INF')
-      app = Trinidad::WebApp.create({}, {})
-
-      app.should be_an_instance_of(Trinidad::RackupWebApp)
-    end
-  end
-
-  it "doesn't add the rackup init parameter when the rackup file is under WEB-INF directory" do
-    FakeFS do
-      create_rackup_file('WEB-INF')
-      app = Trinidad::WebApp.create({}, {})
-
-      app.init_params.should_not include('rackup.path')
-    end
-  end
-
-  it "loads rackup file from a given directory" do
-    FakeFS do
-      create_rackup_file('rack')
-      app = Trinidad::WebApp.create({}, {
-        :web_app_dir => Dir.pwd,
-        :rackup => 'rack'
-      })
-      app.init_params.should include('rackup.path')
-      app.init_params['rackup.path'].should == 'rack/config.ru'
-    end
-  end
-
-  it "allows to configure the servlet from the configuration options" do
-    app = Trinidad::WebApp.create({}, {
-      :servlet => {
-        :class => 'org.jruby.trinidad.FakeServlet',
-        :name => 'FakeServlet'
-      }
-    })
-
-    app.servlet[:class].should == 'org.jruby.trinidad.FakeServlet'
-    app.servlet[:name].should == 'FakeServlet'
-  end
-end