ittayd-buildr 1.3.4 → 1.3.5

data/lib/buildr/java/pom.rb

@@ -1,174 +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.
-
-
-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

@@ -1,155 +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 '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

@@ -1,307 +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.
-
-
-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