buildr 1.3.0-java

data/Rakefile

@@ -0,0 +1,63 @@
+# 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 'rake/gempackagetask'
+
+
+def spec(platform = nil)
+  @specs ||= {}
+  platform ||= RUBY_PLATFORM =~ /java/ ? 'java' : 'ruby'
+  @specs[platform] ||= begin
+    spec = Gem::Specification.load(File.join(File.dirname(__FILE__), 'buildr.gemspec'))
+    spec.platform = platform
+    if platform =~ /java/
+      spec.add_dependency 'ci_reporter', '~> 1.5'
+    else
+      spec.add_dependency 'rjb', '~>1.1'
+    end
+    spec
+  end
+end
+
+
+desc 'Compile Java libraries used by Buildr'
+task 'compile' do
+  puts 'Compiling Java libraries ...'
+  sh Config::CONFIG['ruby_install_name'], '-Ilib', '-Iaddon', 'bin/buildr', 'compile'
+  puts 'OK'
+end
+file Rake::GemPackageTask.new(spec).package_dir=>'compile'
+file Rake::GemPackageTask.new(spec).package_dir_path=>'compile'
+
+# We also need the other package (JRuby if building on Ruby, and vice versa)
+Rake::GemPackageTask.new spec(RUBY_PLATFORM =~ /java/ ? 'ruby' : 'java') do |task|
+  # Block necessary otherwise doesn't do full job.
+end
+
+
+ENV['incubating'] = 'true'
+ENV['staging'] = "people.apache.org:~/public_html/#{spec.name}/#{spec.version}"
+
+task 'apache:license'=>spec.files
+task('apache:license').prerequisites.exclude('doc/css/syntax.css')
+
+task 'spec:check' do
+  print 'Checking that we have JRuby, Scala and Groovy available ... '
+  fail 'Full testing requires JRuby!' unless which('jruby')
+  fail 'Full testing requires Scala!' unless which('scala')
+  fail 'Full testing requires Groovy!' unless which('groovy')
+  puts 'OK'
+end

data/addon/buildr/antlr.rb

@@ -0,0 +1,65 @@
+# 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 ANTLR grammar generation tasks. Require explicitly using <code>require "buildr/antlr"</code>.
+  module ANTLR
+    REQUIRES = [ "org.antlr:antlr:jar:3.0", "antlr:antlr:jar:2.7.7", "org.antlr:stringtemplate:jar:3.0" ]
+
+    Java.classpath << REQUIRES
+
+    class << self
+      def antlr(*args)
+        options = Hash === args.last ? args.pop : {}
+        rake_check_options options, :output, :token
+
+        args = args.flatten.map(&:to_s).collect { |f| File.directory?(f) ? FileList[f + "/**/*.g"] : f }.flatten
+        args = ["-o",  options[:output]] + args if options[:output]
+        if options[:token]
+          # antlr expects the token directory to exist when it starts
+          mkdir_p options[:token] 
+          args = ["-lib",  options[:token]] + args 
+        end
+        Java.load
+        #Java.org.antlr.Tool.new_with_sig("[Ljava.lang.String;", args).process
+        Java.org.antlr.Tool.new(args.to_java(Java.java.lang.String)).process
+      end
+    end
+
+    def antlr(*args)
+      if Hash === args.last
+        options = args.pop 
+        in_package = options[:in_package].split(".")
+        token = options[:token].split(".") if options[:token]
+      else
+        in_package = []; token = nil
+      end
+      file(path_to(:target, :generated, :antlr)=>args.flatten) do |task|
+        args = {:output=>File.join(task.name, in_package)}
+        args.merge!({:token=>File.join(task.name, token)}) if token
+        ANTLR.antlr task.prerequisites, args
+      end         
+    end
+
+  end
+  
+  class Project
+    include ANTLR
+  end
+end

data/addon/buildr/cobertura.rb

@@ -0,0 +1,232 @@
+# 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>cobertura:html</code> and <code>cobertura:xml</code> tasks.
+  # Require explicitly using <code>require "buildr/cobertura"</code>.
+  #
+  # You can generate cobertura reports for a single project 
+  # using the project name as prefix:
+  #
+  #   project_name:cobertura:html
+  #
+  # You can also specify which classes to include/exclude from instrumentation by 
+  # passing a class name regexp to the <code>cobertura.include</code> or 
+  # <code>cobertura.exclude</code> methods. 
+  # 
+  #   define 'someModule' do 
+  #      cobertura.include 'some.package.*'
+  #      cobertura.include /some.(foo|bar).*/
+  #      cobertura.exclude 'some.foo.util.SimpleUtil'
+  #      cobertura.exclude /*.Const(ants)?/i
+  #   end
+  module Cobertura
+
+    class << self
+
+      REQUIRES = ["net.sourceforge.cobertura:cobertura:jar:1.9", "log4j:log4j:jar:1.2.9",
+        "asm:asm:jar:2.2.1", "asm:asm-tree:jar:2.2.1", "oro:oro:jar:2.0.8"]
+
+      def requires()
+        @requires ||= Buildr.artifacts(REQUIRES).each(&:invoke).map(&:to_s)
+      end
+
+      def report_to(file = nil)
+        File.expand_path(File.join(*["reports/cobertura", file.to_s].compact))
+      end
+
+      def data_file()
+        File.expand_path("reports/cobertura.ser")
+      end
+
+    end
+    
+    class CoberturaConfig # :nodoc:
+      
+      def initialize(project)
+        @project = project
+      end
+      
+      attr_reader :project
+      private :project
+
+      attr_writer :data_file, :instrumented_dir, :report_dir
+      
+      def data_file
+        @data_file ||= project.path_to(:reports, 'cobertura.ser')
+      end
+
+      def instrumented_dir
+        @instrumented_dir ||= project.path_to(:target, :instrumented, :classes)
+      end
+
+      def report_dir
+        @report_dir ||= project.path_to(:reports, :cobertura)
+      end
+
+      def report_to(file = nil)
+        File.expand_path(File.join(*[report_dir, file.to_s].compact))
+      end
+
+      # :call-seq:
+      #   project.cobertura.include(*classPatterns)
+      #
+      def include(*classPatterns)
+        includes.push(*classPatterns.map { |p| String === p ? Regexp.new(p) : p })
+        self
+      end
+      
+      def includes
+        @includeClasses ||= []
+      end
+
+      # :call-seq:
+      #   project.cobertura.exclude(*classPatterns)
+      #
+      def exclude(*classPatterns)
+        excludes.push(*classPatterns.map { |p| String === p ? Regexp.new(p) : p })
+        self
+      end
+
+      def excludes
+        @excludeClasses ||= []
+      end
+
+      def sources
+        project.compile.sources
+      end
+    end
+
+    module CoberturaExtension # :nodoc:
+      include Buildr::Extension
+
+      def cobertura
+        @cobertura_config ||= CoberturaConfig.new(self)
+      end
+
+      after_define do |project|
+        cobertura = project.cobertura
+        
+        namespace 'cobertura' do
+          # 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(cobertura.instrumented_dir => file(project.compile.target)) do |task|
+            mkdir_p task.to_s, :verbose => false
+            unless project.compile.sources.empty?
+              puts "Instrumenting classes with cobertura data file #{cobertura.data_file}"
+              Buildr.ant "cobertura" do |ant|
+                ant.taskdef :classpath=>Cobertura.requires.join(File::PATH_SEPARATOR), :resource=>"tasks.properties"
+                ant.send "cobertura-instrument", :todir=>task.to_s, :datafile=>cobertura.data_file do
+                  includes, excludes = cobertura.includes, cobertura.excludes
+                  
+                  classes_dir = project.compile.target.to_s
+                  if includes.empty? && excludes.empty? 
+                    ant.fileset :dir => classes_dir do 
+                      ant.include :name => "**/*.class"
+                    end
+                  else
+                    includes = [//] if includes.empty?
+                    Dir.glob(File.join(classes_dir, "**/*.class")) do |cls|
+                      cls_name = cls.gsub(/#{classes_dir}\/?|\.class$/, '').gsub('/', '.')
+                      if includes.any? { |p| p === cls_name } && !excludes.any? { |p| p === cls_name }
+                        ant.fileset :file => cls
+                      end
+                    end
+                  end
+                end
+              end
+            end
+            touch task.to_s, :verbose=>false
+          end
+
+          task 'instrument' => instrumented
+          [:xml, :html].each do |format|
+            task format => ['instrument', 'test'] do 
+              puts "Creating test coverage reports in #{cobertura.report_to(format)}"
+              Buildr.ant "cobertura" do |ant|
+                ant.taskdef :classpath=>Cobertura.requires.join(File::PATH_SEPARATOR), :resource=>"tasks.properties"
+                ant.send "cobertura-report", :format=>format, 
+                         :destdir=>cobertura.report_to(format), :datafile=>cobertura.data_file do
+                  cobertura.sources.flatten.each do |src|
+                    ant.fileset(:dir=>src.to_s) if File.exist?(src.to_s)
+                  end
+                end
+              end
+            end
+          end
+          
+        end
+
+        # We now have two target directories with bytecode. It would make sense to remove compile.target
+        # and add instrumented instead, but apparently Cobertura only creates some of the classes, so
+        # we need both directories and instrumented must come first.
+        project.test.dependencies.unshift cobertura.instrumented_dir
+        project.test.with Cobertura.requires
+        project.test.options[:properties]["net.sourceforge.cobertura.datafile"] = cobertura.data_file
+        
+        project.clean do
+          rm_rf [cobertura.report_to, cobertura.data_file, cobertura.instrumented_dir], :verbose=>false
+        end
+        
+      end
+      
+    end
+
+    class Buildr::Project
+      include CoberturaExtension
+    end
+
+    namespace "cobertura" do
+
+      task "instrument" do
+        Buildr.projects.each do |project|
+          project.cobertura.data_file = data_file
+          project.test.options[:properties]["net.sourceforge.cobertura.datafile"] = data_file
+          project.task('cobertura:instrument').invoke
+        end
+      end
+      
+      [:xml, :html].each do |format|
+        report_target = report_to(format)
+        desc "Run the test cases and produce code coverage reports in #{report_target}"
+        task format => ["instrument", "test"] do
+          puts "Creating test coverage reports in #{report_target}"
+          Buildr.ant "cobertura" do |ant|
+            ant.taskdef :classpath=>requires.join(File::PATH_SEPARATOR), :resource=>"tasks.properties"
+            ant.send "cobertura-report", :destdir=>report_target, :format=>format, :datafile=>data_file do
+              Buildr.projects.map(&:cobertura).map(&:sources).flatten.each do |src|
+                ant.fileset :dir=>src.to_s if File.exist?(src.to_s)
+              end
+            end
+          end
+        end
+      end
+      
+      task "clean" do
+        rm_rf [report_to, data_file], :verbose=>false
+      end
+    end
+
+    task "clean" do
+      task("cobertura:clean").invoke if Dir.pwd == Rake.application.original_dir
+    end
+
+  end
+end

data/addon/buildr/hibernate.rb

@@ -0,0 +1,142 @@
+# 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 Hibernate Doclet and schema export tasks. Require explicitly using <code>require "buildr/hibernate"</code>.
+  module Hibernate
+
+    REQUIRES = Buildr.struct(
+      :collections  => "commons-collections:commons-collections:jar:3.1",
+      :logging      => "commons-logging:commons-logging:jar:1.0.3",
+      :dom4j        => "dom4j:dom4j:jar:1.6.1",
+      :hibernate    => "org.hibernate:hibernate:jar:3.1.2",
+      :xdoclet      => Buildr.group("xdoclet", "xdoclet-xdoclet-module", "xdoclet-hibernate-module",
+                         # :under=>"xdoclet", :version=>"1.2.3") + ["xdoclet:xjavadoc:jar:1.1-j5"]
+                         :under=>"xdoclet", :version=>"1.2.3") + ["xdoclet:xjavadoc:jar:1.1"]
+    )
+
+    class << self
+      include Buildr::Ant
+
+      # :call-seq:
+      #    doclet(options) => AntProject
+      #
+      # Uses XDoclet to generate HBM files form annotated source files.
+      # Options include:
+      # * :sources -- Directory (or directories) containing source files.
+      # * :target -- The target directory.
+      # * :excludetags -- Tags to exclude (see HibernateDocletTask)
+      #
+      # For example:
+      #  doclet :sources=>compile.sources, :target=>compile.target, :excludedtags=>"@version,@author,@todo"
+      def doclet(options)
+        options[:sources].each { |src| file(src).invoke }
+        ant "hibernatedoclet" do |ant|
+          ant.taskdef :name=>"hibernatedoclet", :classname=>"xdoclet.modules.hibernate.HibernateDocletTask", :classpath=>requires
+          ant.hibernatedoclet :destdir=>options[:target].to_s, :excludedtags=>options[:excludedtags], :force=>"true" do
+            ant.hibernate :version=>"3.0"
+            options[:sources].map(&:to_s).each do |source|
+              ant.fileset :dir=>source.to_s, :includes=>"**/*.java"
+            end
+          end
+        end
+      end
+
+      # :call-seq:
+      #   schemaexport(properties) { ... } => AntProject
+      #
+      # Runs the Hibernate SchemaExportTask with the specified properties. For example:
+      #   Buildr::Hibernate.schemaexport(:properties=>properties.to_s, :quiet=>"yes", :text=>"yes", :delimiter=>";",
+      #     :drop=>"no", :create=>"yes", :output=>target) do
+      #     fileset :dir=>source.to_s, :includes=>"**/*.hbm.xml"
+      #   end
+      def schemaexport(options = nil)
+        ant "schemaexport" do |ant|
+          ant.taskdef :name=>"schemaexport", :classname=>"org.hibernate.tool.hbm2ddl.SchemaExportTask", :classpath=>requires
+          ant.schemaexport(options) { yield ant if block_given? } if options
+        end
+      end
+
+    protected
+
+      # This will download all the required artifacts before returning a classpath, and we want to do this only once.
+      def requires()
+        @requires ||= Buildr.artifacts(REQUIRES.to_a).each(&:invoke).map(&:to_s).join(File::PATH_SEPARATOR)
+      end
+
+    end
+
+    # :call-seq:
+    #   hibernate_doclet(options?) => task
+    #
+    # Runs the hibernate doclet on the source files and creates HBM files in the target directory.
+    # By default runs on all source files, but you can limit it to a given package using the :package
+    # options. You can also pass other options to the doclet task.
+    #
+    # For example:
+    #   resources hibernate_doclet(:package=>"org.apache.ode.store.hib", :excludedtags=>"@version,@author,@todo")
+    def hibernate_doclet(options = {})
+      if options[:package]
+        depends = compile.sources.map { |src| FileList[File.join(src.to_s, options[:package].gsub(".", "/"), "*.java")] }.flatten
+      else
+        depends = compile.sources.map { |src| FileList[File.join(src.to_s, "**/*.java")] }.flatten
+      end
+      file("target/hbm.timestamp"=>depends) do |task|
+        Hibernate.doclet({ :sources=>compile.sources, :target=>compile.target }.merge(options))
+        write task.name
+      end
+    end
+
+    # :call-seq:
+    #   hibernate_schemaexport(path) => task
+    #   hibernate_schemaexport(path) { |task, ant| .. } => task
+    #
+    # Returns an new file task with an accessor (ant) to an AntProject that defines the schemaexport task.
+    # If called with a block, the task will yield to the block passing both itself and the Ant project.
+    #
+    # See #schemaexport.
+    #
+    # For example:
+    #   hibernate_schemaexport "derby.sql" do |task, ant|
+    #     ant.schemaexport :properties=>"derby.properties", :output=>task.name,
+    #       :delimiter=>";", :drop=>"no", :create=>"yes" do
+    #       fileset(:dir=>compile.sources.first) { include :name=>"**/*.hbm.xml" } }
+    #     end
+    #   end
+    def hibernate_schemaexport(args, &block)
+      path, arg_names, deps = Rake.application.resolve_args([args])
+      unless Rake::Task.task_defined?(path)
+        class << file(path) ; attr_accessor :ant ; end
+        file(path).enhance { |task| task.ant = Hibernate.schemaexport }
+      end
+      if block
+        file(path).enhance(deps) { |task| block.call task, task.ant }
+      else
+        file(path).enhance deps
+      end
+    end
+
+  end
+
+  class Project
+    include Hibernate
+  end
+
+end