warbler_updated 2.1.0

data/lib/warbler/traits/war.rb

@@ -0,0 +1,260 @@
+#--
+# Copyright (c) 2010-2012 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
+  module Traits
+    # The War trait sets up the layout and generates web.xml for the war project.
+    class War
+      include Trait
+      include RakeHelper
+      include PathmapHelper
+
+      DEFAULT_GEM_PATH = '/WEB-INF/gems'
+
+      def self.detect?
+        Traits::Rails.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/**/{.[!.],.??*,*}"] # include dotfiles
+        config.jar_extension = 'war'
+        config.init_contents << "#{config.warbler_templates}/war.erb"
+      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.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' unless defined? JRubyJars.core_jar_path
+        require 'jruby-rack' unless defined? JRubyJars.jruby_rack_jar_path
+        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)
+        move_jars_to_webinf_lib(jar, config.move_jars_to_webinf_lib)
+        add_runnables(jar) if config.features.include?("runnable")
+        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.exclude( *(config.excludes.to_a) )
+        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[apply_pathmaps(config, wf, :webinf)] = jar.expand_erb(wf, config)
+          else
+            jar.files[apply_pathmaps(config, wf, :webinf)] = wf
+          end
+        end
+      end
+
+      def add_runnables(jar, main_class = 'WarMain')
+        main_class = main_class.sub('.class', '') # handles WarMain.class
+        unless config.manifest_file
+          manifest = Warbler::Jar::DEFAULT_MANIFEST.chomp + "Main-Class: #{main_class}\n"
+          jar.files['META-INF/MANIFEST.MF'] = StringIO.new(manifest)
+        end
+        [ 'JarMain', 'WarMain', main_class ].uniq.each do |klass|
+          jar.files["#{klass}.class"] = jar.entry_in_jar(WARBLER_JAR, "#{klass}.class")
+        end
+      end
+
+      def add_executables(jar)
+        webserver = WEB_SERVERS[config.webserver.to_s]
+        webserver.add(jar)
+        add_runnables jar, webserver.main_class || 'WarMain'
+      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
+
+      def move_jars_to_webinf_lib(jar, selector = nil)
+        return unless selector # default is false
+        selector = /.*/ if selector == true # move all if not a RegExp given
+        default_jar_paths = default_jar_files
+        default_jars = default_jar_paths.map { |file| File.basename(file) }
+        jar.files.keys.select { |k| k =~ /^WEB-INF\/.*\.jar$/ }.each do |k|
+          if k.start_with?('WEB-INF/lib/') # .jar already in WEB-INF/lib
+            if default_jars.include? k.sub('WEB-INF/lib/', '')
+              # exclude default jar (if it's not matched by selector) :
+              jar.files.delete(k) unless selector =~ File.basename(k)
+            end
+            next
+          end
+          next unless selector =~ File.basename(k)
+          # default jars might end up mapped twice as they're part of gems
+          next if default_jar_paths.include?(jar.files[k])
+          name = k.sub('WEB-INF', '')[1..-1].gsub(/[\/\\]/, '-')
+          jar.files["WEB-INF/lib/#{name}"] = jar.files[k]
+          jar.files[k] = empty_jar
+        end
+      end
+
+      def empty_jar
+        @empty_jar ||= begin
+          t = Tempfile.new(["empty", "jar"])
+          path = t.path
+          t.close!
+          ZipSupport.create(path) do |zipfile|
+            zipfile.mkdir("META-INF")
+            zipfile.get_output_stream("META-INF/MANIFEST.MF") {|f| f << ::Warbler::Jar::DEFAULT_MANIFEST }
+          end
+          at_exit { File.delete(path) }
+          path
+        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 do |name|
+          class_eval "def #{name}; method_missing(:#{name}); end"
+        end
+
+        def initialize(key = 'webxml')
+          @key = key
+          @table = Hash.new { |h, k|
+            new_ostruct_member!(k)
+            h[k] = WebxmlOpenStruct.new(k)
+          }
+
+          @servlet_filter_async = nil # true/false
+        end
+
+        def servlet_filter; @servlet_filter ||= 'org.jruby.rack.RackFilter' end
+        attr_writer :servlet_filter
+
+        def servlet_filter_name; @servlet_filter_name ||= 'RackFilter' end
+        attr_writer :servlet_filter_name
+
+        def servlet_filter_url_pattern; @servlet_filter_url_pattern ||= '/*' end
+        attr_writer :servlet_filter_url_pattern
+
+        attr_accessor :servlet_filter_async
+
+        def servlet_context_listener
+          case booter
+          when :rack
+            'org.jruby.rack.RackServletContextListener'
+          when :rails
+            'org.jruby.rack.rails.RailsServletContextListener'
+          else # default (due compatibility)
+            'org.jruby.rack.rails.RailsServletContextListener'
+          end
+        end
+
+        def servlet_context_listeners
+          @servlet_context_listeners ||= [ servlet_context_listener ]
+        end
+
+        def servlet_context_params(escape = true)
+          require 'cgi'; params = {}
+          @table.each do |k,v|
+            case v
+            when WebxmlOpenStruct
+              v.context_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
+          extra_ignored = Array === ignored ? ignored : []
+          params.delete_if { |k,_| ['ignored', *extra_ignored].include?(k.to_s) }
+          params
+        end
+        # @deprecated
+        alias_method :context_params, :servlet_context_params
+
+        def to_s
+          "No value for '#@key' found"
+        end
+
+        private
+
+        def method_missing(mid, *args)
+          len = args.length
+          if mname = mid[/.*(?==\z)/m]
+            if len != 1
+              raise ArgumentError, "wrong number of arguments (#{len} for 1)", caller(1)
+            end
+            self[mname] = args[0]
+          elsif len == 0
+            @table[mid]
+          else
+            err = NoMethodError.new "undefined method `#{mid}' for #{self}", mid, args
+            err.set_backtrace caller(1)
+            raise err
+          end
+        end
+
+        def respond_to_missing?(mid, include_private = false)
+          @table.key?(mid.to_s.chomp('=').to_sym) || super
+        end
+      end
+    end
+  end
+end

data/lib/warbler/traits.rb

@@ -0,0 +1,124 @@
+#--
+# Copyright (c) 2010-2012 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 'stringio'
+require 'tsort'
+
+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
+      TraitsDependencyArray.new(Traits.constants.map {|t| Traits.const_get(t)}).tsort.select {|tc| tc.detect? }
+    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 requirements
+        []
+      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.expand_path(File.join('..', '..', '#{path}'), __FILE__)\n")
+      # with __FILE__ = "uri:classloader:/META-INF/init.rb"
+      # ...  will end up as "uri:classloader://xxx-gem/lib"
+    end
+
+    def add_main_rb(jar, bin_path, params = nil)
+      binary = "".dup
+      binary << "ARGV.unshift('#{params}')\n" if params
+      binary << "load '#{bin_path}'"
+      jar.files['META-INF/main.rb'] = StringIO.new(binary)
+    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.marshal_dump.keys.each do |pm|
+          config.pathmaps.send(pm).each {|p| p.sub!(default_gem_path[1..-1], sub_gem_path)}
+        end
+        config.webxml["gem"]["path"] = config.gem_path if config.webxml
+      end
+    end
+
+    def jruby_jars
+      require 'jruby-jars'
+      FileList[JRubyJars.core_jar_path, JRubyJars.stdlib_jar_path]
+    end
+  end
+
+  class TraitsDependencyArray < Array
+    include TSort
+
+    alias tsort_each_node each
+    def tsort_each_child(node, &block)
+      node.requirements.each(&block)
+    end
+  end
+
+end
+
+require 'warbler/traits/jar'
+require 'warbler/traits/war'
+require 'warbler/traits/rails'
+require 'warbler/traits/rack'
+require 'warbler/traits/bundler'
+require 'warbler/traits/jbundler'
+require 'warbler/traits/gemspec'
+require 'warbler/traits/nogemspec'

data/lib/warbler/version.rb

@@ -0,0 +1,10 @@
+#--
+# Copyright (c) 2010-2012 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
+  VERSION = "2.1.0"
+end

data/lib/warbler/war.rb

@@ -0,0 +1,8 @@
+#--
+# Copyright (c) 2010-2012 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 'warbler/jar'

data/lib/warbler/web_server.rb

@@ -0,0 +1,125 @@
+module Warbler
+  class WebServer
+    class Artifact < Struct.new(:repo, :group_id, :artifact_id, :version)
+
+      def path_fragment
+        @path_fragment ||= "#{group_id.gsub('.', '/')}/#{artifact_id}/#{version}/#{artifact_id}-#{version}.jar"
+      end
+
+      def cached_path
+        @cached_path ||= File.join(local_repository, path_fragment)
+      end
+
+      def download_url
+        @download_url ||= "#{repo}/#{path_fragment}" #:nocov:
+      end
+
+      def local_path
+        unless File.exist?(cached_path)
+          puts "Downloading #{artifact_id}-#{version}.jar" #:nocov:
+          FileUtils.mkdir_p File.dirname(cached_path) #:nocov:
+          require 'open-uri'                    #:nocov:
+          begin
+            open(download_url) do |stream|        #:nocov:
+              File.open(cached_path, "wb") do |f| #:nocov:
+                while buf = stream.read(4096) #:nocov:
+                  f << buf                    #:nocov:
+                end                           #:nocov:
+              end                             #:nocov:
+            end                               #:nocov:
+          rescue => e
+            e.message.concat " - #{download_url}"
+            raise e
+          end
+        end
+        cached_path
+      end
+
+      @@local_repository = nil
+
+      def local_repository
+        @@local_repository ||= begin
+          m2_home = File.join(user_home, '.m2')
+          if File.exist?(settings = File.join(m2_home, 'settings.xml'))
+            local_repo = detect_local_repository(settings)
+          end
+          if local_repo.nil? && mvn_home = ENV['M2_HOME'] || ENV['MAVEN_HOME']
+            if File.exist?(settings = File.join(mvn_home, 'conf/settings.xml'))
+              local_repo = detect_local_repository(settings)
+            end
+          end
+          local_repo || File.join(m2_home, 'repository')
+        end
+      end
+
+      private
+
+      def user_home
+        ENV[ 'HOME' ] || begin
+          user_home = Dir.home if Dir.respond_to?(:home)
+          unless user_home
+            user_home = ENV_JAVA[ 'user.home' ] if Object.const_defined?(:ENV_JAVA)
+          end
+          user_home
+        end
+      end
+
+      def detect_local_repository(settings); require 'rexml/document'
+        doc = REXML::Document.new( File.read( settings ) )
+        if local_repo = doc.root.elements['localRepository']
+          if ( local_repo = local_repo.first )
+            local_repo = local_repo.value
+            local_repo = nil if local_repo.empty?
+          end
+        end
+        local_repo
+      end
+
+    end
+
+    def add(jar)
+      jar.files["WEB-INF/webserver.jar"] = @artifact.local_path
+    end
+
+    def main_class
+      'WarMain.class'
+    end
+  end
+
+  class JettyServer < WebServer
+    def initialize
+      @artifact = Artifact.new(ENV["MAVEN_REPO"] || "https://repo1.maven.org/maven2",
+                               "org.eclipse.jetty", "jetty-runner",
+                               ENV["WEBSERVER_VERSION"] || "9.2.9.v20150224")
+    end
+
+    def add(jar)
+      super
+      jar.files["WEB-INF/webserver.xml"] ||= StringIO.new(<<-CONFIG)
+<?xml version="1.0"?>
+<!DOCTYPE Configure PUBLIC "-//Jetty//Configure//EN" "http://www.eclipse.org/jetty/configure.dtd">
+
+<Configure id="Server" class="org.eclipse.jetty.server.Server">
+</Configure>
+CONFIG
+
+      jar.files["WEB-INF/webserver.properties"] ||= StringIO.new(<<-PROPS)
+mainclass = org.eclipse.jetty.runner.Runner
+args = args0,args1,args2,args3,args4,args5,args6
+props = jetty.home
+args0 = --host
+args1 = {{host}}
+args2 = --port
+args3 = {{port}}
+args4 = --config
+args5 = {{config}}
+args6 = {{warfile}}
+jetty.home = {{webroot}}
+PROPS
+    end
+  end
+
+  WEB_SERVERS = Hash.new { |hash,_| hash['jetty'] }
+  WEB_SERVERS['jetty'] = JettyServer.new
+
+end

data/lib/warbler/zip_support.rb

@@ -0,0 +1,13 @@
+require 'zip'
+
+module Warbler
+  class ZipSupport
+    def self.create(filename, &blk)
+      Zip::File.open(filename, Zip::File::CREATE, &blk)
+    end
+
+    def self.open(filename, &blk)
+      Zip::File.open(filename, &blk)
+    end
+  end
+end

data/lib/warbler.rb

@@ -0,0 +1,40 @@
+#--
+# Copyright (c) 2010-2012 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)
+  WARBLER_JAR = "#{WARBLER_HOME}/lib/warbler_jar.jar" unless defined?(WARBLER_JAR)
+
+  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/executable_helper'
+require 'warbler/rake_helper'
+require 'warbler/pathmap_helper'
+require 'warbler/platform_helper'
+require 'warbler/bundler_helper'
+require 'warbler/task'
+require 'warbler/application'
+require 'warbler/web_server'