warbler 0.9.14 → 1.0

data/ext/WarblerWarService.java

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2010 Engine Yard, Inc.
+ * This source code is available under the MIT license.
+ * See the file LICENSE.txt for details.
+ */
+
+import java.io.IOException;
+import org.jruby.Ruby;
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class WarblerWarService implements BasicLibraryService {
+    public boolean basicLoad(final Ruby runtime) throws IOException {
+        WarblerWar.create(runtime);
+        return true;
+    }
+}
+

data/lib/warbler.rb

@@ -1,16 +1,32 @@
 #--
-# (c) Copyright 2007-2008 Sun Microsystems, Inc.
-# See the file LICENSES.txt included with the distribution for
-# software license details.
+# 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.
 #++
 
 # Warbler is a lightweight, flexible, Rake-based system for packaging your Rails apps
 # into .war files.
 module Warbler
   WARBLER_HOME = File.expand_path(File.dirname(__FILE__) + '/..') unless defined?(WARBLER_HOME)
+
+  class << self
+    attr_accessor :application
+    attr_accessor :framework_detection
+    attr_writer :project_application
+  end
+
+  def self.project_application
+    application.load_project_rakefile if application
+    @project_application || Rake.application
+  end
+  self.framework_detection = true
 end
 
 require 'warbler/gems'
 require 'warbler/config'
+require 'warbler/war'
 require 'warbler/task'
-require 'warbler/version'
+require 'warbler/application'
+require 'warbler/runtime'
+require 'warbler/version'

data/lib/warbler/application.rb

@@ -0,0 +1,63 @@
+#--
+# 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.
+#++
+
+require 'rake'
+
+class Warbler::Application < Rake::Application
+  def initialize
+    super
+    Warbler.application = self
+    @project_loaded = false
+  end
+
+  def load_rakefile
+    @name = 'warble'
+
+    # Load the main warbler tasks
+    Warbler::Task.new
+
+    task :default => :war
+
+    desc "Generate a configuration file to customize your war assembly"
+    task :config do
+      if File.exists?(Warbler::Config::FILE) && ENV["FORCE"].nil?
+        puts "There's another bird sitting on my favorite branch"
+        puts "(file '#{Warbler::Config::FILE}' already exists. Pass argument FORCE=1 to override)"
+      elsif !File.directory?("config")
+        puts "I'm confused; my favorite branch is missing"
+        puts "(directory 'config' is missing)"
+      else
+        cp "#{Warbler::WARBLER_HOME}/warble.rb", Warbler::Config::FILE
+      end
+    end
+
+    desc "Display version of warbler"
+    task :version do
+      puts "Warbler version #{Warbler::VERSION}"
+    end
+  end
+
+  def load_project_rakefile
+    return if @project_loaded
+    # Load any application rakefiles to aid in autodetecting applications
+    app = Warbler.project_application = Rake::Application.new
+    Rake.application = app
+    Rake::Application::DEFAULT_RAKEFILES.each do |rf|
+      if File.exist?(rf)
+        load rf
+        break
+      end
+    end
+    Rake.application = self
+    @project_loaded = true
+  end
+
+  def run
+    Rake.application = self
+    super
+  end
+end

data/lib/warbler/config.rb

@@ -1,7 +1,8 @@
 #--
-# (c) Copyright 2007-2009 Sun Microsystems, Inc.
-# See the file LICENSES.txt included with the distribution for
-# software license details.
+# 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.
 #++
 
 require 'ostruct'
@@ -11,11 +12,20 @@ module Warbler
   class Config
     TOP_DIRS = %w(app config lib log vendor)
     FILE = "config/warble.rb"
+    DEFAULT_GEM_PATH = '/WEB-INF/gems'
     BUILD_GEMS = %w(warbler rake rcov)
 
-    # Directory where files will be staged, defaults to tmp/war
+    # Deprecated: No longer has any effect.
     attr_accessor :staging_dir
 
+    # A hash of files that Warbler will build into the .war file. Keys
+    # to the hash are filenames in the .war, values are either nil
+    # (for a directory entry), the source filenames or IO objects for
+    # temporary file contents. This will be filled with files by the
+    # various Warbler tasks as they run. You can add arbitrary
+    # filenames to this hash if you wish.
+    attr_accessor :files
+
     # Directory where the war file will be written. Can be used to direct
     # Warbler to place your war file directly in your application server's
     # autodeploy directory. Defaults to the root of the Rails directory.
@@ -38,7 +48,7 @@ module Warbler
     # Java libraries to copy to WEB-INF/lib
     attr_accessor :java_libs
 
-    # Rubygems to install into the webapp at WEB-INF/gems
+    # Rubygems to install into the webapp.
     attr_accessor :gems
 
     # Whether to include dependent gems (default true)
@@ -63,6 +73,17 @@ module Warbler
     # by jar -cf....
     attr_accessor :manifest_file
 
+    # Files for WEB-INF directory (next to web.xml). Contains web.xml by default.
+    # If there are .erb files they will be processed with webxml config.
+    attr_accessor :webinf_files
+
+    # Use Bundler to locate gems if Gemfile is found. Default is true.
+    attr_accessor :bundler
+
+    # Path to the pre-bundled gem directory inside the war file. Default is '/WEB-INF/gems'.
+    # This also sets 'gem.path' inside web.xml.
+    attr_accessor :gem_path
+
     # Extra configuration for web.xml. Controls how the dynamically-generated web.xml
     # file is generated.
     #
@@ -78,6 +99,7 @@ module Warbler
     # * <tt>webxml.rails.env</tt> -- the Rails environment to use for the
     #   running application, usually either development or production (the
     #   default).
+    # * <tt>webxml.gem.path</tt> -- the path to your bundled gem directory
     # * <tt>webxml.jruby.min.runtimes</tt> -- minimum number of pooled runtimes to
     #   keep around during idle time
     # * <tt>webxml.jruby.max.runtimes</tt> -- maximum number of pooled Rails
@@ -92,13 +114,13 @@ module Warbler
 
     def initialize(warbler_home = WARBLER_HOME)
       @warbler_home = warbler_home
-      @staging_dir = File.join("tmp", "war")
       @dirs        = TOP_DIRS.select {|d| File.directory?(d)}
       @includes    = FileList[]
       @excludes    = FileList[]
       @java_libs   = default_jar_files
       @java_classes = FileList[]
       @gems        = Warbler::Gems.new
+      @gem_path    = DEFAULT_GEM_PATH
       @gem_dependencies = true
       @exclude_logs = true
       @public_html = FileList["public/**/*"]
@@ -106,17 +128,24 @@ module Warbler
       @webxml      = default_webxml_config
       @rails_root  = File.expand_path(defined?(RAILS_ROOT) ? RAILS_ROOT : Dir.getwd)
       @war_name    = File.basename(@rails_root)
+      @bundler     = true
+      @webinf_files = default_webinf_files
       auto_detect_frameworks
       yield self if block_given?
+      update_gem_path
+      detect_bundler_gems
       @excludes += warbler_vendor_excludes(warbler_home)
       @excludes += FileList["**/*.log"] if @exclude_logs
-      @excludes << @staging_dir
     end
 
     def gems=(value)
       @gems = Warbler::Gems.new(value)
     end
 
+    def relative_gem_path
+      @gem_path[1..-1]
+    end
+
     private
     def warbler_vendor_excludes(warbler_home)
       warbler = File.expand_path(warbler_home)
@@ -133,8 +162,9 @@ module Warbler
       p.java_libs    = ["WEB-INF/lib/%f"]
       p.java_classes = ["WEB-INF/classes/%p"]
       p.application  = ["WEB-INF/%p"]
-      p.gemspecs     = ["WEB-INF/gems/specifications/%f"]
-      p.gems         = ["WEB-INF/gems/gems/%n"]
+      p.webinf       = ["WEB-INF/%{.erb$,}f"]
+      p.gemspecs     = ["#{relative_gem_path}/specifications/%f"]
+      p.gems         = ["#{relative_gem_path}/gems/%p"]
       p
     end
 
@@ -147,13 +177,61 @@ module Warbler
       c
     end
 
+    def default_webinf_files
+      webxml = if File.exist?("config/web.xml")
+        "config/web.xml"
+      elsif File.exist?("config/web.xml.erb")
+        "config/web.xml.erb"
+      else
+        "#{WARBLER_HOME}/web.xml.erb"
+      end
+      FileList[webxml]
+    end
+
+    def update_gem_path
+      if @gem_path != DEFAULT_GEM_PATH
+        @gem_path = "/#{@gem_path}" unless @gem_path =~ %r{^/}
+        sub_gem_path = @gem_path[1..-1]
+        @pathmaps.gemspecs.each {|p| p.sub!(DEFAULT_GEM_PATH[1..-1], sub_gem_path)}
+        @pathmaps.gems.each {|p| p.sub!(DEFAULT_GEM_PATH[1..-1], sub_gem_path)}
+        @webxml["gem"]["path"] = @gem_path
+      end
+    end
+
+    def detect_bundler_gems
+      if @bundler && File.exist?("Gemfile")
+        @gems.clear
+        @gem_dependencies = false # Bundler takes care of these
+        require 'bundler'
+        env = Bundler.respond_to?(:runtime) ? Bundler.runtime : Bundler.load
+        def Bundler.env_file; root.join(::Warbler::Runtime::WAR_ENV); end
+        env.extend Warbler::Runtime
+        env.gem_path = @gem_path
+        env.write_war_environment
+        env.war_specs.each {|spec| @gems << spec }
+      else
+        @bundler = false
+      end
+    end
+
     def default_jar_files
       require 'jruby-jars'
-      FileList["#{@warbler_home}/lib/*.jar", JRubyJars.core_jar_path, JRubyJars.stdlib_jar_path]
+      require 'jruby-rack'
+      FileList[JRubyJars.core_jar_path, JRubyJars.stdlib_jar_path, JRubyJars.jruby_rack_jar_path]
     end
 
     def auto_detect_frameworks
-      !Warbler.framework_detection || auto_detect_rails || auto_detect_merb || auto_detect_rackup
+      return unless Warbler.framework_detection
+      if File.exist?(".bundle/environment.rb")
+        begin                     # Don't want Bundler to load from .bundle/environment
+          mv(".bundle/environment.rb",".bundle/environment-save.rb", :verbose => false)
+          auto_detect_rails || auto_detect_merb || auto_detect_rackup
+        ensure
+          mv(".bundle/environment-save.rb",".bundle/environment.rb", :verbose => false)
+        end
+      else
+        auto_detect_rails || auto_detect_merb || auto_detect_rackup
+      end
     end
 
     def auto_detect_rails
@@ -166,9 +244,17 @@ module Warbler
         @gems["rails"] = Rails::VERSION::STRING
       end
       if defined?(Rails.configuration.gems)
-        Rails.configuration.gems.each {|g| @gems << Gem::Dependency.new(g.name, g.requirement) }
+        Rails.configuration.gems.each do |g|
+          @gems << Gem::Dependency.new(g.name, g.requirement) if Dir["vendor/gems/#{g.name}*"].empty?
+        end
+      end
+      if defined?(Rails.configuration.threadsafe!) &&
+        (defined?(Rails.configuration.allow_concurrency) && # Rails 3
+          Rails.configuration.allow_concurrency && Rails.configuration.preload_frameworks) ||
+        (defined?(Rails.configuration.action_controller.allow_concurrency) && # Rails 2
+         Rails.configuration.action_controller.allow_concurrency && Rails.configuration.action_controller.preload_frameworks)
+        @webxml.jruby.max.runtimes = 1
       end
-      @webxml.jruby.max.runtimes = 1 if defined?(Rails.configuration.threadsafe!)
       true
     end
 
@@ -189,6 +275,7 @@ module Warbler
       return false unless File.exist?("config.ru")
       @webxml.booter = :rack
       @webxml.rackup = File.read("config.ru")
+      true
     end
   end
 

data/lib/warbler/gems.rb

@@ -1,7 +1,8 @@
 #--
-# (c) Copyright 2007-2008 Sun Microsystems, Inc.
-# See the file LICENSES.txt included with the distribution for
-# software license details.
+# 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 Warbler

data/lib/warbler/runtime.rb

@@ -0,0 +1,43 @@
+module Warbler
+  # Extension module for a Bundler::Runtime instance, to add methods
+  # to create a Bundler environment file specific to war packaging.
+  module Runtime
+    WAR_ENV = ".bundle/war-environment.rb"
+
+    attr_writer :gem_path
+    def gem_path
+      @gem_path || Config::DEFAULT_GEM_PATH
+    end
+
+    class Spec
+      def initialize(spec, gem_path)
+        location = spec[:loaded_from][%r{(.*)/specifications}, 1]
+        spec = spec.dup
+        spec[:loaded_from] = spec[:loaded_from].sub(location, gem_path)
+        spec[:load_paths] = spec[:load_paths].map {|p| p.sub(location, gem_path)}
+        @spec = spec
+      end
+
+      def inspect
+        str = @spec.inspect
+        str.gsub(%r'"/WEB-INF(/[^"]*)"', 'File.expand_path("../..\1", __FILE__)')
+      end
+    end
+
+    def rb_lock_file
+      root.join(WAR_ENV)
+    end
+
+    def specs_for_lock_file
+      super.map {|s| Spec.new(s, gem_path)}
+    end
+
+    def write_war_environment
+      write_rb_lock
+    end
+
+    def war_specs
+      respond_to?(:requested_specs) ? requested_specs : specs_for
+    end
+  end
+end

data/lib/warbler/task.rb

@@ -1,39 +1,29 @@
 #--
-# (c) Copyright 2007-2009 Sun Microsystems, Inc.
-# See the file LICENSES.txt included with the distribution for
-# software license details.
+# 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.
 #++
 
 require 'rake'
 require 'rake/tasklib'
+require 'stringio'
+require 'zip/zip'
 
 module Warbler
-  class << self
-    attr_writer :project_application
-    def project_application
-      @project_application || Rake.application
-    end
-
-    attr_accessor :framework_detection
-  end
-  self.framework_detection = true
-
   # Warbler Rake task.  Allows defining multiple configurations inside the same
   # Rakefile by using different task names.
   class Task < Rake::TaskLib
-    COPY_PROC = proc {|t| cp t.prerequisites.last, t.name }
-
     # Task name
     attr_accessor :name
 
     # Warbler::Config
     attr_accessor :config
 
-    # Whether to print a line when a file or directory task is declared; helps
-    # to see what is getting included
-    attr_accessor :verbose
+    # Warbler::War
+    attr_accessor :war
 
-    def initialize(name = :war, config = nil, tasks = :define_tasks)
+    def initialize(name = :war, config = nil)
       @name   = name
       @config = config
       if @config.nil? && File.exists?(Config::FILE)
@@ -41,310 +31,87 @@ module Warbler
       end
       @config ||= Config.new
       unless @config.kind_of? Config
-        warn "War::Config not provided by override in initializer or #{Config::FILE}; using defaults"
+        warn "Warbler::Config not provided by override in initializer or #{Config::FILE}; using defaults"
         @config = Config.new
       end
+      @war = Warbler::War.new
       yield self if block_given?
-      send tasks
+      define_tasks
     end
 
     private
     def define_tasks
       define_main_task
-      define_clean_task
-      define_public_task
-      define_gems_task
-      define_webxml_task
-      define_app_task
-      define_jar_task
-      define_exploded_task
-      define_debug_task
-    end
-
-    def define_main_task
-      desc "Create #{@config.war_name}.war"
-      task @name => ["#{@name}:app", "#{@name}:public", "#{@name}:webxml", "#{@name}:jar"]
-    end
-
-    def define_clean_task
-      with_namespace_and_config do |name, config|
-        desc "Clean up the .war file and the staging area"
-        task "clean" do
-          rm_rf config.staging_dir
-          rm_f "#{config.war_name}.war"
-        end
-        task "clear" => "#{name}:clean"
-      end
-    end
-
-    def define_public_task
-      public_target_files = define_public_file_tasks
-      with_namespace_and_config do
-        desc "Copy all public HTML files to the root of the .war"
-        task "public" => public_target_files
-        task "debug:public" do
-          puts "", "public files:"
-          puts *public_target_files
-        end
-      end
-    end
-
-    def define_gems_task
-      directory "#{config.staging_dir}/#{apply_pathmaps("sources-0.0.1.gem", :gems).pathmap("%d")}"
-      targets = define_copy_gems_task
-      with_namespace_and_config do
-        desc "Unpack all gems into WEB-INF/gems"
-        task "gems" => targets
-        task "debug:gems" do
-          puts "", "gems files:"
-          puts *targets
-        end
+      namespace name do
+        define_clean_task
+        define_files_task
+        define_gemjar_task
+        define_jar_task
+        define_debug_task
       end
     end
 
-    def define_webxml_task
-      with_namespace_and_config do |name, config|
-        desc "Generate a web.xml file for the webapp"
-        task "webxml" do
-          mkdir_p "#{config.staging_dir}/WEB-INF"
-          if File.exist?("config/web.xml")
-            cp "config/web.xml", "#{config.staging_dir}/WEB-INF"
-          else
-            erb = if File.exist?("config/web.xml.erb")
-              "config/web.xml.erb"
-            else
-              "#{WARBLER_HOME}/web.xml.erb"
-            end
-            require 'erb'
-            erb = ERB.new(File.open(erb) {|f| f.read })
-            File.open("#{config.staging_dir}/WEB-INF/web.xml", "w") do |f|
-              f << erb.result(erb_binding(config.webxml))
-            end
-          end
+    def define_main_task
+      desc "Create the project .war file"
+      task @name do
+        # Invoke this way so custom dependencies can be defined before
+        # the file find routine is run
+        ["#{@name}:files", "#{@name}:jar"].each do |t|
+          Rake::Task[t].invoke
         end
       end
     end
 
-    def define_java_libs_task
-      target_files = @config.java_libs.map do |lib|
-        define_file_task(lib,
-          "#{@config.staging_dir}/#{apply_pathmaps(lib, :java_libs)}")
-      end
-      with_namespace_and_config do |name, config|
-        desc "Copy all java libraries into the .war"
-        task "java_libs" => target_files
-        task "debug:java_libs" do
-          puts "", "java_libs files:"
-          puts *target_files
-        end
+    def define_clean_task
+      desc "Remove the .war file"
+      task "clean" do
+        rm_f "#{config.war_name}.war"
       end
-      target_files
+      task "clear" => "#{name}:clean"
     end
 
-    def define_java_classes_task
-      target_files = @config.java_classes.map do |f|
-        define_file_task(f,
-          "#{@config.staging_dir}/#{apply_pathmaps(f, :java_classes)}")
-      end
-      with_namespace_and_config do |name, config|
-        desc "Copy java classes into the .war"
-        task "java_classes" => target_files
-        task "debug:java_classes" do
-          puts "", "java_classes files:"
-          puts *target_files
-        end
+    def define_files_task
+      task "files" do
+        war.apply(config)
       end
-      target_files
     end
 
-    def define_app_task
-      webinf_target_files = define_webinf_file_tasks
-      with_namespace_and_config do |name, config|
-        desc "Copy all application files into the .war"
-        task "app" => ["#{name}:gems", *webinf_target_files]
-        task "debug:app" do
-          puts "", "app files:"
-          puts *webinf_target_files
+    def define_gemjar_task
+      gem_jar = Warbler::War.new
+      task "gemjar" => "files" do
+        gem_path = Regexp::quote(config.relative_gem_path)
+        gems = war.files.select{|k,v| k =~ %r{#{gem_path}/} }
+        gems.each do |k,v|
+          gem_jar.files[k.sub(%r{#{gem_path}/}, '')] = v
         end
+        war.files["WEB-INF/lib/gems.jar"] = "tmp/gems.jar"
+        war.files.reject!{|k,v| k =~ /#{gem_path}/ }
+        mkdir_p "tmp"
+        gem_jar.create("tmp/gems.jar")
       end
     end
 
     def define_jar_task
-      with_namespace_and_config do |name, config|
-        desc "Run the jar command to create the .war"
-        task "jar" do
-          war_path = "#{config.war_name}.war"
-          war_path = File.join(config.autodeploy_dir, war_path) if config.autodeploy_dir
-          flags, manifest = config.manifest_file ? ["cfm", config.manifest_file] : ["cf", ""]
-          sh "jar #{flags} #{war_path} #{manifest} -C #{config.staging_dir} ."
-        end
-      end
-    end
-
-    def define_exploded_task
-      with_namespace_and_config do |name,config|
-        libs = define_java_libs_task
-        desc "Create an exploded war in the app's public directory"
-        task "exploded" => ["webxml", "java_classes", "gems", *libs] do
-          cp "#{@config.staging_dir}/WEB-INF/web.xml", "."
-          cp File.join(WARBLER_HOME, "sun-web.xml"), "." unless File.exists?("sun-web.xml")
-          ln_sf "#{@config.staging_dir}/WEB-INF/gems", "."
-          if File.directory?("#{@config.staging_dir}/WEB-INF/classes")
-            ln_sf "#{@config.staging_dir}/WEB-INF/classes", "."
-          end
-          mkdir_p "lib"
-          libs.each {|l| ln_sf l, "lib/#{File.basename(l)}"}
-          ln_sf "..", "public/WEB-INF"
-        end
-
-        task "clean:exploded" do
-          (libs.map {|l| "lib/#{File.basename(l)}" } +
-            ["gems", "public/WEB-INF", "classes"]).each do |l|
-            rm_f l if File.exist?(l) && File.symlink?(l)
-          end
-          rm_f "*web.xml"
-        end
+      task "jar" do
+        war.create(config)
       end
     end
 
     def define_debug_task
-      with_namespace_and_config do |name, config|
-        task "debug" do
-          require 'yaml'
-          puts YAML::dump(config)
-        end
-        all_debug_tasks = %w(: app java_libs java_classes gems public includes excludes).map do |n|
-          n.sub(/^:?/, "#{name}:debug:").sub(/:$/, '')
-        end
-        task "debug:all" => all_debug_tasks
-      end
-    end
-
-    def define_public_file_tasks
-      @config.public_html.map do |f|
-        define_file_task(f, "#{@config.staging_dir}/#{apply_pathmaps(f, :public_html)}")
-      end
-    end
-
-    def define_webinf_file_tasks
-      target_files = @config.dirs.select do |d|
-        exists = File.directory?(d)
-        warn "warning: application directory `#{d}' does not exist or is not a directory; skipping" unless exists
-        exists
-      end.map do |d|
-        define_file_task(d, "#{@config.staging_dir}/#{apply_pathmaps(d, :application)}")
-      end
-      files = FileList[*(@config.dirs.map{|d| "#{d}/**/*"})]
-      files.include *(@config.includes.to_a)
-      files.exclude *(@config.excludes.to_a)
-      target_files += files.map do |f|
-        define_file_task(f,
-          "#{@config.staging_dir}/#{apply_pathmaps(f, :application)}")
+      desc "Dump diagnostic information"
+      task "debug" => "files" do
+        require 'yaml'
+        puts YAML::dump(config)
+        war.files.each {|k,v| puts "#{k} -> #{String === v ? v : '<blob>'}"}
       end
-      target_files += define_java_libs_task
-      target_files += define_java_classes_task
-      task "#@name:debug:includes" do
+      task "debug:includes" => "files" do
         puts "", "included files:"
-        puts *files.include
+        puts *war.webinf_filelist.include
       end
-      task "#@name:debug:excludes" do
+      task "debug:excludes" => "files" do
         puts "", "excluded files:"
-        puts *files.exclude
-      end
-      target_files
-    end
-
-    def define_file_task(source, target)
-      if File.directory?(source)
-        directory target
-        puts %{directory "#{target}"} if verbose
-      else
-        directory File.dirname(target)
-        file(target => [File.dirname(target), source], &COPY_PROC)
-        puts %{file "#{target}" => "#{source}"} if verbose
-      end
-      target
-    end
-
-    def with_namespace_and_config
-      name, config = @name, @config
-      namespace name do
-        yield name, config
-      end
-    end
-
-    def define_copy_gems_task
-      targets = []
-      @config.gems.each do |gem, version|
-        define_single_gem_tasks(gem, targets, version)
-      end
-      targets
-    end
-
-    def define_single_gem_tasks(gem_pattern, targets, version = nil)
-      gem = case gem_pattern
-      when Gem::Dependency
-        gem_pattern
-      else
-        Gem::Dependency.new(gem_pattern, Gem::Requirement.create(version))
-      end
-
-      # skip development dependencies
-      return if gem.respond_to?(:type) and gem.type != :runtime
-
-      matched = Gem.source_index.search(gem)
-      fail "gem '#{gem}' not installed" if matched.empty?
-      spec = matched.last
-
-      # skip gems with no load path
-      return if spec.loaded_from == ""
-
-      gem_name = "#{spec.name}-#{spec.version}"
-      unless spec.platform.nil? || spec.platform == Gem::Platform::RUBY
-        [spec.platform, spec.original_platform].each do |p|
-          name = "#{gem_name}-#{p}"
-          if File.exist?(File.join(Gem.dir, 'cache', "#{name}.gem"))
-            gem_name = name
-            break
-          end
-        end
+        puts *war.webinf_filelist.exclude
       end
-
-      gem_unpack_task_name = "gem:#{gem_name}"
-      return if Rake::Task.task_defined?(gem_unpack_task_name)
-
-      targets << define_file_task(spec.loaded_from,
-        "#{@config.staging_dir}/#{apply_pathmaps(spec.loaded_from, :gemspecs)}")
-
-      task targets.last do
-        Rake::Task[gem_unpack_task_name].invoke
-      end
-
-      src = File.join(Gem.dir, 'cache', "#{gem_name}.gem")
-      dest = "#{config.staging_dir}/#{apply_pathmaps(src, :gems)}"
-
-      task gem_unpack_task_name => [dest.pathmap("%d")] do |t|
-        require 'rubygems/installer'
-        Gem::Installer.new(src, :unpack => true).unpack(dest)
-      end
-
-      if @config.gem_dependencies
-        spec.dependencies.each do |dep|
-          define_single_gem_tasks(dep, targets)
-        end
-      end
-    end
-
-    def erb_binding(webxml)
-      binding
-    end
-
-    def apply_pathmaps(file, pathmaps)
-      pathmaps = @config.pathmaps.send(pathmaps)
-      pathmaps.each do |p|
-        file = file.pathmap(p)
-      end if pathmaps
-      file
     end
   end
 end