rdmopensource-warbler 1.1.0

data/lib/warbler/config.rb

@@ -0,0 +1,349 @@
+#--
+# 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'
+
+module Warbler
+  # Warbler war file assembly configuration class.
+  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)
+
+    # Features: additional options controlling how the jar is built.
+    # Currently the following features are supported:
+    # - gemjar: package the gem repository in a jar file in WEB-INF/lib
+    # - executable: embed a web server and make the war executable
+    attr_accessor :features
+
+    # Deprecated: No longer has any effect.
+    attr_accessor :staging_dir
+
+    # 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.
+    attr_accessor :autodeploy_dir
+
+    # Top-level directories to be copied into WEB-INF.  Defaults to
+    # names in TOP_DIRS
+    attr_accessor :dirs
+
+    # Additional files beyond the top-level directories to include in the
+    # WEB-INF directory
+    attr_accessor :includes
+
+    # Files to exclude from the WEB-INF directory
+    attr_accessor :excludes
+
+    # Java classes and other files to copy to WEB-INF/classes
+    attr_accessor :java_classes
+
+    # Java libraries to copy to WEB-INF/lib
+    attr_accessor :java_libs
+
+    # Rubygems to install into the webapp.
+    attr_accessor :gems
+
+    # Whether to include dependent gems (default true)
+    attr_accessor :gem_dependencies
+
+    # Whether to exclude **/*.log files (default is true)
+    attr_accessor :exclude_logs
+
+    # Public HTML directory file list, to be copied into the root of the war
+    attr_accessor :public_html
+
+    # Container of pathmaps used for specifying source-to-destination transformations
+    # under various situations (<tt>public_html</tt> and <tt>java_classes</tt> are two
+    # entries in this structure).
+    attr_accessor :pathmaps
+
+    # Name of war file (without the .war), defaults to the directory name containing
+    # the Rails application
+    attr_accessor :war_name
+
+    # Name of a MANIFEST.MF template to use.
+    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
+
+    # FileList of ruby files to compile to class files
+    attr_accessor :compiled_ruby_files
+
+    # Extra configuration for web.xml. Controls how the dynamically-generated web.xml
+    # file is generated.
+    #
+    # * <tt>webxml.jndi</tt> -- the name of one or more JNDI data sources name to be
+    #   available to the application. Places appropriate &lt;resource-ref&gt; entries
+    #   in the file.
+    # * <tt>webxml.ignored</tt> -- array of key names that will be not used to
+    #   generate a context param. Defaults to ['jndi', 'booter']
+    #
+    # Any other key/value pair placed in the open structure will be dumped as a
+    # context parameter in the web.xml file. Some of the recognized values are:
+    #
+    # * <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
+    #   application runtimes
+    #
+    # Note that if you attempt to access webxml configuration keys in a conditional,
+    # you might not obtain the result you want. For example:
+    #     <%= webxml.maybe.present.key || 'default' %>
+    # doesn't yield the right result. Instead, you need to generate the context parameters:
+    #     <%= webxml.context_params['maybe.present.key'] || 'default' %>
+    attr_accessor :webxml
+
+    def initialize(warbler_home = WARBLER_HOME)
+      @warbler_home = warbler_home
+      @features    = []
+      @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/**/*"]
+      @pathmaps    = default_pathmaps
+      @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
+      @compiled_ruby_files = FileList[]
+      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
+    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)
+      if warbler =~ %r{^#{@rails_root}/(.*)}
+        FileList["#{$1}"]
+      else
+        []
+      end
+    end
+
+    def default_pathmaps
+      p = OpenStruct.new
+      p.public_html  = ["%{public/,}p"]
+      p.java_libs    = ["WEB-INF/lib/%f"]
+      p.java_classes = ["WEB-INF/classes/%p"]
+      p.application  = ["WEB-INF/%p"]
+      p.webinf       = ["WEB-INF/%{.erb$,}f"]
+      p.gemspecs     = ["#{relative_gem_path}/specifications/%f"]
+      p.gems         = ["#{relative_gem_path}/gems/%p"]
+      p
+    end
+
+    def default_webxml_config
+      c = WebxmlOpenStruct.new
+      c.rails.env  = ENV['RAILS_ENV'] || 'production'
+      c.public.root = '/'
+      c.jndi = nil
+      c.ignored = %w(jndi booter)
+      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
+        begin
+          require 'bundler'
+          env = Bundler::Runtime.new(Bundler.root, Bundler.definition)
+          if bundler_env_file = Bundler.respond_to?(:env_file)
+            class << Bundler
+              alias orig_env_file env_file
+              def env_file; root.join(::Warbler::Runtime::WAR_ENV); end
+            end
+          end
+          env.extend Warbler::Runtime
+          env.gem_path = @gem_path
+          env.write_war_environment
+          env.war_specs.each {|spec| @gems << spec }
+        ensure
+          if bundler_env_file
+            class << Bundler
+              alias env_file orig_env_file
+            end
+          end
+        end
+      else
+        @bundler = false
+      end
+    end
+
+    def default_jar_files
+      require 'jruby-jars'
+      require 'jruby-rack'
+      FileList[JRubyJars.core_jar_path, JRubyJars.stdlib_jar_path, JRubyJars.jruby_rack_jar_path]
+    end
+
+    def auto_detect_frameworks
+      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
+      return false unless task = Warbler.project_application.lookup("environment")
+      task.invoke rescue nil
+      return false unless defined?(::Rails)
+      @dirs << "tmp" if File.directory?("tmp")
+      @webxml.booter = :rails
+      unless (defined?(Rails.vendor_rails?) && Rails.vendor_rails?) || File.directory?("vendor/rails")
+        @gems["rails"] = Rails::VERSION::STRING
+      end
+      if defined?(Rails.configuration.gems)
+        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
+      true
+    end
+
+    def auto_detect_merb
+      return false unless task = Warbler.project_application.lookup("merb_env")
+      task.invoke rescue nil
+      return false unless defined?(::Merb)
+      @webxml.booter = :merb
+      if defined?(Merb::BootLoader::Dependencies.dependencies)
+        Merb::BootLoader::Dependencies.dependencies.each {|g| @gems << g }
+      else
+        warn "unable to auto-detect Merb dependencies; upgrade to Merb 1.0 or greater"
+      end
+      true
+    end
+
+    def auto_detect_rackup
+      return false unless File.exist?("config.ru") || !Dir['*/config.ru'].empty?
+      @webxml.booter = :rack
+      @webinf_files += [FileList['config.ru', '*/config.ru'].detect {|f| File.exist?(f)}]
+      true
+    end
+  end
+
+  # Helper class for holding arbitrary config.webxml values for injecting into +web.xml+.
+  class WebxmlOpenStruct < OpenStruct
+    %w(java com org javax).each {|name| undef_method name if Object.methods.include?(name) }
+
+    def initialize(key = 'webxml')
+      @key = key
+      @table = Hash.new {|h,k| h[k] = WebxmlOpenStruct.new(k) }
+    end
+
+    def servlet_context_listener
+      case self.booter
+      when :rack
+        "org.jruby.rack.RackServletContextListener"
+      when :merb
+        "org.jruby.rack.merb.MerbServletContextListener"
+      else # :rails, default
+        "org.jruby.rack.rails.RailsServletContextListener"
+      end
+    end
+
+    def [](key)
+      new_ostruct_member(key)
+      send(key)
+    end
+
+    def []=(key, value)
+      new_ostruct_member(key)
+      send("#{key}=", value)
+    end
+
+    def context_params
+      require 'cgi'
+      params = {}
+      @table.each do |k,v|
+        case v
+        when WebxmlOpenStruct
+          nested_params = v.context_params
+          nested_params.each do |nk,nv|
+            params["#{CGI::escapeHTML(k.to_s)}.#{nk}"] = nv
+          end
+        else
+          params[CGI::escapeHTML(k.to_s)] = CGI::escapeHTML(v.to_s)
+        end
+      end
+      params.delete_if {|k,v| ['ignored', *ignored].include?(k.to_s) }
+      params
+    end
+
+    def to_s
+      "No value for '#@key' found"
+    end
+  end
+end

data/lib/warbler/gems.rb

@@ -0,0 +1,37 @@
+#--
+# 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
+  # A set of gems. This only exists to allow expected operations
+  # to be used to add gems, and for backwards compatibility.
+  # It would be easier to just use a hash.
+  class Gems < Hash
+    ANY_VERSION = nil
+    
+    def initialize(gems = nil)
+      if gems.is_a?(Hash)
+        self.merge!(gems)
+      elsif gems.is_a?(Array)
+        gems.each {|gem| self << gem }
+      end
+    end
+    
+    def <<(gem)
+      self[gem] ||= ANY_VERSION
+    end
+
+    def +(other)
+      other.each {|g| self[g] ||= ANY_VERSION }
+      self
+    end
+
+    def -(other)
+      other.each {|g| self.delete(g)}
+      self
+    end
+  end
+end

data/lib/warbler/runtime.rb

@@ -0,0 +1,44 @@
+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
+
+    # deprecated; compatibility with Bundler <= 0.9.14
+    def rb_lock_file            #:nocov:
+      root.join(WAR_ENV)        #:nocov:
+    end                         #:nocov:
+
+    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

@@ -0,0 +1,224 @@
+#--
+# 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
+  # Warbler Rake task.  Allows defining multiple configurations inside the same
+  # Rakefile by using different task names.
+  #
+  # To define multiple Warbler configurations in a single project, use
+  # code like the following in a Rakefile:
+  #
+  #     Warbler::Task.new("war1", Warbler::Config.new do |config|
+  #       config.war_name = "war1"
+  #       # ...
+  #     end
+  #     Warbler::Task.new("war2", Warbler::Config.new do |config|
+  #       config.war_name = "war2"
+  #       # ...
+  #     end
+  #
+  # With this setup, you can create two separate war files two
+  # different configurations by running <tt>rake war1 war2</tt>.
+  class Task < Rake::TaskLib
+    # Task name
+    attr_accessor :name
+
+    # Warbler::Config
+    attr_accessor :config
+
+    # Warbler::War
+    attr_accessor :war
+
+    def initialize(name = :war, config = nil)
+      @name   = name
+      @config = config
+      if @config.nil? && File.exists?(Config::FILE)
+        @config = eval(File.open(Config::FILE) {|f| f.read})
+      end
+      @config ||= Config.new
+      unless @config.kind_of? Config
+        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?
+      define_tasks
+    end
+
+    private
+    def define_tasks
+      define_main_task
+      namespace name do
+        define_clean_task
+        define_compile_task
+        define_files_task
+        define_jar_task
+        define_debug_task
+        define_gemjar_task
+        define_config_task
+        define_pluginize_task
+        define_executable_task
+        define_version_task
+      end
+    end
+
+    def define_main_task
+      desc "Create the project .war file"
+      task @name do
+        unless @config.features.empty?
+          @config.features.each do |feature|
+            t = "#@name:#{feature}"
+            unless Rake.application.lookup(t)
+              warn "unknown feature `#{feature}', ignoring"
+              next
+            end
+            Rake::Task[t].invoke
+          end
+        end
+        # 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_clean_task
+      desc "Remove the .war file"
+      task "clean" do
+        rm_f "#{config.war_name}.war"
+      end
+      task "clear" => "#{name}:clean"
+    end
+
+    def define_compile_task
+      task "compile_ruby_files" do
+        war.compile(config)
+      end
+    end
+
+    def define_files_task
+      task "files" => "compile_ruby_files" do
+        war.apply(config)
+      end
+    end
+
+    def define_jar_task
+      task "jar" do
+        war.create(config)
+      end
+    end
+
+    def define_debug_task
+      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
+      task "debug:includes" => "files" do
+        puts "", "included files:"
+        puts *war.webinf_filelist.include
+      end
+      task "debug:excludes" => "files" do
+        puts "", "excluded files:"
+        puts *war.webinf_filelist.exclude
+      end
+    end
+
+    def define_gemjar_task
+      task "gemjar" do
+        task "#@name:jar" => "#@name:make_gemjar"
+      end
+
+      gem_jar = Warbler::War.new
+      task "make_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.add_manifest
+        gem_jar.create("tmp/gems.jar")
+      end
+    end
+
+    def define_config_task
+      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
+    end
+
+    def define_pluginize_task
+      task "pluginize" do
+        if !Dir["vendor/plugins/warbler*"].empty? && ENV["FORCE"].nil?
+          puts "I found an old nest in vendor/plugins; please trash it so I can make a new one"
+          puts "(directory vendor/plugins/warbler* exists)"
+        else
+          rm_rf FileList["vendor/plugins/warbler*"], :verbose => false
+          mkdir_p "vendor/plugins/warbler/tasks"
+          File.open("vendor/plugins/warbler/tasks/warbler.rake", "w") do |f|
+            f.puts "require 'warbler'"
+            f.puts "Warbler::Task.new"
+          end
+        end
+      end
+    end
+
+    def define_executable_task
+      winstone_type = ENV["WINSTONE"] || "winstone-lite"
+      winstone_version = ENV["WINSTONE_VERSION"] || "0.9.10"
+      winstone_path = "net/sourceforge/winstone/#{winstone_type}/#{winstone_version}/#{winstone_type}-#{winstone_version}.jar"
+      winstone_jar = File.expand_path("~/.m2/repository/#{winstone_path}")
+      file winstone_jar do |t|
+        # Not always covered in tests as these lines may not get
+        # executed every time if the jar is cached.
+        puts "Downloading #{winstone_type}.jar" #:nocov:
+        mkdir_p File.dirname(t.name)            #:nocov:
+        require 'open-uri'                      #:nocov:
+        maven_repo = ENV["MAVEN_REPO"] || "http://repo2.maven.org/maven2" #:nocov:
+        open("#{maven_repo}/#{winstone_path}") do |stream| #:nocov:
+          File.open(t.name, "wb") do |f|  #:nocov:
+            while buf = stream.read(4096) #:nocov:
+              f << buf                    #:nocov:
+            end                           #:nocov:
+          end                             #:nocov:
+        end                               #:nocov:
+      end
+
+      task "executable" => winstone_jar do
+        war.files['META-INF/MANIFEST.MF'] = StringIO.new(War::DEFAULT_MANIFEST.chomp + "Main-Class: Main\n")
+        war.files['Main.class'] = Zip::ZipFile.open("#{WARBLER_HOME}/lib/warbler_war.jar") do |zf|
+          zf.get_input_stream('Main.class') {|io| StringIO.new(io.read) }
+        end
+        war.files['WEB-INF/winstone.jar'] = winstone_jar
+      end
+    end
+
+    def define_version_task
+      task "version" do
+        puts "Warbler version #{Warbler::VERSION}"
+      end
+    end
+  end
+end