trinidad 0.9.6 → 0.9.7

data/History.txt

@@ -1,3 +1,11 @@
+== 0.9.7 (2010-09-27)
+
+* add option --adress to set the Trinidad's host
+
+== Trinidad_jars 0.3.2 (2010-09-26)
+
+* fix TRINIDAD-21: trinidad_jars 0.3.1 breaks logging extension
+
 == 0.9.6 (2010-09-12)
 
 * add option to specify the application directory path from the command line

data/README.rdoc

@@ -2,7 +2,8 @@
 
 Trinidad allows you to run a rails or rackup applications within an embedded Apache Tomcat container.
 
-This project was initially called "Tomcat-rails" but due to legal issues with the ASF and the Tomcat trademark it has been renamed.
+Mail list: http://groups.google.com/group/rails-trinidad
+Bug tracker: http://github.com/calavera/trinidad/issues
 
 == INSTALL:
 

data/lib/trinidad.rb

@@ -22,5 +22,5 @@ require 'trinidad/rackup_web_app'
 
 
 module Trinidad
-  VERSION = File.read(File.expand_path('../../VERSION', __FILE__)).chomp
+  VERSION = '0.9.7'
 end

data/lib/trinidad/command_line_parser.rb

@@ -111,6 +111,10 @@ module Trinidad
           default_options[:jruby_max_runtimes] = 1
         end
 
+        opts.on('--address', '--address ADDRESS', 'Trinidad host address', 'default: localhost') do |v|
+          default_options[:address] = v
+        end
+
         opts.on('-v', '--version', 'display the current version') do
           puts "trinidad #{Trinidad::VERSION} (tomcat #{Trinidad::TOMCAT_VERSION})"
           exit

data/lib/trinidad/server.rb

@@ -31,6 +31,7 @@ module Trinidad
 
     def load_tomcat_server
       @tomcat = Trinidad::Tomcat::Tomcat.new
+      @tomcat.hostname = @config[:address] || 'localhost'
       @tomcat.port = @config[:port].to_i
       @tomcat.base_dir = Dir.pwd
       @tomcat.host.app_base = Dir.pwd

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: trinidad
 version: !ruby/object:Gem::Version 
-  hash: 55
+  hash: 53
   prerelease: false
   segments: 
   - 0
   - 9
-  - 6
-  version: 0.9.6
+  - 7
+  version: 0.9.7
 platform: ruby
 authors: 
 - David Calavera
@@ -15,22 +15,23 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-12 00:00:00 +02:00
+date: 2010-09-26 00:00:00 +02:00
 default_executable: trinidad
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rack
+  name: trinidad_jars
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 15
+        hash: 19
         segments: 
-        - 1
         - 0
-        version: "1.0"
+        - 3
+        - 0
+        version: 0.3.0
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -49,26 +50,10 @@ dependencies:
         version: 1.0.2
   type: :runtime
   version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: trinidad_jars
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 19
-        segments: 
-        - 0
-        - 3
-        - 0
-        version: 0.3.0
-  type: :runtime
-  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: rspec
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -78,11 +63,11 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id004
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: mocha
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -92,11 +77,11 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id005
+  version_requirements: *id004
 - !ruby/object:Gem::Dependency 
   name: fakefs
   prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -106,23 +91,22 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id006
-description: 
+  version_requirements: *id005
+description: Trinidad allows you to run a rails or rackup applications within an embedded Apache Tomcat container
 email: calavera@apache.org
 executables: 
 - trinidad
 extensions: []
 
 extra_rdoc_files: 
-- LICENSE
 - README.rdoc
+- LICENSE
 files: 
+- bin/trinidad
+- lib/trinidad.rb
 - History.txt
 - LICENSE
 - README.rdoc
-- VERSION
-- bin/trinidad
-- lib/trinidad.rb
 - lib/trinidad/command_line_parser.rb
 - lib/trinidad/core_ext.rb
 - lib/trinidad/extensions.rb
@@ -131,17 +115,8 @@ files:
 - lib/trinidad/server.rb
 - lib/trinidad/web_app.rb
 - lib/trinidad/web_app_lifecycle_listener.rb
-- spec/fixtures/trinidad_foo_extension.rb
-- spec/fixtures/trinidad_override_tomcat_extension.rb
-- spec/spec_helper.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
 has_rdoc: true
-homepage: http://calavera.github.com/trinidad
+homepage: http://github.com/calavera/trinidad
 licenses: []
 
 post_install_message: 
@@ -172,15 +147,7 @@ requirements: []
 rubyforge_project: trinidad
 rubygems_version: 1.3.7
 signing_key: 
-specification_version: 3
+specification_version: 2
 summary: Simple library to run rails applications into an embedded Tomcat
-test_files: 
-- spec/fixtures/trinidad_foo_extension.rb
-- spec/fixtures/trinidad_override_tomcat_extension.rb
-- spec/spec_helper.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
+test_files: []
+

data/VERSION

@@ -1 +0,0 @@
-0.9.6

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