warbler_updated 2.1.0

data/lib/warbler/traits/bundler.rb

@@ -0,0 +1,157 @@
+#--
+# 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
+  module Traits
+    # The Bundler trait uses Bundler to determine gem dependencies to
+    # be added to the project.
+    class Bundler
+      include Trait
+      include PathmapHelper
+      include BundlerHelper
+
+      def self.detect?
+        File.exist?(ENV['BUNDLE_GEMFILE'] || 'Gemfile')
+      end
+
+      def self.requirements
+        [ Traits::War, Traits::Jar ]
+      end
+
+      def before_configure
+        config.bundler ||= true
+        config.bundle_without = ['development', 'test', 'assets']
+      end
+
+      def after_configure
+        add_bundler_gems if config.bundler
+      end
+
+      def add_bundler_gems; require 'bundler'
+        # config.gems.clear allow to add `config.gems` on top of those bundled
+        config.gem_dependencies = false # Bundler takes care of these
+        config.bundler = {} if config.bundler == true
+
+        bundler_specs.each do |spec|
+          spec = to_spec(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)
+            while ! full_gem_path.join('bundler.gemspec').exist?
+              full_gem_path = full_gem_path.dirname
+              # if at top of the path, meaning we cannot find bundler.gemspec, abort.
+              if full_gem_path.to_s =~ /^[\.\/]$/
+                warn("Unable to detect bundler spec under '#{spec.full_gem_path}'' and its sub-dirs")
+                exit
+              end
+            end
+
+            spec.loaded_from = full_gem_path.join('bundler.gemspec').to_s
+            spec.full_gem_path = 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
+            unless bundler_source_is_warbled_gem_itself?(spec.source)
+              if spec.source.path && spec.source.path.relative?
+                # include (assuming) relative *[APP_ROOT]/gem/path*
+                # NOTE: might be tuned to only add gemspec.files ...
+                config.includes += FileList[File.join(spec.source.path, '**/*')]
+                config.gems << spec # probably not really needed
+              else
+                warn("Bundler `path' components are not fully supported.\n" +
+                     "The `#{spec.full_name}' component was not bundled.\n" +
+                     "Your application may fail to boot!")
+              end
+            end
+          else
+            config.gems << spec
+          end
+        end
+        config.bundler[:gemfile]  = ::Bundler.default_gemfile
+        config.bundler[:gemfile_path] = apply_pathmaps(config, relative_from_pwd(::Bundler.default_gemfile), :application)
+        config.bundler[:lockfile] = ::Bundler.default_lockfile
+        config.bundler[:frozen] = ::Bundler.settings[:frozen]
+        path = ::Bundler.settings[:path]
+        config.excludes += [path, "#{path}/**/*"] if 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)
+        gemfile  = relative_from_pwd(config.bundler[:gemfile])
+        lockfile = relative_from_pwd(config.bundler[:lockfile])
+        jar.files[apply_pathmaps(config, gemfile, :application)] = config.bundler[:gemfile].to_s
+        if File.exist?(lockfile)
+          jar.files[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)
+
+            gem_relative_path = full_gem_path.relative_path_from(::Bundler.install_path)
+            filenames = []
+            gem_relative_path.each_filename { |f| filenames << f }
+
+            exclude_gems = true
+            unless filenames.empty?
+              full_gem_path = Pathname.new(::Bundler.install_path) + filenames.first
+              exclude_gems = false
+            end
+
+            if spec.groups.include?(:warbler_excluded)
+              pattern = "#{full_gem_path.to_s}/**/#{spec.name}.gemspec" # #42: gemspec only to avert Bundler error
+            else
+              pattern = "#{full_gem_path.to_s}/**/*"
+            end
+
+            FileList[pattern].each do |src|
+              f = Pathname.new(src).relative_path_from(full_gem_path).to_s
+              next if exclude_gems && config.gem_excludes && config.gem_excludes.any? {|rx| f =~ rx }
+              jar.files[apply_pathmaps(config, File.join(full_gem_path.basename, f), :git)] = src
+            end
+          end
+        end
+      end
+
+      def relative_from_pwd(path)
+        if path.relative?
+          path
+        else
+          path.relative_path_from(Pathname.new(Dir.pwd)).to_s
+        end
+      end
+
+      private
+
+      def bundler_specs
+        bundle_without = config.bundle_without.map { |s| s.to_sym }
+        definition = ::Bundler.definition
+        all = definition.specs.to_a
+        requested = definition.specs_for(definition.groups - bundle_without).to_a
+        excluded_git_specs = (all - requested).select { |spec| ::Bundler::Source::Git === spec.source }
+        excluded_git_specs.each { |spec| spec.groups << :warbler_excluded }
+        requested + excluded_git_specs
+      end
+
+      def bundler_source_is_warbled_gem_itself?(source)
+        source.path.to_s == '.'
+      end
+    end
+  end
+end

data/lib/warbler/traits/gemspec.rb

@@ -0,0 +1,79 @@
+#--
+# 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
+  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
+      include PathmapHelper
+      include ExecutableHelper
+
+      def self.detect?
+        !Dir['*.gemspec'].empty?
+      end
+
+      def before_configure; require 'yaml'
+        @spec_file = Dir['*.gemspec'].first
+        @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)
+        @spec.files.each do |f|
+          unless File.exist?(f)
+            warn "update your gemspec; skipping missing file #{f}"
+            next
+          end
+          file_key = jar.apply_pathmaps(config, f, :application)
+          next if jar.files[file_key]
+          jar.files[file_key] = f
+        end
+
+        config.compiled_ruby_files.each do |f|
+          f = f.sub(/\.rb$/, '.class')
+          next unless File.exist?(f)
+          jar.files[apply_pathmaps(config, f, :application)] = f
+        end
+
+        update_archive_add_executable(jar)
+      end
+
+      def default_executable
+        if ! @spec.executables.empty?
+          exe_script = @spec.executables.first
+          exe_path = File.join(@spec.bindir, exe_script) # bin/script
+          if File.exists?(exe_path)
+            exe_path
+          elsif File.exists?("bin/#{exe_script}") # compatibility
+            "bin/#{exe_script}" # ... should probably remove this
+          else
+            raise "no `#{exe_script}` executable script found"
+          end
+        elsif exe_path = Dir['bin/*'].sort.first
+          warn "no executables found in #{@spec_file}, using #{exe_path}"
+          exe_path
+        elsif exe_path = Dir['exe/*'].sort.first
+          warn "no executables found in #{@spec_file}, using #{exe_path}"
+          exe_path
+        else
+          raise "no executable script found"
+        end
+      end
+
+    end
+  end
+end

data/lib/warbler/traits/jar.rb

@@ -0,0 +1,58 @@
+#--
+# 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 'ostruct'
+
+module Warbler
+  module Traits
+    # The Jar trait sets up the archive layout for an executable jar
+    # project, and adds the JRuby jar files and a JarMain class to the
+    # archive.
+    class Jar
+      include Trait
+
+      def self.detect?
+        !War.detect?
+      end
+
+      def before_configure
+        config.gem_path      = '/'
+        config.pathmaps      = default_pathmaps
+        config.java_libs     = default_jar_files
+        config.manifest_file = 'MANIFEST.MF' if File.exist?('MANIFEST.MF')
+        config.init_contents << "#{config.warbler_templates}/jar.erb"
+      end
+
+      def after_configure
+        config.init_contents << StringIO.new("require 'rubygems' unless defined?(Gem)\n")
+      end
+
+      def update_archive(jar)
+        unless config.manifest_file
+          manifest = Warbler::Jar::DEFAULT_MANIFEST.chomp + "Main-Class: JarMain\n"
+          jar.files['META-INF/MANIFEST.MF'] = StringIO.new(manifest)
+        end
+        jar.files['JarMain.class'] = jar.entry_in_jar(WARBLER_JAR, "JarMain.class")
+      end
+
+      def default_pathmaps
+        p = OpenStruct.new
+        p.java_libs    = ["META-INF/lib/%f"]
+        p.java_classes = ["%p"]
+        p.application  = ["#{config.jar_name}/%p"]
+        p.gemspecs     = ["specifications/%f"]
+        p.gems         = ["gems/%p"]
+        p
+      end
+
+      def default_jar_files
+        jruby_jars
+      end
+    end
+  end
+end

data/lib/warbler/traits/jbundler.rb

@@ -0,0 +1,48 @@
+#--
+# 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
+  module Traits
+    # The JBundler trait uses JBundler to determine jar dependencies to
+    # be added to the project.
+    class JBundler
+      include Trait
+      include PathmapHelper
+
+      def self.detect?
+        File.exist?(ENV['JBUNDLE_JARFILE'] || "Jarfile")
+      end
+
+      def self.requirements
+        [ Traits::War, Traits::Jar ]
+      end
+
+      def before_configure
+        config.jbundler = true
+      end
+
+      def after_configure
+        add_jbundler_jars if config.jbundler
+      end
+
+      def add_jbundler_jars
+        require 'jbundler/config'
+        classpath = ::JBundler::Config.new.classpath_file
+        if File.exists?( classpath )
+          require File.expand_path( classpath )
+        else
+          raise 'jbundler support needs jruby to create a local config: jruby -S jbundle install'
+        end
+        # use only the jars from jbundler and jruby
+        config.java_libs += jruby_jars
+        config.java_libs += JBUNDLER_CLASSPATH
+        config.java_libs.uniq! {|lib| lib.split(File::SEPARATOR).last }
+        config.init_contents << "#{config.warbler_templates}/jbundler.erb"
+      end
+    end
+  end
+end

data/lib/warbler/traits/nogemspec.rb

@@ -0,0 +1,47 @@
+#--
+# 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
+  module Traits
+    # The NoGemspec trait is used when no gemspec file is found for a
+    # jar project. It assumes a standard layout including +bin+ and
+    # +lib+ directories.
+    class NoGemspec
+      include Trait
+      include PathmapHelper
+      include ExecutableHelper
+
+      def self.detect?
+        Jar.detect? && !Gemspec.detect?
+      end
+
+      def before_configure
+        config.dirs = ['.']
+      end
+
+      def after_configure
+        if File.directory?("lib")
+          add_init_load_path(config.pathmaps.application.inject("lib") {|pm,x| pm.pathmap(x)})
+        end
+      end
+
+      def update_archive(jar)
+        update_archive_add_executable(jar)
+      end
+
+      def default_executable
+        exes = Dir['bin/*'].sort
+        unless exe = exes.grep(/#{config.jar_name}/).first
+          exe = exes.first
+          warn "No executable matching config.jar_name found, using #{exe}" if exe
+        end
+        raise "No executable script found" unless exe
+        exe
+      end
+    end
+  end
+end

data/lib/warbler/traits/rack.rb

@@ -0,0 +1,33 @@
+#--
+# 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
+  module Traits
+    # The Rack trait adds config.ru to a Rack-based war project.
+    class Rack
+      include Trait
+
+      def self.detect?
+        !Rails.detect? && (File.exist?("config.ru") || !Dir['*/config.ru'].empty?)
+      end
+
+      def self.requirements
+        [ Traits::War ]
+      end
+
+      def before_configure
+        config.webxml.booter = :rack
+        config.webinf_files += [FileList['config.ru', '*/config.ru'].detect {|f| File.exist?(f)}]
+        config.webxml.rack.env = ENV['RACK_ENV'] || 'production'
+      end
+
+      def after_configure
+        config.init_contents << "#{config.warbler_templates}/rack.erb"
+      end
+    end
+  end
+end

data/lib/warbler/traits/rails.rb

@@ -0,0 +1,91 @@
+#--
+# 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
+  module Traits
+    # The Rails trait invokes the Rake environment task and sets up Rails for a war-based project.
+    class Rails
+      include Trait
+
+      def self.detect?
+        File.exist?('config/environment.rb')
+      end
+
+      def self.requirements
+        [ Traits::War ]
+      end
+
+      def before_configure
+        config.jar_name = default_app_name
+        config.webxml.rails.env = ENV['RAILS_ENV'] || 'production'
+        config.pathmaps.public_html << "%{packs/(manifest.*),WEB-INF/public/packs/\\1}p"
+
+        return unless Warbler.framework_detection
+        return false unless task = Warbler.project_application.lookup('environment')
+
+        task.invoke rescue nil
+        return false unless defined?(::Rails)
+
+        config.dirs << 'tmp' if File.directory?('tmp')
+        config.webxml.booter = :rails
+        unless (defined?(::Rails.vendor_rails?) && ::Rails.vendor_rails?) || File.directory?('vendor/rails')
+          config.gems['rails'] = ::Rails::VERSION::STRING unless Bundler.detect?
+        end
+        if defined?(::Rails.configuration.gems)
+          ::Rails.configuration.gems.each do |g|
+            config.gems << Gem::Dependency.new(g.name, g.requirement) if Dir["vendor/gems/#{g.name}*"].empty?
+          end
+        end
+        config.script_files << "#{config.warbler_scripts}/rails.rb"
+      end
+
+      def after_configure
+        config.init_contents << "#{config.warbler_templates}/rails.erb"
+
+        if config.webxml.jruby.min.runtimes.is_a?(OpenStruct) &&
+           config.webxml.jruby.max.runtimes.is_a?(OpenStruct) # not set
+           if rails_major_version(0) >= 4 || threadsafe_enabled?
+             config.webxml.jruby.min.runtimes = 1
+             config.webxml.jruby.max.runtimes = 1
+           end
+        end
+
+        config.includes += FileList["public/assets/.sprockets-manifest-*.json"].existing
+        config.includes += FileList["public/assets/manifest-*.json"].existing
+        config.includes += FileList["public/assets/manifest.yml"].existing
+      end
+
+      def default_app_name
+        File.basename(File.expand_path(defined?(::Rails.root) ? ::Rails.root : (defined?(RAILS_ROOT) ? RAILS_ROOT : Dir.getwd)))
+      end
+
+      def threadsafe_enabled?
+        rails_env = config.webxml.rails.env
+        begin
+          unless IO.readlines("config/environments/#{rails_env}.rb").grep(/^\s*config\.threadsafe!/).empty? &&
+              IO.readlines("config/environment.rb").grep(/^\s*config\.threadsafe!/).empty?
+            return true
+          end
+        rescue
+        end
+      end
+
+      def rails_major_version(default = 0)
+        begin
+          File.open("#{ENV['BUNDLE_GEMFILE'] || 'Gemfile'}.lock") do |file|
+            file.each_line do |line|
+              match = line.match( /^\s*rails\s\(\s*(\d)\.\d+\.\d+.*\)$/ )
+              return match[1].to_i if match
+            end
+          end
+        rescue
+        end
+        default
+      end
+    end
+  end
+end