Buildr 0.17.0

data/lib/java/openjpa.rb

@@ -0,0 +1,57 @@
+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] },
+        :classpath=>options[:classpath] + [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 = (options[:classpath] || []).collect | (options[:cp] || []).collect
+      classpath = classpath.each { |t| t.invoke if t.respond_to?(:invoke) }.map(&:to_s)
+      cmd_args = ["-cp", (classpath + requires).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
+
+    def self.requires()
+      @required ||= artifacts(REQUIRES).each { |artifact| artifact.invoke }.map(&:to_s)
+    end
+
+  end
+
+end

data/lib/java/packaging.rb

@@ -0,0 +1,214 @@
+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 artifacts(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
+
+
+  class Project
+
+    # Group used for packaging. Inherited from parent project.
+    inherited_attr :group
+    # Version used for packaging. Inherited from parent project.
+    inherited_attr :version
+
+    # The project ID is the project name, and for a sub-project the
+    # parent project ID followed by the project name, separated with a
+    # hyphen. For example, "foo" and "foo-bar".
+    def id()
+      name.gsub(":", "-")
+    end
+    inherited_attr :webapp_src_dir do File.join(src_dir, "main", "webapp") end
+
+    def package(*args)
+      if Hash === args.last
+        options = args.pop.dup
+      else
+        options = {}
+      end
+      options[:type] = args.shift.to_s 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"=>package
+      package.enhance [ task("build")]
+
+      task "install"=>(file(repositories.locate(package)=>package) { |task|
+        mkpath File.dirname(task.name), :verbose=>false
+        cp package.name, task.name
+      })
+      task "install"=>package.pom
+
+      task "uninstall" do |task|
+        verbose(Rake.application.options.trace) do
+          [ package, package.pom ].map { |artifact| repositories.locate(artifact) }.
+            each { |file| rm file if File.exist?(file) } 
+        end
+      end
+
+      task("deploy") { deploy(package, package.pom) }
+
+      packages << package
+      Artifact.register package, package.pom
+      package
+    end
+
+    def packages()
+      @packages ||= []
+    end
+
+  protected
+
+    def package_as_jar(file, options)
+      unless Rake::Task.task_defined?(file)
+        returning(Java::Packaging::JarTask.define_task(file)) do |task|
+          package_extend task, options
+          task.enhance [path_to(:java_target_dir)]
+          task.include path_to(:java_target_dir, "*")
+        end
+      end
+      returning(Java::Packaging::JarTask.define_task(file)) do |task|
+        task.include options[:include] if options[:include]
+        task.manifest = options[:manifest] if options[:manifest]
+      end
+    end
+
+    def package_as_war(file, options)
+      unless Rake::Task.task_defined?(file)
+        returning(Java::Packaging::WarTask.define_task(file)) do |task|
+          package_extend task, options
+          task.include path_to(:webapp_src_dir, "*")
+          task.with :classes=>path_to(:java_target_dir, "**")
+        end
+      end
+      # Add anything we find in webapp sources directory.
+      returning(Java::Packaging::WarTask.define_task(file)) do |task|
+        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] if options[:classes]
+      end
+    end
+
+    def package_as_zip(file, options)
+      unless Rake::Task.task_defined?(file)
+        returning(ZipTask.define_task(file)) do |task|
+          package_extend task, options
+          task.include path_to(:java_target_dir, "*")
+        end
+      end
+      returning(ZipTask.define_task(file)) do |task|
+        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
+
+
+end

data/lib/java/test.rb

@@ -0,0 +1,105 @@
+module Buildr
+
+  class JUnitTask < Rake::Task
+
+    attr_accessor :base_dir
+    attr_accessor :target
+    attr_accessor :classpath
+
+    def initialize(*args)
+      super
+      @classpath = []
+      enhance do |task|
+        test_cases.each do |test|
+          Dir.chdir base_dir
+          java "junit.textui.TestRunner", test, :classpath=>real_classpath, :name=>"tests in #{test}"
+        end
+      end
+    end
+
+    def test_cases()
+      target = File.expand_path(self.target)
+      return [] unless File.exist?(target)
+      prefix = Regexp.new("^" + Regexp.escape(target) + "/")
+      FileList[File.join(target, "**", "*Test.class")].
+        map { |path| path.sub(prefix, "").ext("").gsub(File::SEPARATOR, ".") }.sort
+    end
+
+    def real_classpath()
+      @real_classpath ||= artifacts(@classpath).map(&:to_s)
+    end
+
+  end
+
+  class Tests
+    def prepare(*tasks, &block)
+      returning(@prepare_task ||= task("prepare")) { |task| task.enhance tasks, &block }
+    end
+
+    def compile(*sources, &block)
+      unless @compile_task
+        @compile_task = Java::CompileTask.define_task("compile"=>prepare) { |task| resources.invoke }
+      end
+      returning(@compile_task) { |task| task.sources |= sources ; task.enhance &block }
+    end
+
+    def resources(*tasks, &block)
+      returning(@resources_task ||= Filter.define_task("resources")) { |task| task.enhance tasks, &block }
+    end
+
+    def junit(*tasks, &block)
+      unless @junit_task
+        @junit_task = JUnitTask.define_task("junit"=>compile)
+      end
+      returning(@junit_task) { |task| task.enhance tasks, &block }
+    end
+  end
+
+  class Project
+    inherited_attr :test_src_dir do File.join(src_dir, "test", "java") end
+    inherited_attr :test_resources_dir do File.join(src_dir, "test", "resources") end
+    inherited_attr :test_target_dir do File.join(target_dir, "test-classes") end
+
+    def tests()
+      @tests ||= Tests.new
+    end
+
+    def test(*tasks, &block)
+      @tests.junit *tasks, &block
+    end
+  end
+      
+  # Global task compiles all projects.
+  desc "Run all test cases"
+  Project.local_task(task("test"))
+
+  Project.on_define do |project|
+    tests = nil
+    namespace "test" do
+      tests = project.tests
+    #tests.compile.enhance([tests.prepare]) { |task| tests.resources.invoke }
+      tests.compile.classpath += [ "junit:junit:jar:3.8.1", "jmock:jmock:jar:1.1.0" ]
+      tests.junit
+    end
+    tests.compile.enhance [ project.compile ]
+    project.recursive_task("test"=>project.test)
+
+    #project.recursive_task("compile")
+    #task("build").enhance [ project.compile ]
+    #task("clean") { rm_rf project.path_to(:target_dir), :verbose=>false }
+
+    project.enhance do |project|
+      tests.compile.sources << project.path_to(:test_src_dir) if File.exist?(project.path_to(:test_src_dir))
+      tests.compile.target ||= project.path_to(:test_target_dir)
+      tests.compile.classpath << project.compile.target
+      tests.resources.include project.path_to(:test_resources_dir, "*") if File.exists?(project.path_to(:test_resources_dir))
+      tests.resources.target ||= tests.compile.target
+      tests.junit.target = tests.compile.target
+      tests.junit.classpath += tests.compile.classpath
+      tests.junit.classpath += [ tests.compile.target, project.compile.target ]
+      tests.junit.base_dir = project.base_dir
+      file(tests.compile.target).enhance [ tests.compile ]
+      file(tests.resources.target).enhance [ tests.resources ]
+    end
+  end
+end

data/lib/java/xmlbeans.rb

@@ -0,0 +1,66 @@
+module Buildr
+
+  module XMLBeans
+
+    REQUIRES = [ "xmlbeans:xbean:jar:2.2.0", "stax:stax-api:jar:1.0" ]
+
+    def self.compile(*args)
+      options = Hash === args.last ? args.pop : {}
+      options[:verbose] ||= Rake.application.options.trace || false
+      fu_check_options options, :verbose, :noop, :javasource, :jar, :classes, :output
+
+      # Options for SchemaCompiler.
+      cmd_args = [ options[:verbose] ? "-verbose" : "-quiet" ]
+      cmd_args << "-javasource" << options[:javasource].collect.join(File::PATH_SEPARATOR) if options[:javasource]
+      cmd_args << "-out" << options[:jar] if options[:jar]
+      cmd_args << "-d" << options[:classes] if options[:classes]
+      cmd_args << "-src" << options[:output] if options[:output]
+      cmd_args += args
+      cmd_args << { :verbose=>options[:verbose] }
+
+      unless options[:noop]
+        verbose { puts "Running XMLBeans schema compiler" }
+        mkpath options[:classes], :verbose=>false rescue nil if options[:classes]
+        mkpath options[:output], :verbose=>false rescue nil if options[:output]
+        sh(Java.path_to_bin("java"), "-Xmx256m", "-cp", requires.join(File::PATH_SEPARATOR),
+          "org.apache.xmlbeans.impl.tool.SchemaCompiler", *cmd_args) { |ok, res|
+          fail "Failed to compile schemas, see errors above" unless ok }
+        # Touch paths to let other tasks know there's an update.
+        touch options[:classes], :verbose=>false if options[:classes]
+        touch options[:output], :verbose=>false if options[:output]
+      end
+    end
+
+    def self.requires()
+      @requires ||= artifacts(REQUIRES).each { |artifact| artifact.invoke }.map(&:to_s)
+    end
+    
+    class CompileTask < Rake::FileTask
+
+      def initialize(*args)
+        super
+        enhance do |task|
+          XMLBeans.compile *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.compile_task(args)
+      output = args.keys.first
+      files = args.values.first.collect { |f| File.directory?(f) ? FileList[f + "/**/*"] : f }.flatten
+      CompileTask.define_task(output=>files)  
+    end
+
+  end
+
+end

data/lib/tasks/download.rb

@@ -0,0 +1,38 @@
+require "tempfile"
+
+module Buildr
+
+  # Create a task that will download a file from a URL.
+  #
+  # Takes a single argument, a hash with one pair. The key is the file being
+  # created, the value if the URL to download. The task executes only if the
+  # file does not exist; the URL is not checked for updates.
+  #
+  # The task will show download progress on the console; if there are MD5/SHA1
+  # checksums on the server it will verify the download before saving it.
+  #
+  # For example:
+  #   download "image.jpg"=>"http://example.com/theme/image.jpg"
+  def download(args)
+    if String === args || URI === args
+      # Given only a download URL, download into a temporary file.
+      # You can infer the file from task name.
+      temp = Tempfile.new(File.basename(args.to_s))
+      task = file_create(temp.path) do |task|
+        Transports.download task.source, task.name
+      end
+      task.sources << args
+    else
+      # Download to a file created by the task.
+      fail unless args.keys.size == 1
+      url = args.values.first
+      task = file_create(args.keys.first) do |task|
+        mkpath File.dirname(task.name), :verbose=>false
+        Transports.download task.source, task.name
+      end
+      task.sources << url
+    end
+    task
+  end
+
+end