fjc-warbler 0.9.12

data/generators/warble/warble_generator.rb

@@ -0,0 +1,19 @@
+#--
+# (c) Copyright 2007-2008 Sun Microsystems, Inc.
+# See the file LICENSES.txt included with the distribution for
+# software license details.
+#++
+
+class WarbleGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.directory 'config'
+      m.template 'warble.rb', File.join('config', 'warble.rb')
+    end
+  end
+  
+  protected
+  def banner
+    "Usage: #{$0} warble"
+  end  
+end

data/lib/warbler.rb

@@ -0,0 +1,16 @@
+#--
+# (c) Copyright 2007-2008 Sun Microsystems, Inc.
+# See the file LICENSES.txt included with the distribution for
+# software license 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)
+end
+
+require 'warbler/gems'
+require 'warbler/config'
+require 'warbler/task'
+require 'warbler/version'

data/lib/warbler/config.rb

@@ -0,0 +1,238 @@
+#--
+# (c) Copyright 2007-2008 Sun Microsystems, Inc.
+# See the file LICENSES.txt included with the distribution for
+# software license details.
+#++
+
+require 'ostruct'
+
+module Warbler
+  # Warbler assembly configuration.
+  class Config
+    TOP_DIRS = %w(app config lib log vendor)
+    FILE = "config/warble.rb"
+    BUILD_GEMS = %w(warbler rake rcov)
+
+    # Directory where files will be staged, defaults to tmp/war
+    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 at WEB-INF/gems
+    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 the MANIFEST.MF template.  Defaults to the MANIFEST.MF normally generated
+    # by jar -cf....
+    attr_accessor :manifest_file
+
+    # 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.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)
+      @staging_dir = File.join("tmp", "war")
+      @dirs        = TOP_DIRS.select {|d| File.directory?(d)}
+      @includes    = FileList[]
+      @excludes    = FileList[]
+      @java_libs   = FileList["#{warbler_home}/lib/*.jar"]
+      @java_classes = FileList[]
+      @gems        = Warbler::Gems.new
+      @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)
+      auto_detect_frameworks
+      yield self if block_given?
+      @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
+
+    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.gemspecs     = ["WEB-INF/gems/specifications/%f"]
+      p.gems         = ["WEB-INF/gems/gems/%n"]
+      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 auto_detect_frameworks
+      !Warbler.framework_detection || auto_detect_rails || auto_detect_merb || auto_detect_rackup
+    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[g.name] = g.respond_to?(:version) ? g.version : g.specification.version
+        end
+      end
+      @webxml.jruby.max.runtimes = 1 if defined?(Rails.configuration.threadsafe!)
+      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
+      @gems["merb-core"] = Merb::VERSION # TODO: what should this be?
+      true
+    end
+
+    def auto_detect_rackup
+      return false unless File.exist?("config.ru")
+      @webxml.booter = :rack
+      @webxml.rackup = File.read("config.ru")
+    end
+  end
+
+  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,36 @@
+#--
+# (c) Copyright 2007-2008 Sun Microsystems, Inc.
+# See the file LICENSES.txt included with the distribution for
+# software license 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/task.rb

@@ -0,0 +1,339 @@
+#--
+# (c) Copyright 2007-2008 Sun Microsystems, Inc.
+# See the file LICENSES.txt included with the distribution for
+# software license details.
+#++
+
+require 'rake'
+require 'rake/tasklib'
+
+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
+
+    def initialize(name = :war, config = nil, tasks = :define_tasks)
+      @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 "War::Config not provided by override in initializer or #{Config::FILE}; using defaults"
+        @config = Config.new
+      end
+      yield self if block_given?
+      send 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_tasks
+      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
+      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
+        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
+      end
+      target_files
+    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
+      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
+        end
+      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
+      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.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)}")
+      end
+      target_files += define_java_libs_task
+      target_files += define_java_classes_task
+      task "#@name:debug:includes" do
+        puts "", "included files:"
+        puts *files.include
+      end
+      task "#@name:debug:excludes" 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_tasks
+      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, version)
+      end
+      matched = Gem.source_index.search(gem)
+      fail "gem '#{gem}' not installed" if matched.empty?
+      spec = matched.last
+
+      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
+      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(dest)
+      end
+
+      if @config.gem_dependencies
+        spec.dependencies.each do |dep|
+          define_single_gem_tasks(dep.name, targets, dep.version_requirements)
+        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