warbler 0.9.14 → 1.0

data/spec/warbler/war_spec.rb

@@ -0,0 +1,425 @@
+#--
+# Copyright (c) 2010 Engine Yard, Inc.
+# This source code is available under the MIT license.
+# See the file LICENSE.txt for details.
+#++
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Warbler::War do
+  before(:each) do
+    @rake = Rake::Application.new
+    Rake.application = @rake
+    verbose(false)
+    @pwd = Dir.getwd
+    Dir.chdir("spec/sample")
+    mkdir_p "log"
+    touch "log/test.log"
+    @config = Warbler::Config.new do |config|
+      config.war_name = "warbler"
+      config.gems = ["rake"]
+      config.webxml.jruby.max.runtimes = 5
+    end
+    @war = Warbler::War.new
+  end
+
+  after(:each) do
+    rm_rf "log"
+    rm_rf ".bundle"
+    rm_f FileList["*.war", "config.ru", "*web.xml*", "config/web.xml*",
+                  "config/warble.rb", "file.txt", 'manifest', 'Gemfile*']
+    Dir.chdir(@pwd)
+  end
+
+  def file_list(regex)
+    @war.files.keys.select {|f| f =~ regex }
+  end
+
+  it "should collect files in public" do
+    @war.apply(@config)
+    file_list(%r{^index\.html}).should_not be_empty
+  end
+
+  it "should collect gem files" do
+    @config.gems << "rake"
+    @war.apply(@config)
+    file_list(%r{WEB-INF/gems/gems/rake.*/lib/rake.rb}).should_not be_empty
+    file_list(%r{WEB-INF/gems/specifications/rake.*\.gemspec}).should_not be_empty
+  end
+
+  it "should not include log files by default" do
+    @war.apply(@config)
+    file_list(%r{WEB-INF/log}).should_not be_empty
+    file_list(%r{WEB-INF/log/.*\.log}).should be_empty
+  end
+
+  def expand_webxml
+    @war.apply(@config)
+    @war.files.should include("WEB-INF/web.xml")
+    require 'rexml/document'
+    REXML::Document.new(@war.files["WEB-INF/web.xml"]).root.elements
+  end
+
+  it "should create a web.xml file" do
+    elements = expand_webxml
+    elements.to_a(
+      "context-param/param-name[text()='jruby.max.runtimes']"
+      ).should_not be_empty
+    elements.to_a(
+      "context-param/param-name[text()='jruby.max.runtimes']/../param-value"
+      ).first.text.should == "5"
+  end
+
+  it "should include custom context parameters in web.xml" do
+    @config.webxml.some.custom.config = "myconfig"
+    elements = expand_webxml
+    elements.to_a(
+      "context-param/param-name[text()='some.custom.config']"
+      ).should_not be_empty
+    elements.to_a(
+      "context-param/param-name[text()='some.custom.config']/../param-value"
+      ).first.text.should == "myconfig"
+  end
+
+  it "should allow one jndi resource to be included" do
+    @config.webxml.jndi = 'jndi/rails'
+    elements = expand_webxml
+    elements.to_a(
+      "resource-ref/res-ref-name[text()='jndi/rails']"
+      ).should_not be_empty
+  end
+
+  it "should allow multiple jndi resources to be included" do
+    @config.webxml.jndi = ['jndi/rails1', 'jndi/rails2']
+    elements = expand_webxml
+    elements.to_a(
+      "resource-ref/res-ref-name[text()='jndi/rails1']"
+      ).should_not be_empty
+    elements.to_a(
+      "resource-ref/res-ref-name[text()='jndi/rails2']"
+      ).should_not be_empty
+  end
+
+  it "should not include any ignored context parameters" do
+    @config.webxml.foo = "bar"
+    @config.webxml.ignored << "foo"
+    elements = expand_webxml
+    elements.to_a(
+      "context-param/param-name[text()='foo']"
+      ).should be_empty
+    elements.to_a(
+      "context-param/param-name[text()='ignored']"
+      ).should be_empty
+    elements.to_a(
+      "context-param/param-name[text()='jndi']"
+      ).should be_empty
+  end
+
+  it "should use a config/web.xml if it exists" do
+    mkdir_p "config"
+    touch "config/web.xml"
+    @war.apply(Warbler::Config.new)
+    @war.files["WEB-INF/web.xml"].should == "config/web.xml"
+  end
+
+  it "should use a config/web.xml.erb if it exists" do
+    mkdir_p "config"
+    File.open("config/web.xml.erb", "w") {|f| f << "Hi <%= webxml.public.root %>" }
+    @war.apply(Warbler::Config.new)
+    @war.files["WEB-INF/web.xml"].should_not be_nil
+    @war.files["WEB-INF/web.xml"].read.should == "Hi /"
+  end
+
+  it "should collect java libraries" do
+    @war.apply(@config)
+    file_list(%r{WEB-INF/lib/jruby-.*\.jar$}).should_not be_empty
+  end
+
+  it "should collect application files" do
+    @war.apply(@config)
+    file_list(%r{WEB-INF/app$}).should_not be_empty
+    file_list(%r{WEB-INF/config$}).should_not be_empty
+    file_list(%r{WEB-INF/lib$}).should_not be_empty
+  end
+
+  it "should accept an autodeploy directory where the war should be created" do
+    require 'tmpdir'
+    @config.autodeploy_dir = Dir::tmpdir
+    touch "file.txt"
+    @war.files["file.txt"] = "file.txt"
+    silence { @war.create(@config) }
+    File.exist?(File.join("#{Dir::tmpdir}","warbler.war")).should == true
+  end
+
+  it "should accept a custom manifest file" do
+    touch 'manifest'
+    @config.manifest_file = 'manifest'
+    @war.apply(@config)
+    @war.files['META-INF/MANIFEST.MF'].should == "manifest"
+  end
+
+  it "should be able to exclude files from the .war" do
+    @config.excludes += FileList['lib/tasks/utils.rake']
+    @war.apply(@config)
+    file_list(%r{lib/tasks/utils.rake}).should be_empty
+  end
+
+  it "should read configuration from #{Warbler::Config::FILE}" do
+    mkdir_p "config"
+    File.open(Warbler::Config::FILE, "w") do |dest|
+      contents =
+        File.open("#{Warbler::WARBLER_HOME}/warble.rb") do |src|
+          src.read
+        end
+      dest << contents.sub(/# config\.war_name/, 'config.war_name'
+        ).sub(/# config.gems << "tzinfo"/, 'config.gems = []')
+    end
+    t = Warbler::Task.new "warble"
+    t.config.war_name.should == "mywar"
+  end
+
+  it "should fail if a gem is requested that is not installed" do
+    @config.gems = ["nonexistent-gem"]
+    lambda {
+      Warbler::Task.new "warble", @config
+      @war.apply(@config)
+    }.should raise_error
+  end
+
+  it "should allow specification of dependency by Gem::Dependency" do
+    spec = mock "gem spec"
+    spec.stub!(:full_name).and_return "hpricot-0.6.157"
+    spec.stub!(:full_gem_path).and_return "hpricot-0.6.157"
+    spec.stub!(:loaded_from).and_return "hpricot.gemspec"
+    spec.stub!(:files).and_return ["Rakefile"]
+    spec.stub!(:dependencies).and_return []
+    Gem.source_index.should_receive(:search).and_return do |gem|
+      gem.name.should == "hpricot"
+      [spec]
+    end
+    @config.gems = [Gem::Dependency.new("hpricot", "> 0.6")]
+    @war.apply(@config)
+  end
+
+  it "should copy loose java classes to WEB-INF/classes" do
+    @config.java_classes = FileList["Rakefile"]
+    @war.apply(@config)
+    file_list(%r{WEB-INF/classes/Rakefile$}).should_not be_empty
+  end
+
+  def mock_rails_module
+    rails = Module.new
+    Object.const_set("Rails", rails)
+    version = Module.new
+    rails.const_set("VERSION", version)
+    version.const_set("STRING", "2.1.0")
+    rails
+  end
+
+  def mock_merb_module
+    merb = Module.new
+    silence { Object.const_set("Merb", merb) }
+    boot_loader = Module.new
+    merb.const_set("BootLoader", boot_loader)
+    merb.const_set("VERSION", "1.0")
+    dependencies = Class.new do
+      @@dependencies = []
+      def self.dependencies
+        @@dependencies
+      end
+      def self.dependencies=(deps)
+        @@dependencies = deps
+      end
+    end
+    boot_loader.const_set("Dependencies", dependencies)
+    dependencies
+  end
+
+  it "should auto-detect a Rails application" do
+    task :environment do
+      mock_rails_module
+    end
+    @config = Warbler::Config.new
+    @config.webxml.booter.should == :rails
+    @config.gems["rails"].should == "2.1.0"
+  end
+
+  it "should provide Rails gems by default, unless vendor/rails is present" do
+    rails = nil
+    task :environment do
+      rails = mock_rails_module
+    end
+
+    config = Warbler::Config.new
+    config.gems.should have_key("rails")
+
+    mkdir_p "vendor/rails"
+    config = Warbler::Config.new
+    config.gems.should be_empty
+
+    rm_rf "vendor/rails"
+    rails.stub!(:vendor_rails?).and_return true
+    config = Warbler::Config.new
+    config.gems.should be_empty
+  end
+
+  it "should not try to autodetect frameworks when Warbler.framework_detection is false" do
+    begin
+      Warbler.framework_detection = false
+      task :environment
+      config = Warbler::Config.new
+      config.webxml.booter.should_not == :rails
+      t = Rake::Task['environment']
+      class << t; public :instance_variable_get; end
+      t.instance_variable_get("@already_invoked").should == false
+    ensure
+      Warbler.framework_detection = true
+    end
+  end
+
+  it "should auto-detect a Merb application" do
+    task :merb_env do
+      mock_merb_module
+    end
+    @config = Warbler::Config.new
+    @config.webxml.booter.should == :merb
+    @config.gems.keys.should_not include("rails")
+  end
+
+  it "should auto-detect a Rack application with a config.ru file" do
+    rackup = "run Proc.new {|env| [200, {}, ['Hello World']]}"
+    File.open("config.ru", "w") {|f| f << rackup }
+    @config = Warbler::Config.new
+    @config.webxml.booter.should == :rack
+    @config.webxml.rackup.should == rackup
+  end
+
+  it "should automatically add Rails.configuration.gems to the list of gems" do
+    task :environment do
+      rails = mock_rails_module
+      config = mock "config"
+      rails.stub!(:configuration).and_return(config)
+      gem = mock "gem"
+      gem.stub!(:name).and_return "hpricot"
+      gem.stub!(:requirement).and_return Gem::Requirement.new("=0.6")
+      config.stub!(:gems).and_return [gem]
+    end
+
+    @config = Warbler::Config.new
+    @config.webxml.booter.should == :rails
+    @config.gems.keys.should include(Gem::Dependency.new("hpricot", Gem::Requirement.new("=0.6")))
+  end
+
+  it "should automatically add Merb::BootLoader::Dependencies.dependencies to the list of gems" do
+    task :merb_env do
+      deps = mock_merb_module
+      deps.dependencies = [Gem::Dependency.new("merb-core", ">= 1.0.6.1")]
+    end
+    @config = Warbler::Config.new
+    @config.webxml.booter.should == :merb
+    @config.gems.keys.should include(Gem::Dependency.new("merb-core", ">= 1.0.6.1"))
+  end
+
+  it "should skip Merb development dependencies" do
+    task :merb_env do
+      deps = mock_merb_module
+      deps.dependencies = [Gem::Dependency.new("rake", "= #{RAKEVERSION}", :development)]
+    end
+    @war.apply(Warbler::Config.new)
+    file_list(/rake-#{RAKEVERSION}/).should be_empty
+  end
+
+  it "should warn about using Merb < 1.0" do
+    task :merb_env do
+      silence { Object.const_set("Merb", Module.new) }
+    end
+    @config = silence { Warbler::Config.new }
+    @config.webxml.booter.should == :merb
+  end
+
+  it "should set the jruby max runtimes to 1 when MT Rails is detected" do
+    task :environment do
+      rails = mock_rails_module
+      config = mock "config"
+      rails.stub!(:configuration).and_return(config)
+      config.stub!(:threadsafe!)
+      config.should_receive(:allow_concurrency).and_return true
+      config.should_receive(:preload_frameworks).and_return true
+    end
+    @config = Warbler::Config.new
+    @config.webxml.booter.should == :rails
+    @config.webxml.jruby.max.runtimes.should == 1
+  end
+
+  it "should skip directories that don't exist in config.dirs and print a warning" do
+    @config.dirs = %w(lib notexist)
+    silence { @war.apply(@config) }
+    file_list(%r{WEB-INF/lib}).should_not be_empty
+    file_list(%r{WEB-INF/notexist}).should be_empty
+  end
+
+  it "should write gems to location specified by gem_path" do
+    @config = Warbler::Config.new {|c| c.gem_path = "/WEB-INF/jewels"; c.gems << 'rake' }
+    elements = expand_webxml
+    file_list(%r{WEB-INF/jewels}).should_not be_empty
+    elements.to_a(
+      "context-param/param-name[text()='gem.path']"
+      ).should_not be_empty
+    elements.to_a(
+      "context-param/param-name[text()='gem.path']/../param-value"
+      ).first.text.should == "/WEB-INF/jewels"
+
+  end
+
+  it "should detect a Bundler Gemfile and process only its gems" do
+    File.open("Gemfile", "w") {|f| f << "gem 'rspec'"}
+    @war.apply(Warbler::Config.new {|c| c.gems << "rake"})
+    file_list(%r{WEB-INF/Gemfile}).should_not be_empty
+    file_list(%r{WEB-INF/gems/specifications/rspec}).should_not be_empty
+    file_list(%r{WEB-INF/gems/specifications/rake}).should be_empty
+  end
+
+  it "should write a Bundler environment file into the war" do
+    File.open("Gemfile", "w") {|f| f << "gem 'rspec'"}
+    @war.apply(Warbler::Config.new)
+    file_list(%r{WEB-INF/\.bundle/environment\.rb}).should_not be_empty
+  end
+
+  it "should allow overriding of the gem path when using Bundler" do
+    File.open("Gemfile", "w") {|f| f << "gem 'rspec'"}
+    @war.apply(Warbler::Config.new {|c| c.gem_path = '/WEB-INF/jewels' })
+    file_list(%r{WEB-INF/jewels/specifications/rspec}).should_not be_empty
+    IO.readlines(".bundle/war-environment.rb").grep(/rspec/).last.should =~ %r{jewels/specifications}m
+  end
+
+  it "should not let the framework load Bundler from the locked environment" do
+    task :environment do
+      File.exist?('.bundle/environment.rb').should_not be_true
+      mock_rails_module
+    end
+
+    File.open("Gemfile", "w") {|f| f << "gem 'rspec'"}
+    `ruby -S bundle lock`
+    File.exist?('.bundle/environment.rb').should be_true
+    @war.apply(Warbler::Config.new)
+    hash = eval("[" + IO.readlines(".bundle/environment.rb").grep(/rspec/).last + "]").first
+    hash[:load_paths].each {|p| File.exist?(p).should be_true }
+  end
+
+  it "should allow adding additional WEB-INF files via config.webinf_files" do
+    File.open("myserver-web.xml", "w") do |f|
+      f << "<web-app></web-app>"
+    end
+    @war.apply(Warbler::Config.new {|c| c.webinf_files = FileList['myserver-web.xml'] })
+    file_list(%r{WEB-INF/myserver-web.xml}).should_not be_empty
+  end
+
+  it "should allow expanding of additional WEB-INF files via config.webinf_files" do
+    File.open("myserver-web.xml.erb", "w") do |f|
+      f << "<web-app><%= webxml.rails.env %></web-app>"
+    end
+    @war.apply(Warbler::Config.new {|c| c.webinf_files = FileList['myserver-web.xml.erb'] })
+    file_list(%r{WEB-INF/myserver-web.xml}).should_not be_empty
+    @war.files['WEB-INF/myserver-web.xml'].read.should =~ /web-app.*production/
+  end
+end

data/{generators/warble/templates/warble.rb → warble.rb}

@@ -3,9 +3,6 @@
 
 # Warbler web application assembly configuration file
 Warbler::Config.new do |config|
-  # Temporary directory where the application is staged
-  # config.staging_dir = "tmp/war"
-
   # Application directories to be included in the webapp.
   config.dirs = %w(app config lib log vendor tmp)
 
@@ -30,9 +27,28 @@ Warbler::Config.new do |config|
   # for details of how to specify a pathmap.
   # config.pathmaps.java_classes << "%{target/classes/,}p"
 
-  # Gems to be included. You need to tell Warbler which gems your application needs
-  # so that they can be packaged in the war file.
-  # The Rails gems are included by default unless the vendor/rails directory is present.
+  # Path to the pre-bundled gem directory inside the war file. Default
+  # is 'WEB-INF/gems'. Specify path if gems are already bundled
+  # before running Warbler. This also sets 'gem.path' inside web.xml.
+  # config.gem_path = "WEB-INF/vendor/bundler_gems"
+
+  # Bundler support is built-in. If Warbler finds a Gemfile in the
+  # project directory, it will be used to collect the gems to bundle
+  # in your application. If you wish to explicitly disable this
+  # functionality, uncomment here.
+  # config.bundler = false
+
+  # Files for WEB-INF directory (next to web.xml). This contains
+  # web.xml by default. If there is an .erb-File it will be processed
+  # with webxml-config. You may want to exclude this file via
+  # config.excludes.
+  # config.webinf_files += FileList["jboss-web.xml"]
+
+  # Other gems to be included. You need to tell Warbler which gems
+  # your application needs so that they can be packaged in the war
+  # file.
+  # The Rails gems are included by default unless the vendor/rails
+  # directory is present.
   # config.gems += ["activerecord-jdbcmysql-adapter", "jruby-openssl"]
   # config.gems << "tzinfo"
 
@@ -48,8 +64,9 @@ Warbler::Config.new do |config|
   # config.gems << /^merb-/
   # config.gems << Gem::Dependency.new("merb-core", "= 0.9.3")
 
-  # Include gem dependencies not mentioned specifically
-  config.gem_dependencies = true
+  # Include gem dependencies not mentioned specifically. Default is true, uncomment
+  # to turn off.
+  # config.gem_dependencies = false
 
   # Files to be included in the root of the webapp.  Note that files in public
   # will have the leading 'public/' part of the path stripped during staging.
@@ -58,6 +75,9 @@ Warbler::Config.new do |config|
   # Pathmaps for controlling how public HTML files are copied into the .war
   # config.pathmaps.public_html = ["%{public/,}p"]
 
+  # Pathmaps for controlling how application files are copied into the .war
+  # config.pathmaps.application = ["WEB-INF/%p"]
+
   # Name of the war file (without the .war) -- defaults to the basename
   # of RAILS_ROOT
   # config.war_name = "mywar"
@@ -69,7 +89,7 @@ Warbler::Config.new do |config|
   # Value of RAILS_ENV for the webapp -- default as shown below
   # config.webxml.rails.env = ENV['RAILS_ENV'] || 'production'
 
-  # Application booter to use, one of :rack, :rails, or :merb. (Default :rails)
+  # Application booter to use, one of :rack, :rails, or :merb (autodetected by default)
   # config.webxml.booter = :rails
 
   # When using the :rack booter, "Rackup" script to use.