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

data/lib/buildr/kotlin.rb

@@ -0,0 +1,17 @@
+# 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 'buildr/kotlin/compiler'

data/lib/buildr/kotlin/compiler.rb

@@ -0,0 +1,282 @@
+# 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.
+
+# The Kotlin Module
+module Buildr::Kotlin
+  DEFAULT_VERSION = '1.1.3-2'
+
+  class << self
+
+    def installed_version
+      unless @installed_version
+        @installed_version = if Kotlinc.installed?
+          begin
+            # try to read the value from the build.txt file
+            version_str = File.read(File.expand_path('build.txt', Kotlinc.kotlin_home))
+
+            if version_str
+              md = version_str.match(/\d+\.\d[\d\.]*/) or
+                fail "Unable to parse Kotlin version: #{version_str}"
+
+              md[0].sub(/.$/, "") # remove trailing dot, if any
+            end
+          rescue => e
+            warn "Unable to parse library.properties in $KOTLIN_HOME/build.txt: #{e}"
+            nil
+          end
+        end
+      end
+
+      @installed_version
+    end
+
+    def version
+      Buildr.settings.build['kotlin.version'] || installed_version || DEFAULT_VERSION
+    end
+
+    # check if version matches any of the given prefixes
+    def version?(*v)
+      v.any? { |v| version.index(v.to_s) == 0 }
+    end
+
+  end
+
+  # Kotlin compiler:
+  #   compile.using(:kotlin)
+  # Used by default if .kt files are found in the src/main/kotlin directory (or src/test/kotlin)
+  # and sets the target directory to target/classes (or target/test/classes).
+  # Accepts the following options:
+  # * :warnings    -- Issue warnings when compiling.  True when running in verbose mode.
+  # * :debug       -- Generates bytecode with debugging information.  Set from the debug
+  # environment variable/global option.
+  # * :optimize    -- Optimize the byte code generation. False by default.
+  # * :target      -- Bytecode compatibility.
+  # * :noStdlib    -- Include the Kotlin runtime. False by default.
+  # * :javac       -- Arguments for javac compiler.
+  class Kotlinc < Buildr::Compiler::Base
+
+    class << self
+      def kotlin_home
+        env_home = ENV['KOTLIN_HOME']
+
+        @home ||= if !env_home.nil? && File.exists?(env_home + '/lib/kotlin-compiler.jar')
+          env_home
+        else
+          nil
+        end
+      end
+
+      def installed?
+        !kotlin_home.nil?
+      end
+
+      def use_installed?
+        if installed? && Buildr.settings.build['kotlin.version']
+          Buildr.settings.build['kotlin.version'] == Kotlin.installed_version
+        else
+          Buildr.settings.build['kotlin.version'].nil? && installed?
+        end
+      end
+
+      def dependencies
+        kotlin_dependencies = if use_installed?
+          %w(kotlin-stdlib kotlin-compiler).map { |s| File.expand_path("lib/#{s}.jar", kotlin_home) }
+        else
+          REQUIRES.artifacts.map(&:to_s)
+        end
+        # Add Java utilities (eg KotlinMessageCollector)
+        kotlin_dependencies |= [ File.join(File.dirname(__FILE__)) ]
+        (kotlin_dependencies).compact
+      end
+
+      def applies_to?(project, task) #:nodoc:
+        paths = task.sources + [sources].flatten.map { |src| Array(project.path_to(:source, task.usage, src.to_sym)) }
+        paths.flatten!
+
+        # Just select if we find .kt files
+        paths.any? { |path| !Dir["#{path}/**/*.kt"].empty? }
+      end
+    end
+
+    # The kotlin compiler jars are added to classpath at load time,
+    # if you want to customize artifact versions, you must set them on the
+    #
+    #      artifact_ns['Buildr::Compiler::Kotlinc'].library = '1.1.3-2'
+    #
+    # namespace before this file is required.  This is of course, only
+    # if KOTLIN_HOME is not set or invalid.
+    REQUIRES = ArtifactNamespace.for(self) do |ns|
+      version = Buildr.settings.build['kotlin.version'] || DEFAULT_VERSION
+      ns.compiler!     'org.jetbrains.kotlin:kotlin-compiler:jar:>=' + version
+    end
+
+    Javac = Buildr::Compiler::Javac
+
+    OPTIONS = [:warnings, :optimize, :target, :debug, :noStdlib, :javac]
+
+    # Lazy evaluation to allow change in buildfile
+    Java.classpath << lambda { dependencies }
+
+    specify :language=>:kotlin, :sources => [:kotlin, :java], :source_ext => [:kt, :java],
+            :target=>'classes', :target_ext=>'class', :packaging=>:jar
+
+    def initialize(project, options) #:nodoc:
+      super
+      # use common options also for javac
+
+      options[:javac] ||= Buildr::Compiler::Javac::OPTIONS.inject({}) do |hash, option|
+        hash[option] = options[option]
+        hash
+      end
+      
+      options[:debug] = Buildr.options.debug || trace?(:kotlinc) if options[:debug].nil?
+      options[:warnings] = verbose if options[:warnings].nil?
+      options[:optimize] = false if options[:optimize].nil?
+      options[:noStdlib] = true if options[:noStdlib].nil?
+      @java = Javac.new(project, options[:javac])
+    end
+    
+    
+
+    def compile(sources, target, dependencies) #:nodoc:
+      check_options(options, OPTIONS)
+
+      java_sources = java_sources(sources)
+
+      unless Buildr.application.options.dryrun
+        messageCollector = Java.org.apache.buildr.KotlinMessageCollector.new
+
+        Java.load
+        begin
+          compiler = Java.org.jetbrains.kotlin.cli.jvm.K2JVMCompiler.new
+          compilerArguments = kotlinc_args
+          compilerArguments.destination = File.expand_path(target)
+          compilerArguments.classpath = dependencies.join(File::PATH_SEPARATOR)
+          sources.each do |source|
+            compilerArguments.freeArgs.add(File.expand_path(source))
+          end
+          services = Buildr::Util.java_platform? ? Java.org.jetbrains.kotlin.config.Services::EMPTY : Java.org.jetbrains.kotlin.config.Services.EMPTY
+          compiler.exec(messageCollector, services, compilerArguments)
+        rescue => e
+          fail "Kotlin compiler crashed:\n#{e.inspect}"
+        end
+
+        unless java_sources.empty?
+          trace 'Compiling mixed Java/Kotlin sources'
+
+          deps = dependencies + Kotlinc.dependencies + [ File.expand_path(target) ]
+          @java.compile(java_sources, target, deps)
+        end
+      end
+    end
+
+  protected
+
+    # :nodoc: see Compiler:Base
+    def compile_map(sources, target)
+      target_ext = self.class.target_ext
+      ext_glob = Array(self.class.source_ext).join(',')
+      sources.flatten.map{|f| File.expand_path(f)}.inject({}) do |map, source|
+        sources = if File.directory?(source)
+          FileList["#{source}/**/*.{#{ext_glob}}"].reject { |file| File.directory?(file) }
+        else
+          [source]
+        end
+
+        sources.each do |source|
+          # try to extract package name from .java or .kt files
+          if %w(.java .kt).include? File.extname(source)
+            name = File.basename(source).split(".")[0]
+            package = findFirst(source, /^\s*package\s+([^\s;]+)\s*;?\s*/)
+            packages = count(source, /^\s*package\s+([^\s;]+)\s*;?\s*/)
+            found = findFirst(source, /((class)|(object))\s+(#{name})Kt/)
+
+            # if there's only one package statement and we know the target name, then we can depend
+            # directly on a specific file, otherwise, we depend on the general target
+            if (found && packages == 1)
+              map[source] = package ? File.join(target, package[1].gsub('.', '/'), name.ext(target_ext)) : target
+            else
+              map[source] = target
+            end
+
+          elsif
+            map[source] = target
+          end
+        end
+
+        map.each do |key,value|
+          map[key] = first_file unless map[key]
+        end
+
+        map
+      end
+    end
+
+  private
+
+    def count(file, pattern)
+      count = 0
+      File.open(file, 'r') do |infile|
+        while (line = infile.gets)
+          count += 1 if line.match(pattern)
+        end
+      end
+      count
+    end
+
+    def java_sources(sources)
+      sources.flatten.map { |source| File.directory?(source) ? FileList["#{source}/**/*.java"] : source } .
+        flatten.reject { |file| File.directory?(file) || File.extname(file) != '.java' }.map { |file| File.expand_path(file) }.uniq
+    end
+
+    # Returns Kotlinc arguments from the set of options.
+    def kotlinc_args #:nodoc:
+      compilerArguments = Java.org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments.new
+      compilerArguments.verbose = options[:debug]
+      compilerArguments.suppressWarnings = !options[:warnings]
+      compilerArguments.noStdlib = options[:noStdlib]
+      compilerArguments.noOptimize = !options[:optimize]
+      compilerArguments.reportOutputFiles = compilerArguments.verbose
+      compilerArguments.jvmTarget = options[:target] unless options[:target].nil?
+      compilerArguments
+    end
+  end
+
+  module ProjectExtension
+    def kotlinc_options
+      @kotlinc ||= KotlincOptions.new(self)
+    end
+  end
+
+  class KotlincOptions
+    attr_writer :incremental
+
+    def initialize(project)
+      @project = project
+    end
+
+    def incremental
+      @incremental || (@project.parent ? @project.parent.kotlinc_options.incremental : nil)
+    end
+  end
+end
+
+# Kotlin compiler comes first, ahead of Javac, this allows it to pick
+# projects that mix Kotlin and Java code by spotting Kotlin code first.
+Buildr::Compiler.compilers.unshift Buildr::Kotlin::Kotlinc
+
+class Buildr::Project #:nodoc:
+  include Buildr::Kotlin::ProjectExtension
+end

data/lib/buildr/kotlin/org/apache/buildr/KotlinMessageCollector.java

@@ -0,0 +1,46 @@
+/* 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.
+ */
+
+
+package org.apache.buildr;
+
+import org.jetbrains.kotlin.cli.common.messages.MessageCollector;
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity;
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation;
+
+
+public class KotlinMessageCollector implements MessageCollector {
+    
+    public void report(CompilerMessageSeverity severity, String message, CompilerMessageLocation location) {
+        switch(severity) {
+            case ERROR:
+            case EXCEPTION:
+                System.err.println((location != null ? (location.toString() + " ") : "") + message);
+                break;
+            default:
+                System.out.println((location != null ? (location.toString() + " ") : "") + message);
+                break;
+        }
+    }
+    
+    public boolean hasErrors() {
+        return false;
+    }
+    
+    public void clear() {
+        // not implemented
+    }
+}

data/lib/buildr/packaging/archive.rb

@@ -112,9 +112,9 @@ module Buildr #:nodoc:
         expanders = files.collect do |file|
           @sources << proc { file.to_s }
           expander = ZipExpander.new(file)
-          @actions << proc do |file_map|
+          @actions << proc do |file_map, transform_map|
             file.invoke() if file.is_a?(Rake::Task)
-            expander.expand(file_map, path)
+            expander.expand(file_map, transform_map, path)
           end
           expander
         end
@@ -133,8 +133,8 @@ module Buildr #:nodoc:
         @sources.map{ |source| source.call }.flatten
       end
 
-      def add_files(file_map) #:nodoc:
-        @actions.each { |action| action.call(file_map) }
+      def add_files(file_map, transform_map) #:nodoc:
+        @actions.each { |action| action.call(file_map, transform_map) }
       end
 
       # :call-seq:
@@ -267,6 +267,16 @@ module Buildr #:nodoc:
         @expanders.each { |expander| expander.exclude(*files) }
         self
       end
+      
+      def concatenate(*files)
+        @expanders.each { |expander| expander.concatenate(*files) }
+        self
+      end
+      
+      def transform(*files, &block)
+        @expanders.each { |expander| expander.transform(*files, &block) }
+        self
+      end
     end
 
 
@@ -277,6 +287,8 @@ module Buildr #:nodoc:
         @zip_file = zip_file.to_s
         @includes = []
         @excludes = []
+        @concatenates = []
+        @transforms = {}
       end
 
       def include(*files)
@@ -289,8 +301,18 @@ module Buildr #:nodoc:
         @excludes |= files
         self
       end
+      
+      def concatenate(*files)
+        @concatenates |= files
+        self
+      end
+      
+      def transform(*files, &block)
+        @transforms[[files].flatten] = block
+        self
+      end
 
-      def expand(file_map, path)
+      def expand(file_map, transform_map, path)
         @includes = ['*'] if @includes.empty?
         Zip::File.open(@zip_file) do |source|
           source.entries.reject { |entry| entry.directory? }.each do |entry|
@@ -298,7 +320,19 @@ module Buildr #:nodoc:
                !@excludes.any? { |pattern| File.fnmatch(pattern, entry.name) }
               dest = path =~ /^\/?$/ ? entry.name : Util.relative_path(path + "/" + entry.name)
               trace "Adding #{dest}"
-              file_map[dest] = ZipEntryData.new(source, entry)
+              if @concatenates.any? { |pattern| File.fnmatch(pattern, entry.name) }
+                file_map[dest] << ZipEntryData.new(source, entry)
+              elsif @transforms.each_pair.detect do |transform, transform_block|\
+                  if transform.any? { |pattern| File.fnmatch(pattern, entry.name) }
+                    file_map[dest] << ZipEntryData.new(source, entry)
+                    
+                    transform_map[dest] = transform_block
+                    true
+                  end
+                end
+              else
+                file_map[dest] = ZipEntryData.new(source, entry)
+              end
             end
           end
         end
@@ -327,7 +361,8 @@ module Buildr #:nodoc:
 
       # Make sure we're the last enhancements, so other enhancements can add content.
       enhance do
-        @file_map = {}
+        @file_map = Hash.new {|h,k| h[k]=[]}
+        @transform_map = {}
         enhance do
           send 'create' if respond_to?(:create)
           # We're here because the archive file does not exist, or one of the files is newer than the archive contents;
@@ -338,9 +373,9 @@ module Buildr #:nodoc:
           begin
             @paths.each do |name, object|
               @file_map[name] = nil unless name.empty?
-              object.add_files(@file_map)
+              object.add_files(@file_map, @transform_map)
             end
-            create_from @file_map
+            create_from @file_map, @transform_map
           rescue
             rm name rescue nil
             raise
@@ -485,9 +520,10 @@ module Buildr #:nodoc:
       @prepares.each { |prepare| prepare.call(self) }
       @prepares.clear
 
-      file_map = {}
+      file_map = Hash.new {|h,k| h[k]=[]}
+      transform_map = {}
       @paths.each do |name, path|
-        path.add_files(file_map)
+        path.add_files(file_map, transform_map)
       end
 
       # filter out Procs (dynamic content), nils and others