warbler 1.2.1 → 1.3.0.beta1

data/lib/warbler/application.rb

@@ -22,27 +22,27 @@ class Warbler::Application < Rake::Application
     @name = 'warble'
 
     # Load the main warbler tasks
-    Warbler::Task.new
+    wt = Warbler::Task.new
 
-    task :default => :war
+    task :default => wt.name
 
-    desc "Generate a configuration file to customize your war"
-    task :config => "war:config"
+    desc "Generate a configuration file to customize your archive"
+    task :config => "#{wt.name}:config"
 
     desc "Install Warbler tasks in your Rails application"
-    task :pluginize => "war:pluginize"
+    task :pluginize => "#{wt.name}:pluginize"
 
     desc "Feature: package gem repository inside a jar"
-    task :gemjar => "war:gemjar"
+    task :gemjar => "#{wt.name}:gemjar"
 
     desc "Feature: make an executable archive"
-    task :executable => "war:executable"
+    task :executable => "#{wt.name}:executable"
 
     desc "Feature: precompile all Ruby files"
-    task :compiled => "war:compiled"
+    task :compiled => "#{wt.name}:compiled"
 
     desc "Display version of Warbler"
-    task :version => "war:version"
+    task :version => "#{wt.name}:version"
   end
 
   # Loads the project Rakefile in a separate application

data/lib/warbler/config.rb

@@ -5,16 +5,19 @@
 # See the file LICENSE.txt for details.
 #++
 
-require 'ostruct'
+require 'set'
+require 'warbler/gems'
+require 'warbler/traits'
 
 module Warbler
-  # Warbler war file assembly configuration class.
+  # Warbler archive 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)
 
+    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
@@ -22,6 +25,11 @@ module Warbler
     # - 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
 
@@ -68,9 +76,12 @@ module Warbler
     # 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 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
@@ -130,39 +141,36 @@ module Warbler
     #     <%= webxml.context_params['maybe.present.key'] || 'default' %>
     attr_accessor :webxml
 
+    attr_reader :warbler_templates
+
     def initialize(warbler_home = WARBLER_HOME)
-      @warbler_home = warbler_home
+      super()
+
+      @warbler_home      = warbler_home
       @warbler_templates = "#{WARBLER_HOME}/lib/warbler/templates"
-      @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
-      @gem_excludes = []
-      @exclude_logs = true
-      @public_html = FileList["public/**/*"]
-      @pathmaps    = default_pathmaps
-      @webxml      = default_webxml_config
-      @rails_root  = default_rails_root
-      @war_name    = File.basename(@rails_root)
-      @bundler     = true
-      @bundle_without = ["development", "test"]
-      @webinf_files = default_webinf_files
-      @init_filename = 'META-INF/init.rb'
-      @init_contents = ["#{@warbler_templates}/config.erb"]
-
-      auto_detect_frameworks
+      @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?
-      update_gem_path
-      detect_bundler_gems
+      after_configure
 
-      framework_init = "#{@warbler_templates}/#{@webxml.booter}.erb"
-      @init_contents << framework_init if File.exist?(framework_init)
       @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
@@ -176,185 +184,31 @@ module Warbler
       @gem_path[1..-1]
     end
 
+    # Deprecated
+    def war_name
+      warn "config.war_name deprecated; replace with config.jar_name" #:nocov:
+      jar_name                  #:nocov:
+    end
+
+    # Deprecated
+    def war_name=(w)
+      warn "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{^#{@rails_root}/(.*)}
+      if warbler =~ %r{^#{Dir.getwd}/(.*)}
         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_rails_root
-      File.expand_path(defined?(Rails.root) ? Rails.root : (defined?(RAILS_ROOT) ? RAILS_ROOT : Dir.getwd))
-    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'
-        gemfile = Pathname.new("Gemfile").expand_path
-        root = gemfile.dirname
-        lockfile = root.join('Gemfile.lock')
-        definition = Bundler::Definition.build(gemfile, lockfile, nil)
-        groups = definition.groups - @bundle_without.map {|g| g.to_sym}
-        definition.specs_for(groups).each {|spec| @gems << spec }
-        @init_contents << StringIO.new("ENV['BUNDLE_WITHOUT'] = '#{@bundle_without.join(':')}'\n")
-      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
-      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 << 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 gem).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(escape = true)
-      require 'cgi'
-      params = {}
-      @table.each do |k,v|
-        case v
-        when WebxmlOpenStruct
-          nested_params = v.context_params
-          nested_params.each do |nk,nv|
-            params["#{escape ? CGI::escapeHTML(k.to_s) : k.to_s}.#{nk}"] = nv
-          end
-        else
-          params[escape ? CGI::escapeHTML(k.to_s) : k.to_s] = escape ? CGI::escapeHTML(v.to_s) : 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"
+    def dump
+      YAML::dump(self.dup.tap{|c| c.dump_traits })
     end
+    public :dump
   end
 end

data/lib/warbler/gems.rb

@@ -11,7 +11,7 @@ module Warbler
   # 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)
@@ -19,7 +19,7 @@ module Warbler
         gems.each {|gem| self << gem }
       end
     end
-    
+
     def <<(gem)
       self[gem] ||= ANY_VERSION
     end

data/lib/warbler/jar.rb

@@ -0,0 +1,247 @@
+#--
+# Copyright (c) 2010 Engine Yard, Inc.
+# This source code is available under the MIT license.
+# See the file LICENSE.txt for details.
+#++
+
+require 'zip/zip'
+require 'stringio'
+
+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 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
+
+      # skip gems with no load path
+      return if spec.loaded_from == ""
+
+      add_with_pathmaps(config, spec.loaded_from, :gemspecs)
+      spec.files.each do |f|
+        f = f[2..-1] if f =~ /^\.\//
+        next if config.gem_excludes && config.gem_excludes.any? {|rx| f =~ rx }
+        src = File.join(spec.full_gem_path, f)
+        # some gemspecs may have incorrect file listings
+        next unless File.exist?(src)
+        @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)
+        warn "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)
+            warn "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
+      warn "Warbler::War is deprecated. Please replace all occurrences with Warbler::Jar."
+    end
+  end
+end