buildr 0.14.0

data/lib/java/java.rb

@@ -0,0 +1,117 @@
+module Buildr
+  module Java
+
+    JAVA_OPTIONS = [ :verbose, :noop, :cp, :classpath, :name, :java_args ]
+
+    def self.java(*args)
+      options = Hash === args.last ? args.pop : {}
+      options[:verbose] ||= Rake.application.options.trace || false
+      fu_check_options options, *JAVA_OPTIONS
+
+      name = options[:name] || "java #{args.first}"
+      cmd_args = []
+      classpath = classpath_from(options)
+      cmd_args << "-cp" << classpath unless classpath.empty?
+      cmd_args += options[:java_args].flatten if options[:java_args]
+      cmd_args += args.flatten.compact
+      cmd_args << { :verbose=>options[:verbose] }
+      unless options[:noop]
+        verbose { puts "Running #{name}" }
+        sh(path_to_bin("java"), *cmd_args) { |ok, res| fail "Failed to execute #{name}, see errors above" unless ok }
+      end
+    end
+
+    def self.apt(*args)
+      options = Hash === args.last ? args.pop : {}
+      options[:verbose] ||= Rake.application.options.trace || false
+      fu_check_options options, :verbose, :noop, :compile, :source, :output, :cp, :classpath, :sourcepath
+
+      files = args.collect { |arg| File.directory?(arg) ? FileList[File.join(arg, "**", "*.java")] : arg }.flatten
+      args = [ options[:verbose] ? "-verbose" : "-nowarn" ]
+      if options[:compile]
+        args << "-d" << options[:output]
+      else
+        args << "-nocompile" << "-s" << options[:output]
+      end
+      args << "-source" << options[:source] if options[:source]
+      classpath = classpath_from(options)
+      args << "-cp" << classpath unless classpath.empty?
+      sourcepath = (options[:sourcepath] || []).collect.join(File::PATH_SEPARATOR)
+      args << "-sourcepath" << sourcepath unless sourcepath.empty?
+      args += files
+      args << { :verbose=>options[:verbose] }
+      unless options[:noop]
+        verbose { puts "Running apt" }
+        sh(path_to_bin("apt"), *args) { |ok, res| fail "Failed to execute apt, see errors above" unless ok }
+      end
+    end
+
+    class AptTask < Rake::FileTask
+
+      def initialize(*args)
+        super
+        enhance do |task|
+          Java.apt *task.prerequisites + [options.merge(:output=>task.name)]
+        end
+      end
+
+      def options()
+        @options ||= {}
+      end
+
+      def using(options)
+        self.options.merge!(options)
+        self
+      end
+
+    end
+
+    def self.apt_task(args)
+      output = args.keys.first
+      files = args.values.first.collect { |f| File.directory?(f) ? FileList[f + "/**/*.java"] : f }.flatten
+      AptTask.define_task(output=>files)  
+    end
+
+    def self.javac(*args)
+      options = Hash === args.last ? args.pop : {}
+      options[:verbose] ||= Rake.application.options.trace || false
+      fu_check_options options, :verbose, :noop, :cp, :classpath, :sourcepath, :output, :javac_args, :name
+
+      files = args.flatten.each { |f| f.invoke if f.respond_to?(:invoke) }.map(&:to_s).
+        collect { |arg| File.directory?(arg) ? FileList[File.join(arg, "**", "*.java")] : arg }.flatten
+      name = options[:name] || Dir.pwd
+
+      cmd_args = []
+      classpath = classpath_from(options)
+      #classpath += options[:output] if options[:output]
+      cmd_args << "-cp" << classpath unless classpath.empty?
+      cmd_args << "-sourcepath" << options[:sourcepath].join(File::PATH_SEPARATOR) if options[:sourcepath]
+      cmd_args << "-d" << options[:output] if options[:output]
+      cmd_args += options[:javac_args].flatten if options[:javac_args]
+      cmd_args += files
+      cmd_args << { :verbose=>options[:verbose] }
+      unless options[:noop] || files.empty?
+        verbose { puts "Compiling #{files.size} source files in #{name}" }
+        sh(path_to_bin("javac"), *cmd_args) { |ok, res| fail "Failed to compile, see errors above" unless ok }
+      end
+    end
+
+  protected
+
+    def self.path_to_bin(name)
+      ENV["JAVA_HOME"] ? File.join(ENV["JAVA_HOME"], "bin", name) : name
+    end
+
+    def self.classpath_from(options)
+      classpath = (options[:classpath] || []).collect | (options[:cp] || []).collect
+      artifacts(classpath).each { |t| t.invoke if t.respond_to?(:invoke) }.
+        map(&:to_s).join(File::PATH_SEPARATOR)
+    end
+
+  end
+
+  def java(*args)
+    Java.java(*args)
+  end
+
+end

data/lib/java/javacc.rb

@@ -0,0 +1,88 @@
+module Buildr
+
+  module JavaCC
+
+    JAVACC = "net.java.dev.javacc:javacc:jar:4.0"
+    JJTREE = "net.java.dev.javacc:javacc:jar:4.0"
+
+    def self.javacc(*args)
+      options = Hash === args.last ? args.pop.clone : {}
+      options[:verbose] ||= Rake.application.options.trace || false
+      fu_check_options options, *Java::JAVA_OPTIONS + [:output]
+
+      (options[:classpath] ||= []) << JAVACC
+      java_args = ["javacc"]
+      java_args << "-OUTPUT_DIRECTORY=#{options[:output]}" if options[:output]
+      java_args += args.collect { |f| File.directory?(f) ? FileList[f + "/**/*.jj"] : f }.flatten
+      java_args << options.reject { |k, v| !Java::JAVA_OPTIONS.include?(k) }
+      Java.java(*java_args)
+    end
+
+    class JavaCCTask < Rake::FileTask
+
+      def initialize(*args)
+        super
+        enhance do |task|
+          JavaCC.javacc *(task.prerequisites + [task.options.merge(:output=>task.name)])
+        end
+      end
+
+      def options()
+        @options ||= {}
+      end
+
+      def using(options)
+        self.options.merge!(options)
+        self
+      end
+
+    end
+
+    def self.javacc_task(args)
+      output = args.keys.first
+      files = args.values.first.collect { |f| File.directory?(f) ? FileList[f + "/**/*.jj"] : f }.flatten
+      JavaCCTask.define_task(output=>files)  
+    end
+
+    def self.jjtree(*args)
+      options = Hash === args.last ? args.pop.clone : {}
+      options[:verbose] ||= Rake.application.options.trace || false
+      fu_check_options options, *Java::JAVA_OPTIONS + [:output, :build_node_files]
+
+      (options[:classpath] ||= []) << JJTREE
+      java_args = ["jjtree"]
+      java_args << "-OUTPUT_DIRECTORY=#{options[:output]}" if options[:output]
+      java_args << "-BUILD_NODE_FILES=#{options[:build_node_files]}" if options.has_key?(:build_node_files)
+      java_args += args.collect { |f| File.directory?(f) ? FileList[f + "/**/*.jjt"] : f }.flatten
+      java_args << options.reject { |k, v| !Java::JAVA_OPTIONS.include?(k) }
+      Java.java(*java_args)
+    end
+
+    class JJTreeTask < Rake::FileTask
+
+      def initialize(*args)
+        super
+        enhance do |task|
+          JavaCC.jjtree *(task.prerequisites + [task.options.merge(:output=>task.name)])
+        end
+      end
+
+      def options()
+        @options ||= {}
+      end
+
+      def using(options)
+        self.options.merge!(options)
+        self
+      end
+
+    end
+
+    def self.jjtree_task(args)
+      output = args.keys.first
+      files = args.values.first.collect { |f| File.directory?(f) ? FileList[f + "/**/*.jjt"] : f }.flatten
+      JJTreeTask.define_task(output=>files)
+    end
+
+  end
+end

data/lib/java/openjpa.rb

@@ -0,0 +1,52 @@
+module Buildr
+
+  module OpenJPA
+
+    VERSION = "0.9.7-incubating-SNAPSHOT"
+
+    REQUIRES = [ "org.apache.openjpa:openjpa-all:jar:#{VERSION}",
+      "commons-collections:commons-collections:jar:3.1",
+      "commons-dbcp:commons-dbcp:jar:1.2.1", 
+      "commons-lang:commons-lang:jar:2.1",
+      "commons-pool:commons-pool:jar:1.2",
+      "javax.persistence:persistence-api:jar:1.0",
+      "org.apache.geronimo.specs:geronimo-j2ee-connector_1.5_spec:jar:1.0",
+      "org.apache.geronimo.specs:geronimo-jta_1.0.1B_spec:jar:1.0",
+      "net.sourceforge.serp:serp:jar:1.11.0" ]
+
+    OPTIONS = [ :verbose, :noop, :cp, :classpath, :properties ]
+
+    def self.enhance(options)
+      options[:verbose] ||= Rake.application.options.trace || false
+      fu_check_options options, *OPTIONS + [:output]
+
+      runtool options.merge(:class=>"org.apache.openjpa.enhance.PCEnhancer", :name=>"Enhancer",
+        :args=>{ "-p"=>options[:properties], "-d"=>options[:output] })
+    end
+
+    def self.mapping_tool(options)
+      options[:verbose] ||= Rake.application.options.trace || false
+      fu_check_options options, *OPTIONS + [:action, :sql]
+
+      runtool options.merge(:class=>"org.apache.openjpa.jdbc.meta.MappingTool", :name=>"Mapping Tool",
+        :args=>{ "-p"=>options[:properties], "-sql"=>options[:sql], "-sa"=>options[:action] })
+    end
+
+  protected
+
+    def self.runtool(options)
+      classpath = REQUIRES + (options[:classpath] || []).collect | (options[:cp] || []).collect
+      classpath = artifacts(classpath).each { |t| t.invoke if t.respond_to?(:invoke) }.map(&:to_s)
+      cmd_args = ["-cp", classpath.join(File::PATH_SEPARATOR)]
+      cmd_args << options[:class]
+      cmd_args += options[:args].select { |n, v| v }.map { |n, v| [ n, v ] }.flatten
+      cmd_args << { :verbose=>options[:verbose] }
+      unless options[:noop]
+        verbose { puts "Running OpenJPA #{options[:name]}" }
+        sh(Java.path_to_bin("java"), *cmd_args) { |ok, res| fail "Failed to execute OpenJPA #{options[:name]}, see errors above" unless ok }
+      end
+    end
+
+  end
+
+end

data/lib/java/packaging.rb

@@ -0,0 +1,217 @@
+module Buildr
+  module Java
+
+    module Packaging
+
+      MANIFEST_HEADER = "Manifest-Version: 1.0\nCreated-By: Ruby Build System"
+
+      class JarTask < ZipTask
+        attr_accessor :manifest
+
+        def initialize(*args)
+          super
+          @manifest = true
+        end
+
+        def []=(key, value)
+          if key.to_sym == :manifest
+            self.manifest = value
+          else
+            super key, value
+          end
+          value
+        end
+
+      protected
+
+        def create(zip)
+          if manifest
+            zip.mkdir "META-INF"
+            zip.file.open("META-INF/MANIFEST.MF", "w") do |output|
+              output.write MANIFEST_HEADER
+              case manifest
+              when Hash
+                output.write manifest.map { |pair| pair.join(": ") }.join("\n")
+              when Array
+                manifest.each do |section|
+                  output.write "\n"
+                  output.write section.map { |pair| pair.join(": ") }.join("\n")
+                end
+              when Proc, Method
+                output.write manifest.call 
+              when String
+                output.write File.read(manifest)
+              when true # Default behavior
+              end
+              output.write "\n"
+            end
+          end
+          super zip
+        end
+
+      end
+
+      class WarTask < JarTask
+
+        def []=(key, value)
+          case key.to_sym
+          when :libs
+            self.include value, :path=>"WEB-INF/lib"
+          when :classes
+            self.include value, :path=>"WEB-INF/classes"
+          else
+            super key, value
+          end
+          value
+        end
+
+      end
+
+    end
+  end
+
+
+  # Create a JAR from all the pre-requisites.
+  #
+  # For example:
+  #   jar "lib-1.0.jar"=>["target/classes", "MANIFEST,MF"]
+  def jar(file)
+    Packaging::JarTask.define_task(file)
+  end
+
+
+  # Global task packages all projects.
+  desc "Package all projects"
+  LocalDirectoryTask.define_task "package"
+  desc "Install packages created by this project"
+  LocalDirectoryTask.define_task "install"
+  desc "Uninstall packages created by this project"
+  LocalDirectoryTask.define_task "uninstall"
+  desc "Deploy packages created by this project"
+  LocalDirectoryTask.define_task "deploy"
+
+
+  class Project
+
+    # Group used for packaging. Inherited from parent project.
+    inherited_attr :group
+    # Version used for packaging. Inherited from parent project.
+    inherited_attr :version
+
+    inherited_attr :webapp_src_dir do File.join(src_dir, "main", "webapp") end
+
+    def package(*args)
+      if Hash === args.last
+        options = args.pop.clone
+      else
+        options = {}
+      end
+      options[:type] = args.shift if Symbol === args.first
+      fail "No packaging type specified" unless options[:type]
+      options[:group] ||= self.group
+      options[:version] ||= self.version
+      options[:id] ||= self.id
+      if String === args.first
+        file = args.shift
+      else
+        file = options.delete(:file) || path_to(:target_dir, Artifact.hash_to_file_name(options))
+      end
+      fail "One argument too many; expecting at most type, file name, and hash of options" unless args.empty?
+
+      packager = method("package_as_#{options[:type]}") rescue
+        fail("Do not know how to create a package of type #{options[:type]}")
+      package = packager.call(file, options) or fail("Do not know how to create a package of type #{options[:type]}")
+
+      task("package").enhance [package]
+      package.enhance [task("build")]
+
+      task "install"=>[
+        file_create(File.dirname(repositories.locate(package))) { |task| mkpath task.name, :verbose=>false },
+        file(repositories.locate(package)=>package) { |task| cp package.name, task.name },
+        package.pom
+      ]
+
+      task "uninstall" do |task|
+        verbose(Rake.application.options.trace) do
+          rm repositories.locate(package)
+          rm repositories.locate(package.pom)
+        end
+      end
+
+      task "deploy"=>deploy(package, package.pom)
+
+      packages << package
+      Artifact.register package
+      package
+    end
+
+    def packages()
+      @packages ||= []
+    end
+
+  protected
+
+    def package_as_jar(file, options)
+      returning(Java::Packaging::JarTask.define_task(file)) do |task|
+        package_extend task, options
+        task.include path_to(:java_target_dir, "*")
+        task.include options[:include] if options[:include]
+        task.manifest = options[:manifest] if options[:manifest]
+      end
+    end
+
+    def package_as_war(file, options)
+      # Add anything we find in webapp sources directory.
+      returning(Java::Packaging::WarTask.define_task(file)) do |task|
+        package_extend task, options
+        task.include path_to(:webapp_src_dir, "*")
+        task.include options[:include] if options[:include]
+        # Add libraries in WEB-INF lib, and classes in WEB-INF classes
+        task.with :libs=>options[:libs].collect if options[:libs]
+        task.with :classes=>(options[:classes] || path_to(:java_target_dir, "**")) unless options[:classes] == false
+      end
+    end
+
+    def package_as_zip(file, options)
+      returning(ZipTask.define_task(file)) do |task|
+        package_extend task, options
+        task.include path_to(:java_target_dir, "*")
+        task.include options[:include] if options[:include]
+      end
+    end
+
+    def package_extend(task, spec)
+      task.extend ActsAsArtifact
+      task.apply_spec spec
+      task.pom.enhance do |task|
+        mkpath File.dirname(task.name), :verbose=>false
+        File.open(task.name, "w") do |file|
+          xml = Builder::XmlMarkup.new(:target=>file, :indent=>2)
+          xml.instruct!
+          xml.project do
+            xml.modelVersion  "4.0.0."
+            xml.groupId       spec[:group]
+            xml.artifactId    spec[:id]
+            xml.version       spec[:version]
+            xml.classifier    spec[:classifier] if spec[:classifier]
+          end
+        end
+      end
+    end
+
+  end
+
+
+  Project.on_create do |project|
+    # Recursive tasks must be defined in before_create.
+    desc "Create packages in this project"
+    project.recursive_task "package"=>"build"
+    desc "Install packages created by this project"
+    project.recursive_task "install"=>"package"
+    desc "Uninstall packages created by this project"
+    project.recursive_task "uninstall"
+    desc "Deploy packages created by this project"
+    project.recursive_task "deploy"=>"package"
+  end
+
+end