buildr 1.5.3-x86-mswin32 → 1.5.4-x86-mswin32

data/lib/buildr/packaging/package.rb

@@ -182,7 +182,7 @@ module Buildr #:nodoc:
               end
               @pom
             end
-          end
+          end if package.classifier.nil?
 
           file(Buildr.repositories.locate(package)=>package) { package.install }
 
@@ -190,7 +190,8 @@ module Buildr #:nodoc:
           # register it as an artifact. The later is required so if we look up the spec
           # we find the package in the project's target directory, instead of finding it
           # in the local repository and attempting to install it.
-          Artifact.register package, package.pom
+          Artifact.register package
+          Artifact.register package.pom if package.classifier.nil?
         end
 
         task('install')   { package.install if package.respond_to?(:install) }

data/lib/buildr/packaging/tar.rb

@@ -72,40 +72,75 @@ module Buildr #:nodoc:
       end
     end
 
-  private
+    private
 
-    def create_from(file_map)
+    def create_from(file_map, transform_map)
       if gzip
         StringIO.new.tap do |io|
-          create_tar io, file_map
+          create_tar io, file_map, transform_map
           io.seek 0
           Zlib::GzipWriter.open(name) { |gzip| gzip.write io.read }
         end
       else
-        File.open(name, 'wb') { |file| create_tar file, file_map }
+        File.open(name, 'wb') { |file| create_tar file, file_map, transform_map }
       end
     end
 
-    def create_tar(out, file_map)
+    def create_tar(out, file_map, transform_map)
       Archive::Tar::Minitar::Writer.open(out) do |tar|
         options = { :mode=>mode || '0755', :mtime=>Time.now }
 
-        file_map.each do |path, content|
-          if content.respond_to?(:call)
-            tar.add_file(path, content.respond_to?(:mode) ? options.merge(:mode => content.mode) : options) { |os, _| content.call os }
-          elsif content.nil?
-          elsif File.directory?(content.to_s)
-            stat = File.stat(content.to_s)
+        file_map.each do |path, contents|
+          to_transform = []
+          transform = transform_map.key?(path)
+          if contents.nil?
+          elsif File.directory?(contents.to_s)
+            stat = File.stat(contents.to_s)
             tar.mkdir(path, options.merge(:mode=>stat.mode, :mtime=>stat.mtime, :uid=>stat.uid, :gid=>stat.gid))
           else
-            File.open content.to_s, 'rb' do |is|
-              tar.add_file path, options.merge(:mode=>is.stat.mode, :mtime=>is.stat.mtime, :uid=>is.stat.uid, :gid=>is.stat.gid) do |os, opts|
-                while data = is.read(4096)
-                  os.write(data)
+            contents = [contents].flatten
+            
+            combined_options = options
+            if File.exists?(contents.first.to_s)
+              stat = File.stat(contents.first.to_s)
+              combined_options = options.merge(:mode=> stat.mode, :mtime=> stat.mtime, :uid=>stat.uid, :gid=> stat.gid)
+            elsif contents.first.respond_to?(:mode)
+              combined_options = combined_options.merge(:mode => contents.first.mode)
+            end
+              
+            
+            tar.add_file path, combined_options do |os, opts|
+              [contents].flatten.each do |content|
+                if content.respond_to?(:call)
+                  if transform
+                    output = StringIO.new
+                    content.call output
+                    to_transform << output.string
+                  else
+                    content.call os
+                  end
+                else
+                  File.open content.to_s, 'rb' do |is| 
+                    if transform
+                      output = StringIO.new
+                      while data = is.read(4096)
+                        output << data
+                      end
+                      to_transform << output.string
+                    else
+                      while data = is.read(4096)
+                        os.write(data)
+                      end
+                    end
+                  end
                 end
               end
+              if transform_map.key?(path)
+                os.write(transform_map[path].call(to_transform))
+              end
             end
           end
+          
         end
       end
     end
@@ -128,7 +163,7 @@ module Buildr #:nodoc:
     def contain?(*patterns)
       content = read_content_from_tar
       patterns.map { |pattern| Regexp === pattern ? pattern : Regexp.new(Regexp.escape(pattern.to_s)) }.
-        all? { |pattern| content =~ pattern }
+      all? { |pattern| content =~ pattern }
     end
 
     # :call-seq:

data/lib/buildr/packaging/ziptask.rb

@@ -49,9 +49,9 @@ module Buildr #:nodoc:
       @entries ||= Zip::File.open(name) { |zip| zip.entries }
     end
 
-  private
+    private
 
-    def create_from(file_map)
+    def create_from(file_map, transform_map)
       Zip::OutputStream.open name do |zip|
         seen = {}
         mkpath = lambda do |dir|
@@ -65,24 +65,52 @@ module Buildr #:nodoc:
 
         paths = file_map.keys.sort
         paths.each do |path|
-          content = file_map[path]
+          contents = file_map[path]
           warn "Warning:  Path in zipfile #{name} contains backslash: #{path}" if path =~ /\\/
-          mkpath.call File.dirname(path)
-          if content.respond_to?(:call)
-            entry = zip.put_next_entry(path, compression_level)
-            entry.unix_perms = content.mode & 07777 if content.respond_to?(:mode)
-            content.call zip
-          elsif content.nil? || File.directory?(content.to_s)
-            mkpath.call path
-          else
-            entry = zip.put_next_entry(path, compression_level)
-            File.open content.to_s, 'rb' do |is|
-              entry.unix_perms = is.stat.mode & 07777
-              while data = is.read(4096)
-                zip << data
+          
+          entry_created = false
+          to_transform = []
+          transform = transform_map.key?(path)
+          [contents].flatten.each do |content|
+            if content.respond_to?(:call)
+              unless entry_created
+                entry = zip.put_next_entry(path, compression_level)
+                entry.unix_perms = content.mode & 07777 if content.respond_to?(:mode)
+                entry_created = true
+              end
+              if transform
+                output = StringIO.new
+                content.call output
+                to_transform << output.string
+              else
+                content.call zip
+              end
+            elsif content.nil? || File.directory?(content.to_s)
+              mkpath.call path
+            else
+              File.open content.to_s, 'rb' do |is|
+                unless entry_created
+                  entry = zip.put_next_entry(path, compression_level)
+                  entry.unix_perms = is.stat.mode & 07777
+                  entry_created = true
+                end
+                if transform
+                  output = StringIO.new
+                  while data = is.read(4096)
+                    output << data
+                  end
+                  to_transform << output.string
+                else
+                  while data = is.read(4096)
+                    zip << data
+                  end
+                end
               end
             end
           end
+          if transform_map.key?(path)
+            zip << transform_map[path].call(to_transform)
+          end
         end
       end
     end
@@ -304,7 +332,7 @@ module Buildr #:nodoc:
           if entry.name =~ /^#{@path}/
             short = entry.name.sub(@path, '')
             if includes.any? { |pat| File.fnmatch(pat, short) } &&
-               !excludes.any? { |pat| File.fnmatch(pat, short) }
+              !excludes.any? { |pat| File.fnmatch(pat, short) }
               map[short] = entry
             end
           end

data/lib/buildr/version.rb

@@ -14,5 +14,5 @@
 # the License.
 
 module Buildr #:nodoc:
-  VERSION = '1.5.3'.freeze
+  VERSION = '1.5.4'.freeze
 end

data/spec/addon/bnd_spec.rb

@@ -55,35 +55,95 @@ package com.biz.bar;
 public class Bar {}
 SRC
 
-        @foo = define "foo" do
-          project.version = "2.1.3"
-          project.group = "mygroup"
-          manifest["Magic-Food"] = "Chocolate"
-          manifest["Magic-Drink"] = "Wine"
+      @foo = define "foo" do
+        project.version = "2.1.3"
+        project.group = "mygroup"
+        manifest["Magic-Food"] = "Chocolate"
+        manifest["Magic-Drink"] = "Wine"
+        package(:bundle).tap do |bnd|
+          bnd["Export-Package"] = "com.*"
+        end
+
+        define "bar" do
+          project.version = "2.2"
           package(:bundle).tap do |bnd|
+            bnd["Magic-Food"] = "Cheese"
             bnd["Export-Package"] = "com.*"
           end
+        end
+      end
+      task('package').invoke
+    end
 
-          define "bar" do
-            project.version = "2.2"
-            package(:bundle).tap do |bnd|
-              bnd["Magic-Food"] = "Cheese"
-              bnd["Export-Package"] = "com.*"
-            end
-          end
+    it "version 0.0.384 does not export the version and wrong import-package" do
+      open_main_manifest_section do |attribs|
+        attribs['Bundle-Name'].should eql('foo')
+        attribs['Bundle-Version'].should eql('2.1.3')
+        attribs['Bundle-SymbolicName'].should eql('mygroup.foo')
+        attribs['Export-Package'].should eql('com.biz')
+        attribs['Import-Package'].should eql('com.biz')
+      end
+    end
+  end
+
+  describe "project.bnd version 2.4.0 (assure forwward compatibility)" do
+    after do
+      STDERR.puts("forward compatibility: used #{Buildr::Bnd.version} restoring #{@savedVersion}")
+      Buildr::Bnd.version = @savedVersion
+    end
+
+    before do
+      @savedVersion = Buildr::Bnd.version
+      Buildr::Bnd.version = '2.4.0'
+      write "src/main/java/com/biz/Foo.java", <<SRC
+package com.biz;
+public class Foo {}
+SRC
+
+      @foo = define "foo" do
+        project.version = "2.1.3"
+        project.group = "mygroup"
+        package(:bundle).tap do |bnd|
+          bnd["Export-Package"] = "com.*"
         end
-        task('package').invoke
       end
+      task('package').invoke
+    end
 
-      it "version 0.0.384 does not export the version and wrong import-package" do
-        open_main_manifest_section do |attribs|
-          attribs['Bundle-Name'].should eql('foo')
-          attribs['Bundle-Version'].should eql('2.1.3')
-          attribs['Bundle-SymbolicName'].should eql('mygroup.foo')
-          attribs['Export-Package'].should eql('com.biz')
-          attribs['Import-Package'].should eql('com.biz')
+    it "produces a .bnd and a .jar in the correct location for root project" do
+      File.should be_exist(@foo._("target/foo-2.1.3.bnd"))
+      File.should be_exist(@foo._("target/foo-2.1.3.jar"))
+    end
+  end
+
+  describe "project.bnd version 3.4.0 (assure forward compatibility)" do
+    after do
+      STDERR.puts("forward compatibility: used #{Buildr::Bnd.version} restoring #{@savedVersion}")
+      Buildr::Bnd.version = @savedVersion
+    end
+
+    before do
+      @savedVersion = Buildr::Bnd.version
+      Buildr::Bnd.version = '3.4.0'
+      write "src/main/java/com/biz/Foo.java", <<SRC
+package com.biz;
+public class Foo {}
+SRC
+
+      @foo = define "foo" do
+        project.version = "2.1.3"
+        project.group = "mygroup"
+        package(:bundle).tap do |bnd|
+          bnd["Export-Package"] = "com.*"
         end
       end
+      task('package').invoke
+    end
+
+    it "produces a .bnd and a .jar in the correct location for root project" do
+      File.should be_exist(@foo._("target/foo-2.1.3.bnd"))
+      File.should be_exist(@foo._("target/foo-2.1.3.jar"))
+    end
   end
 
   describe "package :bundle" do

data/spec/kotlin/compiler_spec.rb

@@ -0,0 +1,274 @@
+# 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 File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helpers'))
+
+# need to test both with and without KOTLIN_HOME
+share_as :KotlincCompiler do
+
+  it 'should identify itself from source directories' do
+    write 'src/main/kotlin/com/example/Test.kt', "package com.example\n class Test { }"
+    define('foo').compile.compiler.should eql(:kotlinc)
+  end
+
+  it 'should report the language as :kotlin' do
+    define('foo').compile.using(:kotlinc).language.should eql(:kotlin)
+  end
+
+  it 'should set the target directory to target/classes' do
+    define 'foo' do
+      lambda { compile.using(:kotlinc) }.should change { compile.target.to_s }.to(File.expand_path('target/classes'))
+    end
+  end
+
+  it 'should not override existing target directory' do
+    define 'foo' do
+      compile.into('classes')
+      lambda { compile.using(:kotlinc) }.should_not change { compile.target }
+    end
+  end
+
+  it 'should not change existing list of sources' do
+    define 'foo' do
+      compile.from('sources')
+      lambda { compile.using(:kotlinc) }.should_not change { compile.sources }
+    end
+  end
+
+  it 'should include as classpath dependency' do
+    write 'src/dependency/Dependency.kt', 'class Dependency {}'
+    define 'dependency', :version=>'1.0' do
+      compile.from('src/dependency').into('target/dependency')
+      package(:jar)
+    end
+    write 'src/test/DependencyTest.kt', "class DependencyTest { val d = Dependency() }"
+    lambda { define('foo').compile.from('src/test').with(project('dependency')).invoke }.should run_task('foo:compile')
+    file('target/classes/DependencyTest.class').should exist
+  end
+
+  def define_test1_project
+    write 'src/main/kotlin/com/example/Test1.kt', "// file name: Test1.kt\npackage com.example\nclass Test1 {}"
+    define 'test1', :version=>'1.0' do
+      package(:jar)
+    end
+  end
+
+  it 'should compile a simple .kt file into a .class file' do
+    define_test1_project
+    task('test1:compile').invoke
+    file('target/classes/com/example/Test1.class').should exist
+  end
+
+  it 'should package .class into a .jar file' do
+    define_test1_project
+    task('test1:package').invoke
+    file('target/test1-1.0.jar').should exist
+    Zip::File.open(project('test1').package(:jar).to_s) do |zip|
+      zip.exist?('com/example/Test1.class').should be_true
+    end
+  end
+
+  it 'should compile kotlin class depending on java class in same project' do
+    write 'src/main/java/com/example/Foo.java', 'package com.example; public class Foo {}'
+    write 'src/main/kotlin/com/example/Bar.kt', "package com.example\n class Bar() : Foo() {}"
+    define 'test1', :version=>'1.0' do
+      package(:jar)
+    end
+    task('test1:package').invoke
+    file('target/test1-1.0.jar').should exist
+    Zip::File.open(project('test1').package(:jar).to_s) do |zip|
+      zip.exist?('com/example/Foo.class').should be_true
+      zip.exist?('com/example/Bar.class').should be_true
+    end
+  end
+
+  it 'should compile java class depending on kotlin class in same project' do
+    write 'src/main/kotlin/com/example/Foo.kt', 'package com.example; open class Foo'
+    write 'src/main/java/com/example/Bar.java',  'package com.example; public class Bar extends Foo {}'
+    define 'test1', :version=>'1.0' do
+      package(:jar)
+    end
+    task('test1:package').invoke
+    file('target/test1-1.0.jar').should exist
+    Zip::File.open(project('test1').package(:jar).to_s) do |zip|
+      zip.exist?('com/example/Foo.class').should be_true
+      zip.exist?('com/example/Bar.class').should be_true
+    end
+  end
+end
+
+share_as :KotlincCompiler_CommonOptions do
+
+  it 'should set warnings option to false by default' do
+    compile_task.options.warnings.should be_false
+  end
+
+  it 'should set warnings option to true when running with --verbose option' do
+    verbose true
+    compile_task.options.warnings.should be_true
+  end
+
+  it 'should use -nowarn argument when warnings is false' do
+    compile_task.using(:warnings=>false)
+    kotlinc_args.suppressWarnings.should be_true
+  end
+
+  it 'should not use -nowarn argument when warnings is true' do
+    compile_task.using(:warnings=>true)
+    kotlinc_args.suppressWarnings.should be_false
+  end
+
+  it 'should not use -verbose argument by default' do
+    oldDebug = Buildr.options.debug
+    Buildr.options.debug = false
+    begin
+      kotlinc_args.verbose.should eql(false)
+    ensure
+      Buildr.options.debug = oldDebug
+    end
+  end
+
+  it 'should use -verbose argument when running with --trace=kotlinc option' do
+    Buildr.application.options.trace_categories = [:kotlinc]
+    kotlinc_args.verbose.should eql(true)
+  end
+
+  it 'should set debug option to true by default' do
+    compile_task.options.debug.should be_true
+  end
+
+  it 'should set debug option to false based on Buildr.options' do
+    Buildr.options.debug = false
+    compile_task.options.debug.should be_false
+  end
+
+  it 'should set debug option to false based on debug environment variable' do
+    ENV['debug'] = 'no'
+    compile_task.options.debug.should be_false
+  end
+
+  it 'should set debug option to false based on DEBUG environment variable' do
+    ENV['DEBUG'] = 'no'
+    compile_task.options.debug.should be_false
+  end
+
+  it 'should set deprecation option to false by default' do
+    compile_task.options.deprecation.should be_false
+  end
+
+  it 'should set optimise option to false by default' do
+    compile_task.options.optimize.should be_false
+  end
+
+  it 'should use -optimise argument when deprecation is true' do
+    compile_task.using(:optimize=>true)
+    kotlinc_args.noOptimize.should be_false
+  end
+
+  it 'should not use -optimise argument when deprecation is false' do
+    compile_task.using(:optimize=>false)
+    kotlinc_args.noOptimize.should be_true
+  end
+  
+  it 'should set noStdlib option to true by default' do
+    compile_task.options.noStdlib.should be_true
+    kotlinc_args.noStdlib.should be_true
+  end
+
+  it 'should not set target option by default' do
+    compile_task.options.target.should be_nil
+    kotlinc_args.jvmTarget.should be_nil
+  end
+
+  it 'should use -target:xxx argument if target option set' do
+    compile_task.using(:target=>'1.5')
+    kotlinc_args.jvmTarget.should eql('1.5')
+  end
+
+  it 'should not set other option by default' do
+    compile_task.options.other.should be_nil
+  end  
+
+  it 'should complain about options it doesn\'t know' do
+    write 'source/Test.kt', 'class Test {}'
+    compile_task.using(:unknown=>'option')
+    lambda { compile_task.from('source').invoke }.should raise_error(ArgumentError, /no such option/i)
+  end
+
+  it 'should inherit options from parent' do
+    define 'foo' do
+      compile.using(:noStdlib=>false, :warnings=>true, :target=>'1.8')
+      define 'bar' do
+        compile.using(:kotlinc)
+        compile.options.noStdlib.should be_false
+        compile.options.warnings.should be_true
+        compile.options.target.should eql('1.8')
+      end
+    end
+  end
+
+  after do
+    Buildr.options.debug = nil
+    ENV.delete "debug"
+    ENV.delete "DEBUG"
+  end
+end
+
+if Java.java.lang.System.getProperty("java.runtime.version") >= "1.8"
+  # Only run this test if the test environment has KOTLIN_HOME specified.
+  # Allows the Test Suite to run on TravisCI
+  if ENV['KOTLIN_HOME']
+    describe 'kotlin compiler (installed in KOTLIN_HOME)' do
+      it 'requires present KOTLIN_HOME' do
+        ENV['KOTLIN_HOME'].should_not be_nil
+      end
+    
+      def compile_task
+        @compile_task ||= define('foo').compile.using(:kotlinc)
+      end
+
+      it_should_behave_like KotlincCompiler
+      it_should_behave_like KotlincCompiler_CommonOptions
+    end
+  end
+
+  describe 'kotlin compiler (downloaded from repository)' do
+    old_home = ENV['KOTLIN_HOME']
+
+    before :all do
+      ENV['KOTLIN_HOME'] = nil
+    end
+
+    it 'requires absent KOTLIN_HOME' do
+      ENV['KOTLIN_HOME'].should be_nil
+    end
+  
+    def compile_task
+      @compile_task ||= define('foo').compile.using(:kotlinc)
+    end
+  
+    def kotlinc_args
+      compile_task.instance_eval { @compiler }.send(:kotlinc_args)
+    end
+
+    it_should_behave_like KotlincCompiler
+    it_should_behave_like KotlincCompiler_CommonOptions
+
+    after :all do
+      ENV['KOTLIN_HOME'] = old_home
+    end
+  end
+end