buildr 1.4.4-x86-mswin32 → 1.4.5-x86-mswin32

data/lib/buildr/java/packaging.rb

@@ -391,13 +391,17 @@ module Buildr
 
         # The display-name entry for application.xml
         attr_accessor :display_name
+        # The description entry for application.xml
+        attr_accessor :description
         # Map from component type to path inside the EAR.
         attr_accessor :dirs
+        # Security roles entry for application.xml
+        attr_accessor :security_roles
 
         def initialize(*args)
           super
           @dirs = Hash.new { |h, k| k.to_s }
-          @libs, @components = [], []
+          @libs, @components, @security_roles = [], [], []
           prepare do
             @components.each do |component|
               path(component[:path]).include(component[:clone] || component[:artifact])
@@ -529,6 +533,8 @@ module Buildr
           "http://java.sun.com/j2ee/dtds/application_1_2.dtd"
           xml.application do
             xml.tag! 'display-name', display_name
+            desc = self.description || @project.comment
+            xml.tag! 'description', desc if desc
             @components.each do |comp|
               basename = comp[:artifact].to_s.pathmap('%f')
               uri = comp[:path].empty? ? basename : File.join(comp[:path], basename)
@@ -548,6 +554,12 @@ module Buildr
                 xml.jar uri
               end
             end
+            @security_roles.each do |role|
+              xml.tag! 'security-role', :id=>role[:id] do
+                xml.description role[:description]
+                xml.tag! 'role-name', role[:name]
+              end
+            end
           end
           buffer
         end
@@ -702,13 +714,12 @@ module Buildr
       end
 
       def package_as_javadoc_spec(spec) #:nodoc:
-        spec.merge(:type=>:zip, :classifier=>'javadoc')
+        spec.merge(:type=>:jar, :classifier=>'javadoc')
       end
 
       def package_as_javadoc(file_name) #:nodoc:
         ZipTask.define_task(file_name).tap do |zip|
           zip.include :from=>doc.target
-          doc.options[:windowtitle] ||= project.comment || project.name
         end
       end
 

data/lib/buildr/java/pom.rb

@@ -48,7 +48,11 @@ module Buildr
           filename = File.expand_path(source)
           unless pom = cache[filename]
             trace "Loading m2 pom file from #{filename}"
-            pom = POM.new(IO.read(filename))
+            begin
+              pom = POM.new(IO.read(filename))
+            rescue REXML::ParseException => e
+              fail "Could not parse #{filename}, #{e.continued_exception}"
+            end
             cache[filename] = pom
           end
           pom
@@ -115,7 +119,7 @@ module Buildr
       @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[key] = hash["pom.#{key}"] = hash["project.#{key}"] = value_of(value) if value
           hash
         }
         props = project["properties"].first rescue {}

data/lib/buildr/java/test_result.rb

@@ -14,8 +14,10 @@
 # the License.
 
 # necessary to require YAML even if it is mentioned by autoload as it fails on some platforms.
-require 'yaml' 
+require 'yaml'
 require 'fileutils'
+require 'rspec/core/formatters/base_formatter'
+
 module Buildr #:nodoc:
   module TestFramework
 
@@ -52,278 +54,48 @@ module Buildr #:nodoc:
       end
 
       # An Rspec formatter used by buildr
-      class YamlFormatter
+      class YamlFormatter  < ::RSpec::Core::Formatters::BaseFormatter
         attr_reader :result
 
-        attr_accessor :example_group, :options, :where
-
-        def initialize(options, where)
-          @options = options
-          @where = where
+        def initialize(output)
+          super(output)
           @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 example_group_started(example_group)
-          @example_group = example_group
-        end
-
         def example_passed(example)
+          super(example)
           result.succeeded << example_name(example)
         end
 
-        def example_pending(example, counter)
+        def example_pending(example)
+          super(example)
           result.succeeded << example_name(example)
         end
 
-        def example_failed(example, counter, failure)
+        def example_failed(example)
+          super(example)
           result.failed << example_name(example)
         end
 
         def start(example_count)
+          super(example_count)
           @result = TestResult.new
         end
 
         def close
+          super
           result.succeeded = result.succeeded - result.failed
-          FileUtils.mkdir_p File.dirname(where)
-          File.open(where, 'w') { |f| f.puts YAML.dump(result) }
+          output.puts YAML.dump(result)
         end
 
       private
         def example_name(example)
-          if Spec::Example::ExampleProxy === example
-            example_group.location.gsub(/:\d+$/, '')
-          else
-            example.name.gsub(/(.+)(\..+\(\))/, '\1')
-          end
+          example.file_path
         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
-          attr_accessor :test_files
-
-          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, :location
-        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.example_group_started(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
-          current_example.location = name.to_s
-          current_example.name = name.gsub(/(.*)\((.+)\)/, '\2')
-          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)
-        end
-
-        def succeed_single(name = nil)
-          reporter.example_finished(current_example, nil)
-        end
-
-        def fail_single(name = nil)
-          current_example.name = current_name
-          reporter.example_finished(current_example, current_error)
-        end
-
-        def error_single(name = nil)
-          current_example.name = current_name
-          reporter.example_finished(current_example, current_error)
-        end
-
-        def pending_single(name = nil)
-          error = ::Spec::Example::ExamplePendingError.new(name)
-          reporter.example_finished(current_example, error)
-        end
-
-      private
-        def detect_file(trace)
-          # find first matching test file in stacktrace
-          file = nil
-          first_pos = nil
-          RSpecResultHandler.test_files.each do |f|
-            pos = trace.index(f)
-            if pos && (first_pos.nil? || pos < first_pos)
-              file = f
-              first_pos = pos
-            end
-          end
-          file || fail("RSpecResultHandler.detect_file failed: #{trace}")
-        end
-
-        def current_name(example = current_example, fault = current_failure)
-          return example.name unless fault
-          case fault
-          when Test::Unit::Error
-            detect_file(fault.long_display)
-          when Test::Unit::Failure
-            detect_file(fault.location.to_s)
-          when Spec::Runner::Reporter::Failure
-            detect_file(fault.exception.backtrace.to_s)
-          else
-            example.name
-          end
-        end
-
-        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
-            Error.new(ex.message, 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

data/lib/buildr/java/tests.rb

@@ -219,7 +219,7 @@ module Buildr
     end
 
     def tests(dependencies) #:nodoc:
-      if (self.class.version[0,1].to_i < 4)
+      if (self.class.version.to_s[0,1].to_i < 4)
         filter_classes(dependencies, :interfaces => %w{junit.framework.TestCase})
       else
         filter_classes(dependencies,

data/lib/buildr/packaging.rb

@@ -20,5 +20,6 @@ require 'buildr/packaging/archive'
 require 'buildr/packaging/ziptask'
 require 'buildr/packaging/tar'
 require 'buildr/packaging/gems'
+require 'buildr/packaging/zip'
 autoload :Zlib, 'zlib'
-autoload :Zip, 'buildr/packaging/zip'
+

data/lib/buildr/packaging/#package.rb.rej#

@@ -0,0 +1,19 @@
+--- lib/buildr/packaging/package.rb
++++ lib/buildr/packaging/package.rb
+@@ -183,12 +183,16 @@
+                 pom_filename = Util.replace_extension(self.name, 'pom') 
+                 spec = {:group=>group, :id=>id, :version=>version, :type=>:pom} @pom = Buildr.artifact(spec, pom_filename) 
++                @pom.dependencies = dependencies 
+                 @pom.content @pom.pom_xml 
+               end 
+               @pom 
+             end 
+           end 
+ 
++          # package dependencies are compile dependencies iff not otherwise set
++          package.dependencies |= compile.dependencies 
++ 
+           file(Buildr.repositories.locate(package)=>package) { package.install 
+ 
+           # Add the package to the list of packages created by this project, an 
+ 

data/lib/buildr/packaging/archive.rb

@@ -113,7 +113,10 @@ module Buildr
         expanders = files.collect do |file|
           @sources << proc { file.to_s }
           expander = ZipExpander.new(file)
-          @actions << proc { |file_map| expander.expand(file_map, path) }
+          @actions << proc do |file_map|
+            file.invoke() if file.is_a?(Rake::Task)
+            expander.expand(file_map, path)
+          end
           expander
         end
         Merge.new(expanders)
@@ -202,7 +205,6 @@ module Buildr
     end
 
     def include_as(source, as)
-
         @sources << proc { source }
         @actions << proc do |file_map|
           file = source.to_s
@@ -467,7 +469,15 @@ module Buildr
     def invoke_prerequisites(args, chain) #:nodoc:
       @prepares.each { |prepare| prepare.call(self) }
       @prepares.clear
-      @prerequisites |= @paths.collect { |name, path| path.sources }.flatten
+
+      file_map = {}
+      @paths.each do |name, path|
+        path.add_files(file_map)
+      end
+
+      # filter out Procs (dynamic content), nils and others
+      @prerequisites |= file_map.values.select { |src| src.is_a?(String) || src.is_a?(Rake::Task) }
+
       super
     end