ittayd-buildr 1.3.4 → 1.3.5

data/lib/buildr/java/deprecated.rb

@@ -1,141 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with this
-# work for additional information regarding copyright ownership.  The ASF
-# licenses this file to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-# License for the specific language governing permissions and limitations under
-# the License.
-
-
-require 'buildr/core/project'
-
-
-module Java
-
-  # *Deprecated:* In earlier versions, Java.wrapper served as a wrapper around RJB/JRuby.
-  # From this version forward, we apply with JRuby style for importing Java classes:
-  #   Java.java.lang.String.new('hai!')
-  # You still need to call Java.load before using any Java code: it resolves, downloads
-  # and installs various dependencies that are required on the classpath before calling
-  # any Java code (e.g. Ant and its tasks).
-  class JavaWrapper
-
-    include Singleton
-
-    # *Deprecated:* Append to Java.classpath directly.
-    def classpath
-      Buildr.application.deprecated 'Append to Java.classpath instead.'
-      ::Java.classpath
-    end
-
-    def classpath=(paths)
-      fail 'Deprecated: Append to Java.classpath, you cannot replace the classpath.'
-    end
-
-    # *Deprecated:* No longer necessary.
-    def setup
-      Buildr.application.deprecated 'See documentation for new way to access Java code.'
-      yield self if block_given?
-    end
-    
-    # *Deprecated:* Use Java.load instead.
-    def load
-      Buildr.application.deprecated 'Use Java.load instead.'
-      ::Java.load
-    end
-
-    alias :onload :setup
-
-    # *Deprecated:* Use Java.pkg.pkg.ClassName to import a Java class.
-    def import(class_name)
-      Buildr.application.deprecated 'Use Java.pkg.pkg.ClassName to import a Java class.'
-      ::Java.instance_eval(class_name)
-    end
-  end
-
-
-  class << self
-
-    # *Deprecated*: Use Java::Commands.java instead.
-    def java(*args, &block)
-      return send(:method_missing, :java) if args.empty?
-      Buildr.application.deprecated 'Use Java::Commands.javadoc instead.'
-      Commands.java(*args, &block)
-    end
-
-    # *Deprecated*: Use Java::Commands.apt instead.
-    def apt(*args)
-      Buildr.application.deprecated 'Use Java::Commands.javadoc instead.'
-      Commands.apt(*args)
-    end
-
-    # *Deprecated*: Use Java::Commands.javac instead.
-    def javac(*args)
-      Buildr.application.deprecated 'Use Java::Commands.javadoc instead.'
-      Commands.javac(*args)
-    end
-
-    # *Deprecated*: Use Java::Commands.javadoc instead.
-    def javadoc(*args)
-      Buildr.application.deprecated 'Use Java::Commands.javadoc instead.'
-      Commands.javadoc(*args)
-    end
-
-    # *Deprecated:* Use ENV_JAVA['java.version'] instead.
-    def version
-      Buildr.application.deprecated 'Use ENV_JAVA[\'java.version\'] instead.'
-      Java.load
-      ENV_JAVA['java.version']
-    end
-
-    # *Deprecated:* Use ENV['JAVA_HOME'] instead
-    def home
-      Buildr.application.deprecated 'Use ENV[\'JAVA_HOME\'] instead.'
-      ENV['JAVA_HOME']
-    end
-
-    # *Deprecated:* In earlier versions, Java.wrapper served as a wrapper around RJB/JRuby.
-    # From this version forward, we apply with JRuby style for importing Java classes:
-    #   Java.java.lang.String.new('hai!')
-    # You still need to call Java.load before using any Java code: it resolves, downloads
-    # and installs various dependencies that are required on the classpath before calling
-    # any Java code (e.g. Ant and its tasks).
-    def wrapper
-      Buildr.application.deprecated 'See documentation for new way to access Java code.'
-      if block_given?
-        Java.load
-        yield JavaWrapper.instance
-      else
-        JavaWrapper.instance
-      end
-    end
-
-    alias :rjb :wrapper
-
-  end
-
-
-  class Options
-
-    # *Deprecated:* Use ENV['JAVA_OPTS'] instead.
-    def java_args
-      Buildr.application.deprecated "Use ENV['JAVA_OPTS'] instead"
-      (ENV["JAVA_OPTS"] || ENV["JAVA_OPTIONS"]).to_s.split
-    end
-
-    # *Deprecated:* Use ENV['JAVA_OPTS'] instead.
-    def java_args=(args)
-      Buildr.application.deprecated "Use ENV['JAVA_OPTS'] instead"
-      ENV['JAVA_OPTS'] = Array(args).join(' ')
-    end
-
-  end
-
-end

data/lib/buildr/java/emma.rb

@@ -1,238 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with this
-# work for additional information regarding copyright ownership.  The ASF
-# licenses this file to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-# License for the specific language governing permissions and limitations under
-# the License.
-
-
-require 'buildr/java'
-
-
-module Buildr
-
-  # Provides the <code>emma:html</code> and <code>emma:xml</code> tasks.
-  # Require explicitly using <code>require "buildr/emma"</code>.
-  #
-  # You can generate emma reports for a single project 
-  # using the project name as prefix:
-  #
-  #   project_name:emma:html
-  #
-  # You can also specify which classes to include/exclude from instrumentation by 
-  # passing a class name regexp to the <code>emma.include</code> or 
-  # <code>emma.exclude</code> methods. 
-  # 
-  #   define 'someModule' do 
-  #      emma.include 'some.package.*'
-  #      emma.exclude 'some.foo.util.SimpleUtil'
-  #   end
-  module Emma
-
-    class << self
-
-      REQUIRES = ['emma:emma_ant:jar:2.0.5312', 'emma:emma:jar:2.0.5312'] unless const_defined?('REQUIRES')
-
-      def requires()
-        @requires ||= Buildr.artifacts(REQUIRES).each(&:invoke).map(&:to_s)
-      end
-
-      def report_to format=nil
-        File.expand_path('reports/emma')
-      end
-
-      def data_file()
-        File.join(report_to, 'coverage.es')
-      end
-
-      def ant
-          Buildr.ant 'emma' do |ant|
-            ant.taskdef :classpath=>requires.join(File::PATH_SEPARATOR), :resource=>'emma_ant.properties'
-            ant.emma :verbosity=>(Buildr.application.options.trace ? 'verbose' : 'warning') do
-              yield ant
-            end
-          end
-      end
-    end
-    
-    class EmmaConfig # :nodoc:
-      
-      def initialize(project)
-        @project = project
-      end
-      
-      attr_reader :project
-      private :project
-
-      attr_writer :metadata_file, :coverage_file, :instrumented_dir, :report_dir
-      
-      def coverage_file
-        @coverage_file ||= File.join(report_dir, 'coverage.ec')
-      end
-
-      def metadata_file
-        @metadata_file ||= File.join(report_dir, 'coverage.em')
-      end
-
-      def instrumented_dir
-        @instrumented_dir ||= project.path_to(:target, :instrumented, :classes)
-      end
-
-      def report_dir
-        @report_dir ||= project.path_to(:reports, :emma)
-      end
-      
-      def report_to format
-        report_dir
-      end
-
-      # :call-seq:
-      #   project.emma.include(*classPatterns)
-      #
-      def include(*classPatterns)
-        includes.push(*classPatterns)
-        self
-      end
-      
-      def includes
-        @includeClasses ||= []
-      end
-
-      # :call-seq:
-      #   project.emma.exclude(*classPatterns)
-      #
-      def exclude(*classPatterns)
-        excludes.push(*classPatterns)
-        self
-      end
-
-      def excludes
-        @excludeClasses ||= []
-      end
-
-      def sources
-        project.compile.sources
-      end
-    end
-
-    module EmmaExtension # :nodoc:
-      include Buildr::Extension
-
-      def emma
-        @emma_config ||= EmmaConfig.new(self)
-      end
-
-      after_define do |project|
-        emma = project.emma
-        
-        namespace 'emma' do
-          unless project.compile.target.nil?
-            # Instrumented bytecode goes in a different directory. This task creates before running the test
-            # cases and monitors for changes in the generate bytecode.
-            instrumented = project.file(emma.instrumented_dir => project.compile.target) do |task|
-              unless project.compile.sources.empty?
-                info "Instrumenting classes with emma metadata file #{emma.metadata_file}"
-                Emma.ant do |ant|
-                  ant.instr :instrpath=>project.compile.target.to_s, :destdir=>task.to_s, :metadatafile=>emma.metadata_file do
-                    ant.filter :includes=>emma.includes.join(', ') unless emma.includes.empty?
-                    ant.filter :excludes=>emma.excludes.join(', ') unless emma.excludes.empty?
-                  end
-                end
-                touch task.to_s, :verbose=>false
-              end
-            end
-            
-            task 'instrument' => instrumented
-            
-            # We now have two target directories with bytecode.
-            project.test.dependencies.unshift emma.instrumented_dir
-            project.test.with Emma.requires
-            project.test.options[:properties]["emma.coverage.out.file"] = emma.coverage_file
-            
-            [:xml, :html].each do |format|
-              task format => ['instrument', 'test'] do
-                missing_required_files = [emma.metadata_file, emma.coverage_file].reject { |f| File.exist?(f) }
-                if missing_required_files.empty?
-                  info "Creating test coverage reports in #{emma.report_dir}"
-                  mkdir_p emma.report_dir, :verbose=>false
-                  Emma.ant do |ant|
-                    ant.report do
-                      ant.infileset :file=>emma.metadata_file
-                      ant.infileset :file=>emma.coverage_file
-                      ant.send format, :outfile=>File.join(emma.report_to(format),"coverage.#{format}")
-                      ant.sourcepath do
-                        emma.sources.flatten.each do |src|
-                          ant.dirset(:dir=>src.to_s) if File.exist?(src.to_s)
-                        end
-                      end
-                    end
-                  end
-                else
-                  info "No test coverage report for #{project}. Missing: #{missing_required_files.join(', ')}"
-                end
-              end
-            end
-          end
-        end
-
-        project.clean do
-          rm_rf [emma.report_dir, emma.coverage_file, emma.metadata_file, emma.instrumented_dir], :verbose=>false
-        end
-        
-      end
-      
-    end
-
-    class Buildr::Project
-      include EmmaExtension
-    end
-
-    namespace "emma" do
-
-      Project.local_task('instrument') { |name| "Instrumenting #{name}" }
-      
-      [:xml, :html].each do |format|
-        desc "Run the test cases and produce code coverage reports in #{format}"
-        task format => ['instrument', 'test'] do
-          info "Creating test coverage reports in #{format}"
-          mkdir_p report_to(format), :verbose=>false
-          Emma.ant do |ant|
-            ant.merge :outfile=>data_file do
-              Buildr.projects.each do |project|
-                [project.emma.metadata_file, project.emma.coverage_file].each do |data_file|
-                  ant.fileset :file=>data_file if File.exist?(data_file)
-                end
-              end
-            end
-            ant.report do
-              ant.infileset :file=>data_file
-              ant.send format, :outfile=>File.join(report_to(format), "coverage.#{format}")
-              ant.sourcepath do
-                Buildr.projects.map(&:emma).map(&:sources).flatten.map(&:to_s).each do |src|
-                  ant.dirset :dir=>src if File.exist?(src)
-                end    
-              end
-            end
-          end
-        end
-      end
-      
-      task :clean do
-        rm_rf [report_to, data_file], :verbose=>false
-      end
-      end
-
-    task :clean do
-      task('emma:clean').invoke if Dir.pwd == Rake.application.original_dir
-    end
-
-  end
-end

data/lib/buildr/java/jruby.rb

@@ -1,117 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with this
-# work for additional information regarding copyright ownership.  The ASF
-# licenses this file to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
-# License for the specific language governing permissions and limitations under
-# the License.
-
-
-require 'java'
-require 'jruby'
-
-
-# Buildr runs along side a JVM, using either RJB or JRuby.  The Java module allows
-# you to access Java classes and create Java objects.
-#
-# Java classes are accessed as static methods on the Java module, for example:
-#   str = Java.java.lang.String.new('hai!')
-#   str.toUpperCase
-#   => 'HAI!'
-#   Java.java.lang.String.isInstance(str)
-#   => true
-#   Java.com.sun.tools.javac.Main.compile(args)
-#
-# The classpath attribute allows Buildr to add JARs and directories to the classpath,
-# for example, we use it to load Ant and various Ant tasks, code generators, test
-# frameworks, and so forth.
-#
-# When using an artifact specification, Buildr will automatically download and
-# install the artifact before adding it to the classpath.
-#
-# For example, Ant is loaded as follows:
-#   Java.classpath << 'org.apache.ant:ant:jar:1.7.0'
-#
-# Artifacts can only be downloaded after the Buildfile has loaded, giving it
-# a chance to specify which remote repositories to use, so adding to classpath
-# does not by itself load any libraries.  You must call Java.load before accessing
-# any Java classes to give Buildr a chance to load the libraries specified in the
-# classpath.
-#
-# When building an extension, make sure to follow these rules:
-# 1. Add to the classpath when the extension is loaded (i.e. in module or class
-#    definition), so the first call to Java.load anywhere in the code will include
-#    the libraries you specify.
-# 2. Call Java.load once before accessing any Java classes, allowing Buildr to
-#    set up the classpath.
-# 3. Only call Java.load when invoked, otherwise you may end up loading the JVM
-#    with a partial classpath, or before all remote repositories are listed.
-# 4. Check on a clean build with empty local repository.
-module Java
-
-  # Since we already have a JVM loaded, we can use it to guess where JAVA_HOME is.
-  # We set JAVA_HOME early so we can use it without calling Java.load first.
-  ENV['JAVA_HOME'] ||= java.lang.System.getProperty("java.home")
-
-  class << self
-
-    # Returns the classpath, an array listing directories, JAR files and
-    # artifacts.  Use when loading the extension to add any additional
-    # libraries used by that extension.
-    #
-    # For example, Ant is loaded as follows:
-    #   Java.classpath << 'org.apache.ant:ant:jar:1.7.0'
-    def classpath
-      @classpath ||= []
-    end
-    
-    # Most platforms requires tools.jar to be on the classpath, tools.jar contains the
-    # Java compiler (OS X and AIX are two exceptions we know about, may be more).
-    # Guess where tools.jar is from JAVA_HOME, which hopefully points to the JDK,
-    # but maybe the JRE.  Return nil if not found.
-    def tools_jar #:nodoc:
-      @tools_jar ||= ['lib/tools.jar', '../lib/tools.jar'].map { |path| File.expand_path(path, ENV['JAVA_HOME']) }.
-        find { |path| File.exist?(path) }
-    end
-
-    # Loads the JVM and all the libraries listed on the classpath.  Call this
-    # method before accessing any Java class, but only call it from methods
-    # used in the build, giving the Buildfile a chance to load all extensions
-    # that append to the classpath and specify which remote repositories to use.
-    def load
-      return self if @loaded
-
-      # Adding jars to the jruby's $CLASSPATH should be the correct thing, however it
-      # seems like some tools require their jars on system class loader (javadoc, junit, etc)
-      # cp.each { |path| $CLASSPATH << path }
-
-      # Use system ClassLoader to add classpath
-      sysloader = java.lang.ClassLoader.getSystemClassLoader
-      add_url_method = java.lang.Class.forName('java.net.URLClassLoader').
-        getDeclaredMethod('addURL', [java.net.URL.java_class].to_java(java.lang.Class))
-      add_url_method.setAccessible(true)
-      add_path = lambda { |path| add_url_method.invoke(sysloader, [java.io.File.new(path).toURI.toURL].to_java(java.net.URL)) }
-
-      # Most platforms requires tools.jar to be on the classpath.
-      add_path[tools_jar] if tools_jar
-      
-      classpath.map! { |path| Proc === path ? path.call : path }      
-      Buildr.artifacts(classpath).map(&:to_s).each do |path|
-        file(path).invoke
-        add_path[path]
-      end
-      
-      @loaded = true
-      self
-    end
-
-  end
-
-end