lucidimagination-warbler 1.3.2.dev

data/lib/warbler/task.rb

@@ -0,0 +1,183 @@
+#--
+# 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'
+require 'rake/tasklib'
+require 'warbler/config'
+require 'warbler/jar'
+
+module Warbler
+  # Warbler Rake task.  Allows defining multiple configurations inside the same
+  # Rakefile by using different task names.
+  #
+  # To define multiple Warbler configurations in a single project, use
+  # code like the following in a Rakefile:
+  #
+  #     Warbler::Task.new("war1", Warbler::Config.new do |config|
+  #       config.jar_name = "war1"
+  #       # ...
+  #     end
+  #     Warbler::Task.new("war2", Warbler::Config.new do |config|
+  #       config.jar_name = "war2"
+  #       # ...
+  #     end
+  #
+  # With this setup, you can create two separate war files two
+  # different configurations by running <tt>rake war1 war2</tt>.
+  class Task < Rake::TaskLib
+    # Task name
+    attr_accessor :name
+
+    # Warbler::Config
+    attr_accessor :config
+
+    # Warbler::Jar
+    attr_accessor :jar
+
+    def initialize(name = nil, config = nil)
+      @config = config
+      if @config.nil? && File.exists?(Config::FILE)
+        @config = eval(File.open(Config::FILE) {|f| f.read})
+      end
+      @config ||= Config.new
+      unless @config.kind_of? Config
+        $stderr.puts "Warbler::Config not provided by override in initializer or #{Config::FILE}; using defaults"
+        @config = Config.new
+      end
+      @name = name || @config.jar_extension
+      @jar = Warbler::Jar.new
+      yield self if block_given?
+      define_tasks
+    end
+
+    # Deprecated: attr_accessor :war
+    alias war jar
+
+    private
+    def define_tasks
+      define_main_task
+      namespace name do
+        define_clean_task
+        define_compiled_task
+        define_files_task
+        define_jar_task
+        define_debug_task
+        define_config_task
+        define_pluginize_task
+        define_version_task
+        define_extra_tasks
+      end
+    end
+
+    def define_main_task
+      desc "Create the project #{config.jar_extension} file"
+      task @name do
+        unless @config.features.empty?
+          @config.features.each do |feature|
+            t = "#@name:#{feature}"
+            unless Rake.application.lookup(t)
+              $stderr.puts "unknown feature `#{feature}', ignoring"
+              next
+            end
+            Rake::Task[t].invoke
+          end
+        end
+        # Invoke this way so custom dependencies can be defined before
+        # the file find routine is run
+        ["#{@name}:files", "#{@name}:jar"].each do |t|
+          Rake::Task[t].invoke
+        end
+      end
+    end
+
+    def define_clean_task
+      desc "Remove the project #{config.jar_extension} file"
+      task "clean" do
+        rm_f "#{config.jar_name}.#{config.jar_extension}"
+      end
+      task "clear" => "#{name}:clean"
+    end
+
+    def define_compiled_task
+      task "compiled" do
+        jar.compile(config)
+        task @name do
+          rm_f config.compiled_ruby_files.map {|f| f.sub(/\.rb$/, '.class') }
+        end
+      end
+    end
+
+    def define_files_task
+      task "files" do
+        jar.apply(config)
+      end
+    end
+
+    def define_jar_task
+      task "jar" do
+        jar.create(config)
+      end
+    end
+
+    def define_debug_task
+      desc "Dump diagnostic information"
+      task "debug" => "files" do
+        require 'yaml'
+        puts config.dump
+        jar.files.each {|k,v| puts "#{k} -> #{String === v ? v : '<blob>'}"}
+      end
+      task "debug:includes" => "files" do
+        puts "", "included files:"
+        puts *war.app_filelist.include
+      end
+      task "debug:excludes" => "files" do
+        puts "", "excluded files:"
+        puts *war.app_filelist.exclude
+      end
+    end
+
+    def define_extra_tasks
+      @config.define_tasks
+    end
+
+    def define_config_task
+      task "config" do
+        if File.exists?(Warbler::Config::FILE) && ENV["FORCE"].nil?
+          puts "There's another bird sitting on my favorite branch"
+          puts "(file '#{Warbler::Config::FILE}' already exists. Pass argument FORCE=1 to override)"
+        elsif !File.directory?("config")
+          puts "I'm confused; my favorite branch is missing"
+          puts "(directory 'config' is missing)"
+        else
+          cp "#{Warbler::WARBLER_HOME}/warble.rb", Warbler::Config::FILE
+        end
+      end
+    end
+
+    def define_pluginize_task
+      task "pluginize" do
+        if !Dir["vendor/plugins/warbler*"].empty? && ENV["FORCE"].nil?
+          puts "I found an old nest in vendor/plugins; please trash it so I can make a new one"
+          puts "(directory vendor/plugins/warbler* exists)"
+        else
+          rm_rf FileList["vendor/plugins/warbler*"], :verbose => false
+          mkdir_p "vendor/plugins/warbler/tasks"
+          File.open("vendor/plugins/warbler/tasks/warbler.rake", "w") do |f|
+            f.puts "require 'warbler'"
+            f.puts "Warbler::Task.new"
+          end
+        end
+      end
+    end
+
+    def define_version_task
+      task "version" do
+        puts "Warbler version #{Warbler::VERSION}"
+      end
+    end
+  end
+end

data/lib/warbler/templates/bundler.erb

@@ -0,0 +1,3 @@
+ENV['BUNDLE_WITHOUT'] = '<%= config.bundle_without.join(':') %>'
+ENV['BUNDLE_GEMFILE'] = '<%= config.bundler[:gemfile].basename %>'
+<% if config.bundler[:frozen] %>ENV['BUNDLE_FROZEN'] = '1'<% end %>

data/lib/warbler/templates/config.erb

@@ -0,0 +1 @@
+WARBLER_CONFIG = <%= config.webxml ? config.webxml.context_params(false).inspect : '{}' %>

data/lib/warbler/templates/jar.erb

@@ -0,0 +1,5 @@
+<% if config.relative_gem_path.empty? %>
+ENV['GEM_HOME'] ||= File.expand_path('../..', __FILE__)
+<% else %>
+ENV['GEM_HOME'] ||= File.expand_path('../../<%= config.relative_gem_path %>', __FILE__)
+<% end %>

data/lib/warbler/templates/rack.erb

@@ -0,0 +1 @@
+ENV['RACK_ENV'] = '<%= (params = config.webxml.context_params; params['rack.env']) %>'

data/lib/warbler/templates/rails.erb

@@ -0,0 +1 @@
+ENV['RAILS_ENV'] = '<%= config.webxml.rails.env %>'

data/lib/warbler/templates/war.erb

@@ -0,0 +1 @@
+ENV['GEM_HOME'] ||= $servlet_context.getRealPath('<%= config.gem_path %>')

data/lib/warbler/traits.rb

@@ -0,0 +1,107 @@
+#--
+# 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 '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.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
+  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/traits/bundler.rb

@@ -0,0 +1,104 @@
+#--
+# 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
+  module Traits
+    # The Bundler trait uses Bundler to determine gem dependencies to
+    # be added to the project.
+    class Bundler
+      include Trait
+
+      def self.detect?
+        File.exist?(ENV['BUNDLE_GEMFILE'] || "Gemfile")
+      end
+
+      def self.requires?(trait)
+        trait == Traits::War || trait == Traits::Jar
+      end
+
+      def before_configure
+        config.bundler = true
+        config.bundle_without = ["development", "test"]
+      end
+
+      def after_configure
+        add_bundler_gems if config.bundler
+      end
+
+      def add_bundler_gems
+	require 'bundler'
+        config.gems.clear
+        config.gem_dependencies = false # Bundler takes care of these
+        config.bundler = {}
+
+        bundler_specs.each do |spec|
+          # Bundler HAX -- fixup bad #loaded_from attribute in fake
+          # bundler gemspec from bundler/source.rb
+          if spec.name == "bundler"
+            full_gem_path = Pathname.new(spec.full_gem_path)
+            tries = 2
+            (full_gem_path = full_gem_path.dirname; tries -= 1) while tries > 0 && !full_gem_path.join('bundler.gemspec').exist?
+            spec.loaded_from = full_gem_path.to_s
+          end
+
+          case spec.source
+          when ::Bundler::Source::Git
+            config.bundler[:git_specs] ||= []
+            config.bundler[:git_specs] << spec
+          when ::Bundler::Source::Path
+            $stderr.puts("warning: Bundler `path' components are not currently supported.",
+                         "The `#{spec.full_name}' component was not bundled.",
+                         "Your application may fail to boot!")
+          else
+            config.gems << spec
+          end
+        end
+        config.bundler[:gemfile]  = ::Bundler.default_gemfile
+        config.bundler[:lockfile] = ::Bundler.default_lockfile
+        config.bundler[:frozen] = ::Bundler.settings[:frozen]
+        config.excludes += [::Bundler.settings[:path]] if ::Bundler.settings[:path]
+        config.init_contents << "#{config.warbler_templates}/bundler.erb"
+      end
+
+      def update_archive(jar)
+        add_bundler_files(jar) if config.bundler
+      end
+
+      # Add Bundler Gemfiles and git repositories to the archive.
+      def add_bundler_files(jar)
+        pwd = Pathname.new(Dir.pwd)
+        gemfile  = config.bundler[:gemfile].relative_path_from(pwd).to_s
+        lockfile = config.bundler[:lockfile].relative_path_from(pwd).to_s
+        jar.files[jar.apply_pathmaps(config, gemfile, :application)] = config.bundler[:gemfile].to_s
+        if File.exist?(lockfile)
+          jar.files[jar.apply_pathmaps(config, lockfile, :application)] = config.bundler[:lockfile].to_s
+        end
+        if config.bundler[:git_specs]
+          pathmap = "#{config.relative_gem_path}/bundler/gems/%p"
+          pathmap.sub!(%r{^/+}, '')
+          config.pathmaps.git = [pathmap]
+          config.bundler[:git_specs].each do |spec|
+            full_gem_path = Pathname.new(spec.full_gem_path)
+            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 }
+              jar.files[jar.apply_pathmaps(config, File.join(full_gem_path.basename, f), :git)] = src
+            end
+          end
+        end
+      end
+
+      private
+
+      def bundler_specs
+	bundle_without = config.bundle_without.map {|s| s.to_sym}
+	definition = ::Bundler.definition
+        definition.specs_for(definition.groups - bundle_without)
+      end
+    end
+  end
+end

data/lib/warbler/traits/gemspec.rb

@@ -0,0 +1,59 @@
+#--
+# 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
+  module Traits
+    # The Gemspec trait reads a .gemspec file to determine the files,
+    # executables, require paths, and dependencies for a project.
+    class Gemspec
+      include Trait
+
+      def self.detect?
+        !Dir['*.gemspec'].empty?
+      end
+
+      def before_configure
+        @spec_file = Dir['*.gemspec'].first
+        require 'yaml'
+        @spec = File.open(@spec_file) {|f| Gem::Specification.from_yaml(f) } rescue Gem::Specification.load(@spec_file)
+        @spec.runtime_dependencies.each {|g| config.gems << g }
+        config.dirs = []
+        config.compiled_ruby_files = @spec.files.select {|f| f =~ /\.rb$/}
+      end
+
+      def after_configure
+        @spec.require_paths.each do |p|
+          add_init_load_path(config.pathmaps.application.inject(p) {|pm,x| pm.pathmap(x)})
+        end
+      end
+
+      def update_archive(jar)
+        (Dir['**/*'] - config.compiled_ruby_files).each do |f|
+          jar.files[jar.apply_pathmaps(config, f, :application)] = f
+        end
+        config.compiled_ruby_files.each do |f|
+          f = f.sub(/\.rb$/, '.class')
+          next unless File.exist?(f)
+          jar.files[jar.apply_pathmaps(config, f, :application)] = f
+        end
+        bin_path = jar.apply_pathmaps(config, default_executable, :application)
+        add_main_rb(jar, bin_path)
+      end
+
+      def default_executable
+        if !@spec.executables.empty?
+          "bin/#{@spec.executables.first}"
+        else
+          exe = Dir['bin/*'].first
+          raise "No executable script found" unless exe
+          warn "No default executable found in #{@spec_file}, using #{exe}"
+          exe
+        end
+      end
+    end
+  end
+end