rdmopensource-warbler 1.1.0

data/lib/warbler/version.rb

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

data/lib/warbler/war.rb

@@ -0,0 +1,226 @@
+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)
+      # Need to use the version of JRuby in the application to compile it
+      compiled_ruby_files = config.compiled_ruby_files.to_a
+
+      return if compiled_ruby_files.empty?
+
+      run_javac(config, compiled_ruby_files)
+      replace_compiled_ruby_files(config, compiled_ruby_files)
+    end
+
+    def run_javac(config, compiled_ruby_files)
+      %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)
+    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$/
+          require 'erb'
+          erb = ERB.new(File.open(wf) {|f| f.read })
+          contents = StringIO.new(erb.result(erb_binding(config.webxml)))
+          @files[apply_pathmaps(config, wf, :webinf)] = contents
+        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|
+        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 Gemfile and .bundle/environment.rb 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'
+          @files[apply_pathmaps(config, '.bundle/environment.rb', :application)] = '.bundle/war-environment.rb'
+        end
+      end
+    end
+
+    private
+    def add_with_pathmaps(config, f, map_type)
+      @files[apply_pathmaps(config, f, map_type)] = f
+    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

data/spec/sample/app/controllers/application.rb

@@ -0,0 +1,15 @@
+# Filters added to this controller apply to all controllers in the application.
+# Likewise, all the methods added will be available for all controllers.
+
+class ApplicationController < ActionController::Base
+  helper :all # include all helpers, all the time
+
+  # See ActionController::RequestForgeryProtection for details
+  # Uncomment the :secret if you're not using the cookie session store
+  protect_from_forgery # :secret => '9eae08a7d153857faa33c1101e411ce1'
+  
+  # See ActionController::Base for details 
+  # Uncomment this to filter the contents of submitted sensitive data parameters
+  # from your application log (in this case, all fields with names like "password"). 
+  # filter_parameter_logging :password
+end

data/spec/sample/app/helpers/application_helper.rb

@@ -0,0 +1,3 @@
+# Methods added to this helper will be available to all templates in the application.
+module ApplicationHelper
+end

data/spec/sample/config/boot.rb

@@ -0,0 +1,109 @@
+# Don't change this file!
+# Configure your app in config/environment.rb and config/environments/*.rb
+
+RAILS_ROOT = "#{File.dirname(__FILE__)}/.." unless defined?(RAILS_ROOT)
+
+module Rails
+  class << self
+    def boot!
+      unless booted?
+        preinitialize
+        pick_boot.run
+      end
+    end
+
+    def booted?
+      defined? Rails::Initializer
+    end
+
+    def pick_boot
+      (vendor_rails? ? VendorBoot : GemBoot).new
+    end
+
+    def vendor_rails?
+      File.exist?("#{RAILS_ROOT}/vendor/rails")
+    end
+
+    def preinitialize
+      load(preinitializer_path) if File.exist?(preinitializer_path)
+    end
+
+    def preinitializer_path
+      "#{RAILS_ROOT}/config/preinitializer.rb"
+    end
+  end
+
+  class Boot
+    def run
+      load_initializer
+      Rails::Initializer.run(:set_load_path)
+    end
+  end
+
+  class VendorBoot < Boot
+    def load_initializer
+      require "#{RAILS_ROOT}/vendor/rails/railties/lib/initializer"
+      Rails::Initializer.run(:install_gem_spec_stubs)
+    end
+  end
+
+  class GemBoot < Boot
+    def load_initializer
+      self.class.load_rubygems
+      load_rails_gem
+      require 'initializer'
+    end
+
+    def load_rails_gem
+      if version = self.class.gem_version
+        gem 'rails', version
+      else
+        gem 'rails'
+      end
+    rescue Gem::LoadError => load_error
+      $stderr.puts %(Missing the Rails #{version} gem. Please `gem install -v=#{version} rails`, update your RAILS_GEM_VERSION setting in config/environment.rb for the Rails version you do have installed, or comment out RAILS_GEM_VERSION to use the latest version installed.)
+      exit 1
+    end
+
+    class << self
+      def rubygems_version
+        Gem::RubyGemsVersion if defined? Gem::RubyGemsVersion
+      end
+
+      def gem_version
+        if defined? RAILS_GEM_VERSION
+          RAILS_GEM_VERSION
+        elsif ENV.include?('RAILS_GEM_VERSION')
+          ENV['RAILS_GEM_VERSION']
+        else
+          parse_gem_version(read_environment_rb)
+        end
+      end
+
+      def load_rubygems
+        require 'rubygems'
+
+        unless rubygems_version >= '0.9.4'
+          $stderr.puts %(Rails requires RubyGems >= 0.9.4 (you have #{rubygems_version}). Please `gem update --system` and try again.)
+          exit 1
+        end
+
+      rescue LoadError
+        $stderr.puts %(Rails requires RubyGems >= 0.9.4. Please install RubyGems and try again: http://rubygems.rubyforge.org)
+        exit 1
+      end
+
+      def parse_gem_version(text)
+        $1 if text =~ /^[^#]*RAILS_GEM_VERSION\s*=\s*["']([!~<>=]*\s*[\d.]+)["']/
+      end
+
+      private
+        def read_environment_rb
+          File.read("#{RAILS_ROOT}/config/environment.rb")
+        end
+    end
+  end
+end
+
+# All that for this:
+Rails.boot!

data/spec/sample/config/database.yml

@@ -0,0 +1,19 @@
+# SQLite version 3.x
+#   gem install sqlite3-ruby (not necessary on OS X Leopard)
+development:
+  adapter: sqlite3
+  database: db/development.sqlite3
+  timeout: 5000
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  adapter: sqlite3
+  database: db/test.sqlite3
+  timeout: 5000
+
+production:
+  adapter: sqlite3
+  database: db/production.sqlite3
+  timeout: 5000

data/spec/sample/config/environment.rb

@@ -0,0 +1,67 @@
+# Be sure to restart your server when you modify this file
+
+# Uncomment below to force Rails into production mode when
+# you don't control web/app server and can't set it the proper way
+# ENV['RAILS_ENV'] ||= 'production'
+
+# Specifies gem version of Rails to use when vendor/rails is not present
+RAILS_GEM_VERSION = '2.1.0' unless defined? RAILS_GEM_VERSION
+
+# Bootstrap the Rails environment, frameworks, and default configuration
+require File.join(File.dirname(__FILE__), 'boot')
+
+Rails::Initializer.run do |config|
+  # Settings in config/environments/* take precedence over those specified here.
+  # Application configuration should go into files in config/initializers
+  # -- all .rb files in that directory are automatically loaded.
+  # See Rails::Configuration for more options.
+
+  # Skip frameworks you're not going to use. To use Rails without a database
+  # you must remove the Active Record framework.
+  # config.frameworks -= [ :active_record, :active_resource, :action_mailer ]
+
+  # Specify gems that this application depends on. 
+  # They can then be installed with "rake gems:install" on new installations.
+  # config.gem "bj"
+  # config.gem "hpricot", :version => '0.6', :source => "http://code.whytheluckystiff.net"
+  # config.gem "aws-s3", :lib => "aws/s3"
+
+  # Only load the plugins named here, in the order given. By default, all plugins 
+  # in vendor/plugins are loaded in alphabetical order.
+  # :all can be used as a placeholder for all plugins not explicitly named
+  # config.plugins = [ :exception_notification, :ssl_requirement, :all ]
+
+  # Add additional load paths for your own custom dirs
+  # config.load_paths += %W( #{RAILS_ROOT}/extras )
+
+  # Force all environments to use the same logger level
+  # (by default production uses :info, the others :debug)
+  # config.log_level = :debug
+
+  # Make Time.zone default to the specified zone, and make Active Record store time values
+  # in the database in UTC, and return them converted to the specified local zone.
+  # Run "rake -D time" for a list of tasks for finding time zone names. Uncomment to use default local time.
+  config.time_zone = 'UTC'
+
+  # Your secret key for verifying cookie session data integrity.
+  # If you change this key, all old sessions will become invalid!
+  # Make sure the secret is at least 30 characters and all random, 
+  # no regular words or you'll be exposed to dictionary attacks.
+  config.action_controller.session = {
+    :session_key => '_sample_session',
+    :secret      => 'e747620fa6b20fae99c5fe0797091fe35a84dd367f4031d1a37cd61376ecce0537b5ae22c5d606e30be2a05ef303ee2aa39813080e6fdd6bb3bd932552313c5c'
+  }
+
+  # Use the database for sessions instead of the cookie-based default,
+  # which shouldn't be used to store highly confidential information
+  # (create the session table with "rake db:sessions:create")
+  # config.action_controller.session_store = :active_record_store
+
+  # Use SQL instead of Active Record's schema dumper when creating the test database.
+  # This is necessary if your schema can't be completely dumped by the schema dumper,
+  # like if you have constraints or database-specific column types
+  # config.active_record.schema_format = :sql
+
+  # Activate observers that should always be running
+  # config.active_record.observers = :cacher, :garbage_collector
+end