lucidimagination-warbler 1.3.2.dev

data/ext/WarblerJarService.java

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2010-2011 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.
+ */
+
+import java.io.IOException;
+import org.jruby.Ruby;
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class WarblerJarService implements BasicLibraryService {
+    public boolean basicLoad(final Ruby runtime) throws IOException {
+        WarblerJar.create(runtime);
+        return true;
+    }
+}
+

data/lib/warbler.rb

@@ -0,0 +1,33 @@
+#--
+# Copyright (c) 2010-2011 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 Ruby applications into .jar or .war files.
+module Warbler
+  WARBLER_HOME = File.expand_path(File.dirname(__FILE__) + '/..') unless defined?(WARBLER_HOME)
+
+  class << self
+    # An instance of Warbler::Application used by the +warble+ command.
+    attr_accessor :application
+    # Set Warbler.framework_detection to false to disable
+    # auto-detection based on application configuration.
+    attr_accessor :framework_detection
+    attr_writer :project_application
+  end
+
+  # Warbler loads the project Rakefile in a separate Rake application
+  # from the one where the Warbler tasks are run.
+  def self.project_application
+    application.load_project_rakefile if application
+    @project_application || Rake.application
+  end
+  self.framework_detection = true
+end
+
+require 'warbler/version'
+require 'warbler/task'
+require 'warbler/application'

data/lib/warbler/application.rb

@@ -0,0 +1,86 @@
+#--
+# Copyright (c) 2010-2011 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'
+
+# Extension of Rake::Application that allows the +warble+ command to
+# report its name properly and inject its own tasks without a
+# Rakefile.
+class Warbler::Application < Rake::Application
+  def initialize
+    super
+    Warbler.application = self
+    @project_loaded = false
+  end
+
+  # Sets the application name and loads Warbler's own tasks
+  def load_rakefile
+    @name = 'warble'
+
+    # Load the main warbler tasks
+    wt = Warbler::Task.new
+
+    task :default => wt.name
+
+    desc "Generate a configuration file to customize your archive"
+    task :config => "#{wt.name}:config"
+
+    desc "Install Warbler tasks in your Rails application"
+    task :pluginize => "#{wt.name}:pluginize"
+
+    desc "Feature: package gem repository inside a jar"
+    task :gemjar => "#{wt.name}:gemjar"
+
+    desc "Feature: make an executable archive"
+    task :executable => "#{wt.name}:executable"
+
+    desc "Feature: precompile all Ruby files"
+    task :compiled => "#{wt.name}:compiled"
+
+    desc "Display version of Warbler"
+    task :version => "#{wt.name}:version"
+  end
+
+  # Loads the project Rakefile in a separate application
+  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
+
+  # Run the application: The equivalent code for the +warble+ command
+  # is simply <tt>Warbler::Application.new.run</tt>.
+  def run
+    Rake.application = self
+    super
+  end
+
+  # Remap the version option to display Warbler version.
+  def standard_rake_options
+    super.map do |opt|
+      if opt.first == '--version'
+        ['--version', '-V', "Display the program version.",
+         lambda { |value|
+           puts "Warbler version #{Warbler::VERSION}"
+           exit
+         }
+        ]
+      else
+        opt
+      end
+    end
+  end
+end

data/lib/warbler/config.rb

@@ -0,0 +1,223 @@
+#--
+# Copyright (c) 2010-2011 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 'set'
+require 'warbler/gems'
+require 'warbler/traits'
+
+module Warbler
+  # Warbler archive assembly configuration class.
+  class Config
+    TOP_DIRS = %w(app config lib log vendor)
+    FILE = "config/warble.rb"
+    BUILD_GEMS = %w(warbler rake rcov)
+
+    include Traits
+
+    # 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
+    # - compiled: compile .rb files to .class files
+    attr_accessor :features
+
+    # Traits: an array of trait classes corresponding to
+    # characteristics of the project that are either auto-detected or
+    # configured.
+    attr_accessor :traits
+
+    # 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 application 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
+
+    # Array of regular expressions matching relative paths in gems to
+    # be excluded from the war. Default contains no exclusions.
+    attr_accessor :gem_excludes
+
+    # 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 jar or war file (without the extension), defaults to the
+    # directory name containing the application.
+    attr_accessor :jar_name
+
+    # Extension of jar file. Defaults to <tt>jar</tt> or <tt>war</tt> depending on the project.
+    attr_accessor :jar_extension
+
+    # 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
+
+    # An array of Bundler groups to avoid including in the war file.
+    # Defaults to ["development", "test"].
+    attr_accessor :bundle_without
+
+    # 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
+
+    # List of ruby files to compile to class files. Default is to
+    # compile all .rb files in the application.
+    attr_accessor :compiled_ruby_files
+
+    # Warbler writes an "init" file into the war at this location. JRuby-Rack and possibly other
+    # launchers may use this to initialize the Ruby environment.
+    attr_accessor :init_filename
+
+    # Array containing filenames or StringIO's to be concatenated together to form the init file.
+    # If the filename ends in .erb the file will be expanded the same way web.xml.erb is; see below.
+    attr_accessor :init_contents
+
+    # 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
+
+    attr_reader :warbler_templates
+
+    def initialize(warbler_home = WARBLER_HOME)
+      super()
+
+      @warbler_home      = warbler_home
+      @warbler_templates = "#{WARBLER_HOME}/lib/warbler/templates"
+      @features          = Set.new
+      @dirs              = TOP_DIRS.select {|d| File.directory?(d)}
+      @includes          = FileList[]
+      @excludes          = FileList[]
+      @java_libs         = FileList[]
+      @java_classes      = FileList[]
+      @gems              = Warbler::Gems.new
+      @gem_dependencies  = true
+      @gem_excludes      = []
+      @exclude_logs      = true
+      @public_html       = FileList[]
+      @jar_name          = File.basename(Dir.getwd)
+      @jar_extension     = 'jar'
+      @webinf_files      = FileList[]
+      @init_filename     = 'META-INF/init.rb'
+      @init_contents     = ["#{@warbler_templates}/config.erb"]
+
+      before_configure
+      yield self if block_given?
+      after_configure
+
+      @compiled_ruby_files ||= FileList[*@dirs.map {|d| "#{d}/**/*.rb"}]
+
+      @excludes += ["tmp/war"] if File.directory?("tmp/war")
+      @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
+
+    def define_tasks
+      task "gemjar" do
+        self.features << "gemjar"
+      end
+      task "executable" do
+        self.features << "executable"
+      end
+    end
+
+    # Deprecated
+    def war_name
+      $stderr.puts "config.war_name deprecated; replace with config.jar_name" #:nocov:
+      jar_name                  #:nocov:
+    end
+
+    # Deprecated
+    def war_name=(w)
+      $stderr.puts "config.war_name deprecated; replace with config.jar_name" #:nocov:
+      self.jar_name = w         #:nocov:
+    end
+
+    private
+    def warbler_vendor_excludes(warbler_home)
+      warbler = File.expand_path(warbler_home)
+      if warbler =~ %r{^#{Dir.getwd}/(.*)}
+        FileList["#{$1}"]
+      else
+        []
+      end
+    end
+
+    def dump
+      YAML::dump(self.dup.tap{|c| c.dump_traits })
+    end
+    public :dump
+  end
+end

data/lib/warbler/gems.rb

@@ -0,0 +1,37 @@
+#--
+# Copyright (c) 2010-2011 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/jar.rb

@@ -0,0 +1,253 @@
+#--
+# Copyright (c) 2010-2011 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 'zip/zip'
+require 'stringio'
+require 'pathname'
+
+module Warbler
+  # Class that holds the files that will be stored in the jar file.
+  # The #files attribute contains a hash of pathnames inside the jar
+  # file to their contents. Contents can be one of:
+  # * +nil+ representing a directory entry
+  # * Any object responding to +read+ representing an in-memory blob
+  # * A String filename pointing to a file on disk
+  class Jar
+    DEFAULT_MANIFEST = %{Manifest-Version: 1.0\nCreated-By: Warbler #{Warbler::VERSION}\n\n}
+
+    attr_reader :files
+    attr_reader :app_filelist
+
+    def initialize
+      @files = {}
+    end
+
+    def contents(entry)
+      file = files[entry]
+      file.respond_to?(:read) ? file.read : File.open(file) {|f| f.read }
+    end
+
+    def compile(config)
+      # Compiling all Ruby files we can find -- do we need to allow an
+      # option to configure what gets compiled?
+      return if config.compiled_ruby_files.nil? || config.compiled_ruby_files.empty?
+
+      run_javac(config, config.compiled_ruby_files)
+      replace_compiled_ruby_files(config, config.compiled_ruby_files)
+    end
+
+    def run_javac(config, compiled_ruby_files)
+      # Need to use the version of JRuby in the application to compile it
+      %x{java -classpath #{config.java_libs.join(File::PATH_SEPARATOR)} org.jruby.Main -S jrubyc \"#{compiled_ruby_files.join('" "')}\"}
+    end
+
+    def replace_compiled_ruby_files(config, compiled_ruby_files)
+      # Exclude the rb files and recreate them. This
+      # prevents the original contents being used.
+      config.excludes += compiled_ruby_files
+
+      compiled_ruby_files.each do |ruby_source|
+        files[apply_pathmaps(config, ruby_source, :application)] = StringIO.new("require __FILE__.sub(/\.rb$/, '.class')")
+      end
+    end
+
+    # Apply the information in a Warbler::Config object in order to
+    # look for files to put into this war file.
+    def apply(config)
+      find_application_files(config)
+      find_java_libs(config)
+      find_java_classes(config)
+      find_gems_files(config)
+      add_manifest(config)
+      add_init_file(config)
+      apply_traits(config)
+    end
+
+    # Create the jar or war file. The single argument can either be a
+    # Warbler::Config or a filename of the file to create.
+    def create(config_or_path)
+      path = config_or_path
+      if Warbler::Config === config_or_path
+        path = "#{config_or_path.jar_name}.#{config_or_path.jar_extension}"
+        path = File.join(config_or_path.autodeploy_dir, path) if config_or_path.autodeploy_dir
+      end
+      rm_f path
+      ensure_directory_entries
+      puts "Creating #{path}"
+      create_jar path, @files
+    end
+
+    # Invoke a hook to allow the project traits to add or modify the archive contents.
+    def apply_traits(config)
+      config.update_archive(self)
+    end
+
+    # Add a manifest file either from config or by making a default manifest.
+    def add_manifest(config = nil)
+      unless @files.keys.detect{|k| k =~ /^META-INF\/MANIFEST\.MF$/i}
+        if config && config.manifest_file
+          @files['META-INF/MANIFEST.MF'] = config.manifest_file
+        else
+          @files['META-INF/MANIFEST.MF'] = StringIO.new(DEFAULT_MANIFEST)
+        end
+      end
+    end
+
+    # Add java libraries to WEB-INF/lib.
+    def find_java_libs(config)
+      config.java_libs.map {|lib| add_with_pathmaps(config, lib, :java_libs) }
+    end
+
+    # Add java classes to WEB-INF/classes.
+    def find_java_classes(config)
+      config.java_classes.map {|f| add_with_pathmaps(config, f, :java_classes) }
+    end
+
+    # Add gems to WEB-INF/gems
+    def find_gems_files(config)
+      config.gems.each {|gem, version| find_single_gem_files(config, gem, version) }
+    end
+
+    # Add a single gem to WEB-INF/gems
+    def find_single_gem_files(config, gem_pattern, version = nil)
+      if Gem::Specification === gem_pattern
+        spec = gem_pattern
+      else
+        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
+      end
+
+      full_gem_path = Pathname.new(spec.full_gem_path)
+
+      # skip gems whose full_gem_path does not exist
+      ($stderr.puts "warning: skipping #{spec.name} (#{full_gem_path.to_s} does not exist)" ; return) unless full_gem_path.exist?
+
+      @files[apply_pathmaps(config, "#{spec.full_name}.gemspec", :gemspecs)] = StringIO.new(spec.to_ruby)
+      FileList["#{full_gem_path.to_s}/**/*"].each do |src|
+        f = Pathname.new(src).relative_path_from(full_gem_path).to_s
+        next if config.gem_excludes && config.gem_excludes.any? {|rx| f =~ rx }
+        @files[apply_pathmaps(config, File.join(spec.full_name, f), :gems)] = src
+      end
+
+      spec.dependencies.each {|dep| find_single_gem_files(config, dep) } if config.gem_dependencies
+    end
+
+    # Add all application directories and files to the archive.
+    def find_application_files(config)
+      config.dirs.select do |d|
+        exists = File.directory?(d)
+        $stderr.puts "warning: application directory `#{d}' does not exist or is not a directory; skipping" unless exists
+        exists
+      end.each do |d|
+        @files[apply_pathmaps(config, d, :application)] = nil
+      end
+      @app_filelist = FileList[*(config.dirs.map{|d| "#{d}/**/*"})]
+      @app_filelist.include *(config.includes.to_a)
+      @app_filelist.exclude *(config.excludes.to_a)
+      @app_filelist.map {|f| add_with_pathmaps(config, f, :application) }
+    end
+
+    # Add init.rb file to the war file.
+    def add_init_file(config)
+      if config.init_contents
+        contents = ''
+        config.init_contents.each do |file|
+          if file.respond_to?(:read)
+            contents << file.read
+          elsif File.extname(file) == '.erb'
+            contents << expand_erb(file, config).read
+          else
+            contents << File.read(file)
+          end
+        end
+        @files[config.init_filename] = StringIO.new(contents)
+      end
+    end
+
+    def add_with_pathmaps(config, f, map_type)
+      @files[apply_pathmaps(config, f, map_type)] = f
+    end
+
+    def expand_erb(file, config)
+      require 'erb'
+      erb = ERB.new(File.open(file) {|f| f.read })
+      StringIO.new(erb.result(erb_binding(config)))
+    end
+
+    def erb_binding(config)
+      webxml = config.webxml
+      binding
+    end
+
+    def apply_pathmaps(config, file, pathmaps)
+      file = file[2..-1] if file =~ /^\.\//
+      pathmaps = config.pathmaps.send(pathmaps)
+      pathmaps.each do |p|
+        file = file.pathmap(p)
+      end if pathmaps
+      file
+    end
+
+    def ensure_directory_entries
+      files.select {|k,v| !v.nil? }.each do |k,v|
+        dir = File.dirname(k)
+        while dir != "." && !files.has_key?(dir)
+          files[dir] = nil
+          dir = File.dirname(dir)
+        end
+      end
+    end
+
+    def create_jar(war_file, entries)
+      Zip::ZipFile.open(war_file, Zip::ZipFile::CREATE) do |zipfile|
+        entries.keys.sort.each do |entry|
+          src = entries[entry]
+          if src.respond_to?(:read)
+            zipfile.get_output_stream(entry) {|f| f << src.read }
+          elsif src.nil? || File.directory?(src)
+            $stderr.puts "directory symlinks are not followed unless using JRuby; #{entry} contents not in archive" \
+              if File.symlink?(entry) && !defined?(JRUBY_VERSION)
+            zipfile.mkdir(entry)
+          elsif File.symlink?(src)
+            zipfile.get_output_stream(entry) {|f| f << File.read(src) }
+          else
+            zipfile.add(entry, src)
+          end
+        end
+      end
+    end
+
+    def entry_in_jar(jar, entry)
+      Zip::ZipFile.open(jar) do |zf|
+        zf.get_input_stream(entry) {|io| StringIO.new(io.read) }
+      end
+    end
+
+    # Java-boosted jar creation for JRuby; replaces #create_jar and
+    # #entry_in_jar with Java version
+    require 'warbler_jar' if defined?(JRUBY_VERSION) && JRUBY_VERSION >= "1.5"
+  end
+
+  # Warbler::War is Deprecated. Please use Warbler::Jar.
+  class War < Jar
+    def initialize(*)
+      super
+      $stderr.puts "Warbler::War is deprecated. Please replace all occurrences with Warbler::Jar."
+    end
+  end
+end