assaf-buildr 1.3.3

data/lib/buildr/java/pom.rb

@@ -0,0 +1,178 @@
+# 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 'xmlsimple'
+require 'buildr/packaging'
+
+
+module Buildr
+  class POM
+
+    POM_TO_SPEC_MAP = { :group=>"groupId", :id=>"artifactId", :type=>"type",
+      :version=>"version", :classifier=>"classifier", :scope=>"scope" }
+    SCOPES_TRANSITIVE = [nil, "compile", "runtime"]
+    SCOPES_WE_USE = SCOPES_TRANSITIVE + ["provided"]
+
+    # POM project as Hash (using XmlSimple).
+    attr_reader :project
+    # Parent POM if referenced by this POM.
+    attr_reader :parent
+
+    class << self
+      
+      # :call-seq:
+      #   POM.load(arg)
+      #
+      # Load new POM object form various kind of sources such as artifact, hash representing spec, filename, XML.
+      def load(source)
+        case source
+        when Hash
+          load(Buildr.artifact(source).pom)
+        when Artifact
+          pom = source.pom
+          pom.invoke
+          load(pom.to_s)
+        when Rake::FileTask
+          source.invoke
+          load(source.to_s)
+        when String
+          filename = File.expand_path(source)
+          unless pom = cache[filename]
+            trace "Loading m2 pom file from #{filename}"
+            pom = POM.new(IO.read(filename))
+            cache[filename] = pom
+          end
+          pom
+        else
+          raise ArgumentError, "Expecting Hash spec, Artifact, file name or file task"
+        end
+      end
+
+    private
+
+      def cache()
+        @cache ||= {}
+      end
+
+    end
+
+    def initialize(xml) #:nodoc:
+      @project = XmlSimple.xml_in(xml)
+      @parent = POM.load(pom_to_hash(project["parent"].first).merge(:type=>'pom')) if project['parent']
+    end
+
+    # :call-seq:
+    #   dependencies(scopes?) => artifacts
+    #
+    # Returns list of required dependencies as specified by the POM. You can specify which scopes
+    # to use (e.g. "compile", "runtime"); use +nil+ for dependencies with unspecified scope.
+    # The default scopes are +nil+, "compile" and "runtime" (aka SCOPES_WE_USE).
+    def dependencies(scopes = SCOPES_WE_USE)
+      #try to cache dependencies also
+      @depends_for_scopes ||= {}
+      unless depends = @depends_for_scopes[scopes]
+        declared = project["dependencies"].first["dependency"] rescue nil
+        depends = (declared || []).reject { |dep| value_of(dep["optional"]) =~ /true/ }.
+          map { |dep| 
+            spec = pom_to_hash(dep, properties) 
+            apply = managed(spec)
+            spec = apply.merge(spec) if apply
+
+            #calculate transitive dependencies
+            if scopes.include?(spec[:scope])
+              spec.delete(:scope)
+
+              exclusions = dep["exclusions"]["exclusion"] rescue nil
+              transitive_deps = POM.load(spec).dependencies(SCOPES_TRANSITIVE)
+              transitive_deps = transitive_deps.reject{|dep| 
+                exclusions.find {|ex| dep.index("#{dep['groupdId'].first}:#{dep['artifactId'].first}:") == 0}
+              } if exclusions
+
+              [Artifact.to_spec(spec)] + transitive_deps
+            end
+          }.flatten.compact #.uniq_by{|spec| art = spec.split(':'); "#{art[0]}:#{art[1]}"}
+
+        @depends_for_scopes[scopes] = depends
+      end
+      depends
+    end
+
+    # :call-seq:
+    #   properties() => hash
+    #
+    # Returns properties available to this POM as hash. Includes explicit properties and pom.xxx/project.xxx
+    # properties for groupId, artifactId, version and packaging.
+    def properties()
+      @properties ||= begin
+        pom = ["groupId", "artifactId", "version", "packaging"].inject({}) { |hash, key|
+          value = project[key] || (parent ? parent.project[key] : nil)
+          hash["pom.#{key}"] = hash["project.#{key}"] = value_of(value) if value
+          hash
+        }
+        props = project["properties"].first rescue {}
+        props = props.inject({}) { |mapped, pair| mapped[pair.first] = value_of(pair.last, pom) ; mapped }
+        (parent ? parent.properties.merge(props) : props).merge(pom)
+      end
+    end
+
+    # :call-seq:
+    #    managed() => hash
+    #    managed(hash) => hash
+    #
+    # The first form returns all the managed dependencies specified by this POM in dependencyManagement.
+    # The second form uses a single spec hash and expands it from the current/parent POM. Used to determine
+    # the version number if specified in dependencyManagement instead of dependencies.
+    def managed(spec = nil)
+      if spec
+        managed.detect { |dep| [:group, :id, :type, :classifier].all? { |key| spec[key] == dep[key] } } ||
+          (parent ? parent.managed(spec) : nil)
+      else
+        @managed ||= begin
+          managed = project["dependencyManagement"].first["dependencies"].first["dependency"] rescue nil
+          managed ? managed.map { |dep| pom_to_hash(dep, properties) } : []
+        end
+      end
+    end
+
+  private
+
+    # :call-seq:
+    #    value_of(element) => string
+    #    value_of(element, true) => string
+    #
+    # Returns the normalized text value of an element from its XmlSimple value. The second form performs
+    # property substitution.
+    def value_of(element, substitute = nil)
+      value = element.to_a.join.strip
+      substitute ? value.gsub(/\$\{([^}]+)\}/) { |key| substitute[$1] } : value
+    end
+
+    # :call-seq:
+    #    pom_to_hash(element) => hash
+    #    pom_to_hash(element, true) => hash
+    #
+    # Return the spec hash from an XmlSimple POM referencing element (e.g. project, parent, dependency).
+    # The second form performs property substitution.
+    def pom_to_hash(element, substitute = nil)
+      hash = POM_TO_SPEC_MAP.inject({}) { |spec, pair|
+        spec[pair.first] = value_of(element[pair.last], substitute) if element[pair.last]
+        spec
+      }
+      { :type=>"jar" }.merge(hash)
+    end
+
+  end
+end

data/lib/buildr/java/rjb.rb

@@ -0,0 +1,155 @@
+# 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 'rjb'
+
+
+# Equivalent to Java system properties.  For example:
+#   ENV_JAVA['java.version']
+#   ENV_JAVA['java.class.version']
+ENV_JAVA = {}
+
+
+# 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
+
+  module Package #:nodoc:
+
+    def method_missing(sym, *args, &block)
+      raise ArgumentError, 'No arguments expected' unless args.empty?
+      name = "#{@name}.#{sym}"
+      return ::Rjb.import(name) if sym.to_s =~ /^[[:upper:]]/
+      ::Java.send :__package__, name
+    end
+
+  end
+  
+  # On OS X we know where the default JDK is. We can try to guess for other OS.
+  # We set JAVA_HOME early so we can use it without calling Java.load first.
+  ENV['JAVA_HOME'] ||= '/System/Library/Frameworks/JavaVM.framework/Home' if Config::CONFIG['host_os'] =~ /darwin/i
+
+  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 ||= begin
+        home = ENV['JAVA_HOME'] or fail 'Are we forgetting something? JAVA_HOME not set.'
+        ['lib/tools.jar', '../lib/tools.jar'].map { |path| File.expand_path(path, home) }.
+          find { |path| File.exist?(path) }
+      end
+    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
+      classpath << tools_jar if tools_jar
+      
+      classpath.map! { |path| Proc === path ? path.call : path }
+      cp = Buildr.artifacts(classpath).map(&:to_s).each { |path| file(path).invoke }
+      java_opts = (ENV['JAVA_OPTS'] || ENV['JAVA_OPTIONS']).to_s.split
+      ::Rjb.load cp.join(File::PATH_SEPARATOR), java_opts
+
+      props = ::Rjb.import('java.lang.System').getProperties
+      enum = props.propertyNames 
+      while enum.hasMoreElements
+        name = enum.nextElement.toString
+        ENV_JAVA[name] = props.getProperty(name)
+      end
+      @loaded = true
+      self
+    end
+
+    def method_missing(sym, *args, &block) #:nodoc:
+      raise ArgumentError, 'No arguments expected' unless args.empty?
+      name = sym.to_s
+      return ::Rjb.import(name) if name =~ /^[[:upper:]]/
+      __package__ name
+    end
+
+  private
+
+    def __package__(name) #:nodoc:
+      const = name.split('.').map { |part| part.gsub(/^./) { |char| char.upcase } }.join
+      return const_get(const) if const_defined?(const)
+      package = Module.new
+      package.extend Package
+      package.instance_variable_set :@name, name
+      const_set(const, package)
+    end
+
+  end
+
+end
+
+
+class Array
+  # Converts a Ruby array into a typed Java array, argument specifies the element type.
+  # This is necessary for JRuby and causes no harm on RJB.
+  def to_java(cls)
+    map { |item| cls.new(item) }
+  end
+end

data/lib/buildr/java/test_result.rb

@@ -0,0 +1,308 @@
+# 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 'yaml'
+
+module Buildr #:nodoc:
+  module TestFramework
+    
+    # A class used by buildr for jruby based frameworks, so that buildr can know 
+    # which tests succeeded/failed.
+    class TestResult
+
+      class Error < ::Exception
+        attr_reader :message, :backtrace
+        def initialize(message, backtrace)
+          @message = message
+          @backtrace = backtrace
+          set_backtrace backtrace
+        end
+
+        def self.dump_yaml(file, e)
+          require 'fileutils'
+          FileUtils.mkdir_p(File.dirname(file))
+          File.open(file, 'w') { |f| f.puts(YAML.dump(Error.new(e.message, e.backtrace))) }
+        end
+
+        def self.guard(file)
+          begin 
+            yield
+          rescue
+            dump_yaml(file)
+          end
+        end
+      end
+      
+      attr_accessor :failed, :succeeded
+
+      def initialize
+        @failed, @succeeded = [], []
+      end
+
+      # An Rspec formatter used by buildr
+      class YamlFormatter
+        attr_reader :result
+
+        attr_accessor :example_group, :options, :where
+        
+        def initialize(options, where)
+          @options = options
+          @where = where
+          @result = Hash.new
+          @result[:succeeded] = []
+          @result[:failed] = []
+        end
+        
+        %w[ example_started
+            start_dump dump_failure dump_summary dump_pending ].each do |meth|
+          module_eval "def #{meth}(*args); end"
+        end
+
+        def add_example_group(example_group)
+          @example_group = example_group
+        end
+
+        def example_passed(example)
+        end
+
+        def example_pending(example, counter, failure)
+        end
+
+        def example_failed(example, counter, failure)
+          if example_group.respond_to?(:spec_path)
+            result.failed << example_group.spec_path.gsub(/:\d+$/, '')
+          else
+            path = path_from_bt(failure.exception.backtrace)
+            result.failed << path if path
+          end
+        end
+
+        def start(example_count)
+          @result = TestResult.new
+        end
+
+        def path_from_bt(ary)
+          files = options.files
+          test = nil
+          ary.find do |bt|
+            bt = bt.split(':').first.strip
+            test = bt if files.include?(bt)
+          end
+          test
+        end
+
+        def close
+          files = options.files
+          result.succeeded = files - result.failed
+          
+          FileUtils.mkdir_p(File.dirname(where))
+          File.open(where, 'w') { |f| f.puts YAML.dump(result) }
+        end
+      end # YamlFormatter
+
+      # A JtestR ResultHandler
+      # Using this handler we can use RSpec formatters, like html/ci_reporter with JtestR
+      # Created for YamlFormatter
+      class RSpecResultHandler
+
+        # Workaround for http://jira.codehaus.org/browse/JTESTR-68
+        module TestNGResultHandlerMixin
+          def onTestSuccess(test_result)
+            @result_handler.succeed_single(test_result.name)
+          end
+        end
+
+        class BacktraceTweaker
+          attr_reader :ignore_patterns
+          def initialize
+            @ignore_patterns = ::Spec::Runner::QuietBacktraceTweaker::IGNORE_PATTERNS.dup
+            # ignore jruby/jtestr backtrace
+            ignore_patterns << /org\.jruby\.javasupport\.JavaMethod\./
+            ignore_patterns << /jtestr.*\.jar!/i << /runner\.rb/
+          end
+          
+          def clean_up_double_slashes(line)
+            line.gsub!('//','/')
+          end
+
+          def tweak_backtrace(error)
+            return if error.backtrace.nil?
+            error.backtrace.collect! do |line|
+              clean_up_double_slashes(line)
+              ignore_patterns.each do |ignore|
+                if line =~ ignore
+                  line = nil
+                  break
+                end
+              end
+              line
+            end
+            error.backtrace.compact!
+          end
+        end
+        
+        class << self
+          # an rspec reporter used to proxy events to rspec formatters
+          attr_reader :reporter
+
+          def init(argv = [], out = STDOUT, err = STDERR)
+            ::JtestR::TestNGResultHandler.module_eval { include TestNGResultHandlerMixin }
+            rspec_parser = ::Spec::Runner::OptionParser.new(err, out)
+            rspec_parser.order!(argv)
+            rspec_parser.options.backtrace_tweaker = BacktraceTweaker.new
+            @reporter = Spec::Runner::Reporter.new(rspec_parser.options)
+          end
+
+          def before
+            reporter.start(reporter.options.files.size)
+          end
+
+          def after
+            reporter.end
+            reporter.dump
+          end
+        end
+
+        module ExampleMethods
+          attr_accessor :name, :description, :__full_description
+        end
+
+        def reporter
+          self.class.reporter
+        end
+
+        attr_accessor :example_group, :current_example, :current_failure
+
+        def initialize(name, desc, *args)
+          self.example_group = ::Spec::Example::ExampleGroup.new(desc)
+          example_group.extend ExampleMethods
+          example_group.name = name.to_s
+          if example_group.name[/Spec/]
+            example_group.description = desc.to_s
+          else
+            example_group.description = name.to_s
+          end
+          reporter.add_example_group(example_group)
+        end
+
+        def starting
+        end
+
+        def ending
+        end
+
+        def add_fault(fault)
+          self.current_failure = fault
+        end
+
+        def add_pending(pending)
+        end
+
+        def starting_single(name = nil)
+          self.current_failure = nil
+          self.current_example = Object.new
+          current_example.extend ::Spec::Example::ExampleMethods
+          current_example.extend ExampleMethods
+          name = name.to_s
+          name[/\((pen?ding|error|failure|success)\)?$/]
+          name = $`
+          current_example.description = name
+          if example_group.name[/Spec/]
+            current_example.__full_description = "#{example_group.description} #{name}"
+          else
+            current_example.__full_description = "#{example_group.name}: #{name}"
+          end
+          reporter.example_started(current_example)
+          #puts "STARTED #{name} #{current_example.__full_description}"
+        end
+
+        def succeed_single(name = nil)
+          #puts "SUCC SINGLE #{name}"
+          reporter.example_finished(current_example, nil)
+        end
+        
+        def fail_single(name = nil)
+          #puts "FAIL SINGLE #{name}"
+          reporter.example_finished(current_example, current_error)
+        end
+
+        def error_single(name = nil)
+          #puts "ERR SINGLE #{name}"
+          reporter.example_finished(current_example, current_error)
+        end
+
+        def pending_single(name = nil)
+          #puts "PEND SINGLE #{name}"
+          error = ::Spec::Example::ExamplePendingError.new(name)
+          reporter.example_finished(current_example, error)
+        end
+
+      private
+        def current_error(fault = current_failure)
+          case fault
+          when nil
+            nil
+          when Test::Unit::Failure
+            Error.new(fault.message, fault.location)
+          when Test::Unit::Error
+            if fault.exception.is_a?(NativeException)
+              exception = fault.exception.cause
+              bt = exception.stack_trace.to_a
+            else
+              exception = fault.exception
+              bt = exception.backtrace
+            end
+            Error.new(exception.message, bt)
+          when Expectations::Results::Error
+            fault.exception
+          when Spec::Runner::Reporter::Failure
+            ex = fault.exception
+            fault.example.instance_variable_get(:@_implementation).to_s =~ /@(.+:\d+)/
+            Error.new(ex.message, [$1.to_s] + ex.backtrace)
+          when Expectations::Results
+            file = fault.file
+            line = fault.line
+            Error.new(fault.message, ["#{fault.file}:#{fault.line}"])
+          else
+            if fault.respond_to?(:test_header)
+              fault.test_header[/\((.+)\)/]
+              test_cls, test_meth = $1.to_s, $`.to_s
+              exception = fault.exception
+              (class << exception; self; end).module_eval do
+                define_method(:backtrace) do 
+                  (["#{test_cls}:in `#{test_meth}'"] + stackTrace).map { |s| s.to_s }
+                end
+              end
+              exception
+            elsif fault.respond_to?(:method)
+              test_cls, test_meth = fault.method.test_class.name, fault.method.method_name
+              exception = fault.throwable
+              (class << exception; self; end).module_eval do
+                define_method(:backtrace) do 
+                  (["#{test_cls}:in `#{test_meth}'"] + stackTrace).map { |s| s.to_s }
+                end
+              end
+              exception
+            else
+              raise "Cannot handle fault #{fault.class}: #{fault.inspect}"
+            end
+          end
+        end
+
+      end # RSpecResultHandler
+
+    end # TestResult
+  end
+end