warbler 1.2.1 → 1.3.0.beta1

data/lib/warbler/traits/war.rb

@@ -0,0 +1,191 @@
+#--
+# Copyright (c) 2010 Engine Yard, Inc.
+# This source code is available under the MIT license.
+# See the file LICENSE.txt for details.
+#++
+
+require 'ostruct'
+
+module Warbler
+  module Traits
+    # The War trait sets up the layout and generates web.xml for the war project.
+    class War
+      include Trait
+
+      DEFAULT_GEM_PATH = '/WEB-INF/gems'
+
+      def self.detect?
+        Traits::Rails.detect? || Traits::Merb.detect? || Traits::Rack.detect?
+      end
+
+      def before_configure
+        config.gem_path      = DEFAULT_GEM_PATH
+        config.pathmaps      = default_pathmaps
+        config.webxml        = default_webxml_config
+        config.webinf_files  = default_webinf_files
+        config.java_libs     = default_jar_files
+        config.public_html   = FileList["public/**/*"]
+        config.jar_extension = 'war'
+      end
+
+      def after_configure
+        update_gem_path(DEFAULT_GEM_PATH)
+      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     = ["#{config.relative_gem_path}/specifications/%f"]
+        p.gems         = ["#{config.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 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 update_archive(jar)
+        add_public_files(jar)
+        add_webxml(jar)
+        add_executables(jar) if config.features.include?("executable")
+        add_gemjar(jar) if config.features.include?("gemjar")
+      end
+
+      # Add public/static assets to the root of the war file.
+      def add_public_files(jar)
+        config.public_html.map {|f| jar.add_with_pathmaps(config, f, :public_html) }
+      end
+
+      # Add web.xml and other WEB-INF configuration files from
+      # config.webinf_files to the war file.
+      def add_webxml(jar)
+        config.webinf_files.each do |wf|
+          if wf =~ /\.erb$/
+            jar.files[jar.apply_pathmaps(config, wf, :webinf)] = jar.expand_erb(wf, config)
+          else
+            jar.files[jar.apply_pathmaps(config, wf, :webinf)] = wf
+          end
+        end
+      end
+
+      def add_executables(jar)
+        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}")
+        unless File.exist?(winstone_jar)
+          # 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
+
+        jar.files['META-INF/MANIFEST.MF'] = StringIO.new(Warbler::Jar::DEFAULT_MANIFEST.chomp + "Main-Class: WarMain\n")
+        jar.files['WarMain.class'] = jar.entry_in_jar("#{WARBLER_HOME}/lib/warbler_jar.jar", 'WarMain.class')
+        jar.files['WEB-INF/winstone.jar'] = winstone_jar
+      end
+
+      def add_gemjar(jar)
+        gem_jar = Warbler::Jar.new
+        gem_path = Regexp::quote(config.relative_gem_path)
+        gems = jar.files.select{|k,v| k =~ %r{#{gem_path}/} }
+        gems.each do |k,v|
+          gem_jar.files[k.sub(%r{#{gem_path}/}, '')] = v
+        end
+        jar.files["WEB-INF/lib/gems.jar"] = "tmp/gems.jar"
+        jar.files.reject!{|k,v| k =~ /#{gem_path}/ || k == "WEB-INF/tmp/gems.jar"}
+        mkdir_p "tmp"
+        gem_jar.add_manifest
+        gem_jar.create("tmp/gems.jar")
+      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"
+        end
+      end
+    end
+  end
+end

data/lib/warbler/traits.rb

@@ -0,0 +1,105 @@
+#--
+# Copyright (c) 2010 Engine Yard, Inc.
+# This source code is available under the MIT license.
+# See the file LICENSE.txt for details.
+#++
+
+require 'stringio'
+
+module Warbler
+  # Traits are project configuration characteristics that correspond
+  # to the framework or project layout. Each trait corresponds to a
+  # class in Warbler::Traits that contains baked-in knowledge about
+  # the kind of project and how it should be packed into the jar or
+  # war file.
+  module Traits
+    attr_accessor :traits
+
+    def initialize
+      @traits = auto_detect_traits
+    end
+
+    def auto_detect_traits
+      Traits.constants.map {|t| Traits.const_get(t)}.select {|tc| tc.detect? }.sort
+    end
+
+    def before_configure
+      trait_objects.each {|t| t.before_configure }
+    end
+
+    def after_configure
+      trait_objects.each {|t| t.after_configure }
+    end
+
+    def trait_objects
+      @trait_objects ||= @traits.map {|klass| klass.new(self) }
+    end
+
+    def update_archive(jar)
+      trait_objects.each {|t| t.update_archive(jar) }
+    end
+
+    def dump_traits
+      @trait_objects = nil
+      @traits.collect! {|t| t.name }
+    end
+  end
+
+  # Each trait class includes this module to receive shared functionality.
+  module Trait
+    module ClassMethods
+      def <=>(o)
+        requires?(o) ? 1 : (o.requires?(self) ? -1 : 0)
+      end
+
+      def requires?(t)
+        false
+      end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    attr_reader :config
+    def initialize(config)
+      @config = config
+    end
+
+    def before_configure
+    end
+
+    def after_configure
+    end
+
+    def update_archive(jar)
+    end
+
+    def add_init_load_path(path)
+      config.init_contents << StringIO.new("$LOAD_PATH.unshift __FILE__.sub(/!.*/, '!/#{path}')\n")
+    end
+
+    def add_main_rb(jar, bin_path)
+      jar.files['META-INF/main.rb'] = StringIO.new("load '#{bin_path}'")
+    end
+
+    def update_gem_path(default_gem_path)
+      if config.gem_path != default_gem_path
+        config.gem_path = "/#{config.gem_path}" unless config.gem_path =~ %r{^/}
+        sub_gem_path = config.gem_path[1..-1]
+        config.pathmaps.gemspecs.each {|p| p.sub!(default_gem_path[1..-1], sub_gem_path)}
+        config.pathmaps.gems.each {|p| p.sub!(default_gem_path[1..-1], sub_gem_path)}
+        config.webxml["gem"]["path"] = config.gem_path if config.webxml
+      end
+    end
+  end
+end
+
+require 'warbler/traits/jar'
+require 'warbler/traits/war'
+require 'warbler/traits/rails'
+require 'warbler/traits/merb'
+require 'warbler/traits/rack'
+require 'warbler/traits/bundler'
+require 'warbler/traits/gemspec'
+require 'warbler/traits/nogemspec'

data/lib/warbler/version.rb

@@ -6,5 +6,5 @@
 #++
 
 module Warbler
-  VERSION = "1.2.1"
+  VERSION = "1.3.0.beta1"
 end

data/lib/warbler/war.rb

@@ -1,247 +1 @@
-require 'zip/zip'
-
-module Warbler
-  # Class that holds the files that will be stored in the war file.
-  # The #files attribute contains a hash of pathnames inside the war
-  # 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 War
-    DEFAULT_MANIFEST = %{Manifest-Version: 1.0\nCreated-By: Warbler #{Warbler::VERSION}\n\n}
-
-    attr_reader :files
-    attr_reader :webinf_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_webinf_files(config)
-      find_java_libs(config)
-      find_java_classes(config)
-      find_gems_files(config)
-      find_public_files(config)
-      add_webxml(config)
-      add_manifest(config)
-      add_bundler_files(config)
-      add_init_file(config)
-    end
-
-    # Create the war file. The single argument can either be a
-    # Warbler::Config or a filename of the war file to create.
-    def create(config_or_path)
-      war_path = config_or_path
-      if Warbler::Config === config_or_path
-        war_path = "#{config_or_path.war_name}.war"
-        war_path = File.join(config_or_path.autodeploy_dir, war_path) if config_or_path.autodeploy_dir
-      end
-      rm_f war_path
-      ensure_directory_entries
-      puts "Creating #{war_path}"
-      create_war war_path, @files
-    end
-
-    # Add web.xml and other WEB-INF configuration files from
-    # config.webinf_files to the war file.
-    def add_webxml(config)
-      config.webinf_files.each do |wf|
-        if wf =~ /\.erb$/
-          @files[apply_pathmaps(config, wf, :webinf)] = expand_erb(wf, config)
-        else
-          @files[apply_pathmaps(config, wf, :webinf)] = wf
-        end
-      end
-    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 public/static assets to the root of the war file.
-    def find_public_files(config)
-      config.public_html.map {|f| add_with_pathmaps(config, f, :public_html) }
-    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|
-        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 WEB-INF.
-    def find_webinf_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
-      @webinf_filelist = FileList[*(config.dirs.map{|d| "#{d}/**/*"})]
-      @webinf_filelist.include *(config.includes.to_a)
-      @webinf_filelist.exclude *(config.excludes.to_a)
-      @webinf_filelist.map {|f| add_with_pathmaps(config, f, :application) }
-    end
-
-    # Add Bundler Gemfiles to the war file.
-    def add_bundler_files(config)
-      if config.bundler
-        @files[apply_pathmaps(config, 'Gemfile', :application)] = 'Gemfile'
-        if File.exist?('Gemfile.lock')
-          @files[apply_pathmaps(config, 'Gemfile.lock', :application)] = 'Gemfile.lock'
-        end
-      end
-    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
-
-    private
-    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.webxml)))
-    end
-
-    def erb_binding(webxml)
-      binding
-    end
-
-    def apply_pathmaps(config, file, pathmaps)
-      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_war(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
-
-    # Java-boosted war creation for JRuby; replaces #create_war with Java version
-    require 'warbler_war' if defined?(JRUBY_VERSION) && JRUBY_VERSION >= "1.5"
-  end
-end
+require 'warbler/jar'

data/lib/warbler.rb

@@ -5,8 +5,8 @@
 # See the file LICENSE.txt for details.
 #++
 
-# Warbler is a lightweight, flexible, Rake-based system for packaging your Rails apps
-# into .war files.
+# 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)
 
@@ -29,8 +29,5 @@ module Warbler
 end
 
 require 'warbler/version'
-require 'warbler/gems'
-require 'warbler/config'
-require 'warbler/war'
 require 'warbler/task'
 require 'warbler/application'

data/spec/sample_jar/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2010-11-03
+
+* 1 major enhancement
+
+  * Birthday!
+

data/spec/sample_jar/Manifest.txt

@@ -0,0 +1,8 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/sample_jar
+lib/sample_jar.rb
+test/test_sample_jar.rb

data/spec/sample_jar/README.txt

@@ -0,0 +1,30 @@
+= sample_jar
+
+== DESCRIPTION:
+
+Sample jar application for Warbler specs.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 Nick Sieger
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/spec/sample_jar/lib/sample_jar.rb

@@ -0,0 +1,6 @@
+class SampleJar
+  VERSION = '1.0.0'
+  def self.hello
+    puts "Hello World!"
+  end
+end

data/spec/sample_jar/sample_jar.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{sample_jar}
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Nick Sieger"]
+  s.date = %q{2010-11-03}
+  s.default_executable = %q{sample_jar}
+  s.description = %q{Sample jar application for Warbler specs.}
+  s.email = ["nick@nicksieger.com"]
+  s.executables = ["sample_jar"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.txt"]
+  s.files = ["History.txt", "Manifest.txt", "README.txt", "Rakefile", "bin/sample_jar", "lib/sample_jar.rb", "test/test_sample_jar.rb"]
+  s.rdoc_options = ["--main", "README.txt"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{sample_jar}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Sample jar application for Warbler specs.}
+  s.test_files = ["test/test_sample_jar.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rubyzip>, [">= 0"])
+      s.add_development_dependency(%q<rubyforge>, [">= 2.0.4"])
+      s.add_development_dependency(%q<hoe>, [">= 2.6.2"])
+    else
+      s.add_dependency(%q<rubyzip>, [">= 0"])
+      s.add_dependency(%q<rubyforge>, [">= 2.0.4"])
+      s.add_dependency(%q<hoe>, [">= 2.6.2"])
+    end
+  else
+    s.add_dependency(%q<rubyzip>, [">= 0"])
+    s.add_dependency(%q<rubyforge>, [">= 2.0.4"])
+    s.add_dependency(%q<hoe>, [">= 2.6.2"])
+  end
+end

data/spec/sample_jar/test/test_sample_jar.rb

@@ -0,0 +1,8 @@
+require "test/unit"
+require "sample_jar"
+
+class TestSampleJar < Test::Unit::TestCase
+  def test_sanity
+    SampleJar.hello
+  end
+end