mguymon-buildr 1.4.5-java

data/lib/buildr/resources/icons-license.txt

@@ -0,0 +1,17 @@
+
+MouseRunner.com Green/Red icons
+-------------------------------
+
+The graphics contained in the 'completed.png' and 'failed.png' files are
+licensed under the Creative Commons Attribution-ShareAlike 2.5 License
+
+Furthermore,
+You may not claim the works as your own.
+You must provide a link back to www.MouseRunner.com when using on a website,
+for commercial purposes, and for applications.
+
+Visit the address below to learn more about the Creative Commons license.
+http://creativecommons.org/licenses/by-nc-sa/2.5/legalcode
+
+
+

data/lib/buildr/run.rb

@@ -0,0 +1,195 @@
+# 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
+  module Run
+    include Extension
+
+    class << self
+      def runners
+        @runners ||= []
+      end
+
+      def select_by_lang(lang)
+        fail 'Unable to define run task for nil language' if lang.nil?
+        runners.detect { |e| e.languages.nil? ? false : e.languages.include?(lang.to_sym) }
+      end
+
+      alias_method :select, :select_by_lang
+
+      def select_by_name(name)
+        fail 'Unable to define run task for nil' if name.nil?
+        runners.detect { |e| e.to_sym == name.to_sym }
+      end
+
+    end
+
+    # Base class for any run provider.  Defines most
+    # common functionality (things like @lang@, @build?@ and friends).
+    class Base
+      attr_reader :project
+
+      class << self
+        attr_accessor :runner_name, :languages
+
+        def specify(options)
+          @runner_name ||= options[:name]
+          @languages ||= options[:languages]
+        end
+
+        def to_sym
+          @runner_name || name.split('::').last.downcase.to_sym
+        end
+      end
+
+      def initialize(project)
+        @project = project
+      end
+
+      def build?
+        true
+      end
+
+      def launch
+        fail 'Not implemented'
+      end
+    end
+
+    class RunTask < Rake::Task
+      # Classpath dependencies.
+      attr_accessor :classpath
+
+      # Returns the run options.
+      attr_reader :options
+
+      # Returns file dependencies
+      attr_reader :files
+
+      attr_reader :project # :nodoc:
+
+      def initialize(*args) # :nodoc:
+        super
+        @options = {}
+        @classpath = []
+        @files = FileList[]
+      end
+
+      # :call-seq:
+      #   with(*artifacts) => self
+      #
+      # Adds files and artifacts as classpath dependencies, and returns self.
+      def with(*specs)
+        @classpath |= Buildr.artifacts(specs.flatten).uniq
+        self
+      end
+
+      # :call-seq:
+      #   using(options) => self
+      #
+      # Sets the run options from a hash and returns self.
+      #
+      # For example:
+      #   run.using :main=>'org.example.Main'
+      def using(*args)
+        args.pop.each { |key, value| @options[key.to_sym] = value } if Hash === args.last
+
+        until args.empty?
+          new_runner = Run.select_by_name(args.pop)
+          @runner = new_runner.new(project) unless new_runner.nil?
+        end
+
+        self
+      end
+
+      # :call-seq:
+      #   requires(*files) => self
+      #
+      # Adds additional files and directories as dependencies to the task and returns self.
+      # When specifying a directory, includes all files in that directory.
+      def requires(*files)
+        @files.include *files.flatten.compact
+        self
+      end
+
+      def runner
+        @runner ||= guess_runner
+      end
+
+      def runner?
+        @runner ||= begin
+          guess_runner if project.compile.language
+        rescue
+          nil
+        end
+      end
+
+      def run
+        runner.run(self) if runner?
+      end
+
+      def prerequisites #:nodoc:
+        super + @files + classpath
+      end
+
+    private
+
+      def guess_runner
+        runner = Run.select project.compile.language
+        fail 'Unable to guess runner for project.' unless runner
+        runner.new project
+      end
+
+      def associate_with(project)
+        @project ||= project
+      end
+    end
+
+    first_time do
+      Project.local_task 'run'
+    end
+
+    before_define(:run => :test) do |project|
+      RunTask.define_task('run').tap do |run|
+        run.send(:associate_with, project)
+        run.enhance([project.compile, project.test]) do |t|
+          # double-enhance to execute the runner last
+          run.enhance { |t| t.run }
+        end
+      end
+    end
+
+    after_define(:run => :test) do |project|
+      project.run.with project.test.compile.dependencies
+      project.run.with project.test.compile.target if project.test.compile.target
+    end
+
+    # :call-seq:
+    #   run(&block) => RunTask
+    #
+    # This method returns the project's run task. It also accepts a block to be executed
+    # when the run task is invoked.
+    def run(&block)
+      task('run').tap do |t|
+        t.enhance &block if block
+      end
+    end
+
+  end
+
+  class Project
+    include Run
+  end
+end

data/lib/buildr/scala.rb

@@ -0,0 +1,26 @@
+# 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.
+
+
+ENV['SCALA_HOME'] ||= '/opt/local/share/scala/' if File.exist?('/opt/local/share/scala/lib/scala-compiler.jar')
+Buildr.repositories.remote << 'http://scala-tools.org/repo-releases'
+
+require 'buildr/scala/compiler'
+require 'buildr/scala/tests'
+require 'buildr/scala/bdd'
+require 'buildr/scala/doc'
+require 'buildr/scala/shell'
+
+Object::Scala = Buildr::Scala

data/lib/buildr/scala/bdd.rb

@@ -0,0 +1,118 @@
+# 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/core/build'
+require 'buildr/core/compile'
+require 'buildr/java/bdd'
+require 'buildr/scala/tests'
+
+module Buildr::Scala
+
+  # Specs is a Scala based BDD framework.
+  # To use in your project:
+  #
+  #   test.using :specs
+  #
+  # This framework will search in your project for:
+  #   src/spec/scala/**/*.scala
+  class Specs < Buildr::TestFramework::JavaBDD
+    @lang = :scala
+    @bdd_dir = :spec
+
+    VERSION = '1.6.6'
+
+    class << self
+      def version
+        Buildr.settings.build['scala.specs'] || VERSION
+      end
+
+      def artifact
+        Buildr.settings.build['scala.specs.artifact'] || "specs_#{Buildr::Scala.version}"
+      end
+
+      def dependencies
+        unless @dependencies
+          super
+          specs = (version =~ /:/) ? [version] : ["org.scala-tools.testing:#{artifact}:jar:#{version}"]
+          # Add utility classes (e.g. SpecsSingletonRunner) and other dependencies
+          @dependencies |= [ File.join(File.dirname(__FILE__)) ] + specs +
+                           Check.dependencies + JUnit.dependencies + Scalac.dependencies
+        end
+        @dependencies
+      end
+
+      def applies_to?(project)  #:nodoc:
+        !Dir[project.path_to(:source, bdd_dir, lang, '**/*.scala')].empty?
+      end
+
+    private
+      def const_missing(const)
+        return super unless const == :REQUIRES # TODO: remove in 1.5
+        Buildr.application.deprecated "Please use Scala::Specs.dependencies/.version instead of ScalaSpecs::REQUIRES/VERSION"
+        dependencies
+      end
+    end
+
+    def initialize(task, options) #:nodoc:
+      super
+
+      specs = task.project.path_to(:source, :spec, :scala)
+      task.compile.from specs if File.directory?(specs)
+
+      resources = task.project.path_to(:source, :spec, :resources)
+      task.resources.from resources if File.directory?(resources)
+    end
+
+    def tests(dependencies)
+      candidates = filter_classes(dependencies, :interfaces => ['org.specs.Specification'])
+
+      Java.load   # Java is already loaded, but just in case
+
+      filter = Java.org.apache.buildr.JavaTestFilter.new(dependencies.to_java(Java.java.lang.String))
+      filter.add_fields ['MODULE$'].to_java(Java.java.lang.String)
+      filter.filter(candidates.to_java(Java.java.lang.String)).map { |s| s[0..(s.size - 2)] }
+    end
+
+    def run(specs, dependencies)  #:nodoc:
+      cmd_options = { :properties => options[:properties],
+                      :java_args => options[:java_args],
+                      :classpath => dependencies,
+                      :name => false }
+
+      runner = 'org.apache.buildr.SpecsSingletonRunner'
+      specs.inject [] do |passed, spec|
+        begin
+          unless Util.win_os?
+            Java::Commands.java(runner, task.compile.target.to_s, '-c', spec + '$', cmd_options)
+          else
+            Java::Commands.java(runner, task.compile.target.to_s, spec + '$', cmd_options)
+          end
+        rescue => e
+          passed
+        else
+          passed << spec
+        end
+      end
+    end
+  end
+end
+
+# Backwards compatibility stuff.  Remove in 1.5.
+module Buildr
+  ScalaSpecs = Scala::Specs
+end
+
+Buildr::TestFramework << Buildr::Scala::Specs

data/lib/buildr/scala/compiler.rb

@@ -0,0 +1,242 @@
+# 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/core/project'
+require 'buildr/core/common'
+require 'buildr/core/compile'
+require 'buildr/packaging'
+
+module Buildr::Scala
+  DEFAULT_VERSION = '2.8.1'
+
+  class << self
+
+    def version_str
+      warn "Use of Scala.version_str is deprecated.  Use Scala.version instead"
+      version
+    end
+
+    def installed_version
+      unless @installed_version
+        @installed_version = if Scalac.installed?
+          begin
+            # try to read the value from the properties file
+            props = Zip::ZipFile.open(File.expand_path('lib/scala-library.jar', Scalac.scala_home)) do |zipfile|
+              zipfile.read 'library.properties'
+            end
+
+            version_str = props.match(/version\.number\s*=\s*([^\s]+)/).to_a[1]
+
+            if version_str
+              md = version_str.match(/\d+\.\d[\d\.]*/) or
+                fail "Unable to parse Scala version: #{version_str}"
+
+              md[0].sub(/.$/, "") # remove trailing dot, if any
+            end
+          rescue => e
+            warn "Unable to parse library.properties in $SCALA_HOME/lib/scala-library.jar: #{e}"
+            nil
+          end
+        end
+      end
+
+      @installed_version
+    end
+
+    def version
+      Buildr.settings.build['scala.version'] || installed_version || DEFAULT_VERSION
+    end
+
+    def compatible_28?
+      major, minor = version.match(/^(\d)\.(\d)/).to_a[1,2]
+      if major && minor
+        (major.to_i == 2 && minor.to_i >= 8) || (major.to_i > 2)
+      else
+        false
+      end
+    end
+  end
+
+  # Scalac compiler:
+  #   compile.using(:scalac)
+  # Used by default if .scala files are found in the src/main/scala directory (or src/test/scala)
+  # and sets the target directory to target/classes (or target/test/classes).
+  #
+  # Accepts the following options:
+  # * :warnings    -- Generate warnings if true (opposite of -nowarn).
+  # * :deprecation -- Output source locations where deprecated APIs are used.
+  # * :optimise    -- Generates faster bytecode by applying optimisations to the program.
+  # * :target      -- Class file compatibility with specified release.
+  # * :debug       -- Generate debugging info.
+  # * :other       -- Array of options to pass to the Scalac compiler as is, e.g. -Xprint-types
+  class Scalac < Buildr::Compiler::Base
+
+    # The scalac 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::Scalac'].library = '2.7.5'
+    #
+    # namespace before this file is required.  This is of course, only
+    # if SCALA_HOME is not set or invalid.
+    REQUIRES = ArtifactNamespace.for(self) do |ns|
+      version = Buildr.settings.build['scala.version'] || DEFAULT_VERSION
+      ns.library!      'org.scala-lang:scala-library:jar:>=' + version
+      ns.compiler!     'org.scala-lang:scala-compiler:jar:>=' + version
+    end
+
+    class << self
+      def scala_home
+        env_home = ENV['SCALA_HOME']
+
+        @home ||= (if !env_home.nil? && File.exists?(env_home + '/lib/scala-library.jar') && File.exists?(env_home + '/lib/scala-compiler.jar')
+          env_home
+        else
+          nil
+        end)
+      end
+
+      def installed?
+        !scala_home.nil?
+      end
+
+      def use_installed?
+        if installed? && Buildr.settings.build['scala.version']
+          Buildr.settings.build['scala.version'] == Scala.installed_version
+        else
+          Buildr.settings.build['scala.version'].nil? && installed?
+        end
+      end
+
+      def dependencies
+        if use_installed?
+          ['scala-library', 'scala-compiler'].map { |s| File.expand_path("lib/#{s}.jar", scala_home) }
+        else
+          REQUIRES.artifacts.map(&:to_s)
+        end
+      end
+
+      def use_fsc
+        use_installed? && ENV["USE_FSC"] =~ /^(yes|on|true)$/i
+      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 .scala files
+        paths.any? { |path| !Dir["#{path}/**/*.scala"].empty? }
+      end
+    end
+
+    Javac = Buildr::Compiler::Javac
+
+    OPTIONS = [:warnings, :deprecation, :optimise, :target, :debug, :other, :javac]
+
+    # Lazy evaluation to allow change in buildfile
+    Java.classpath << lambda { dependencies }
+
+    specify :language=>:scala, :sources => [:scala, :java], :source_ext => [:scala, :java],
+            :target=>'classes', :target_ext=>'class', :packaging=>:jar
+
+    def initialize(project, options) #:nodoc:
+      super
+      options[:debug] = Buildr.options.debug if options[:debug].nil?
+      options[:warnings] = verbose if options[:warnings].nil?
+      options[:deprecation] ||= false
+      options[:optimise] ||= false
+      options[:make] ||= :transitivenocp if Scala.compatible_28?
+      options[:javac] ||= {}
+
+      @java = Javac.new(project, options[:javac])
+    end
+
+    def compile(sources, target, dependencies) #:nodoc:
+      check_options(options, OPTIONS + (Scala.compatible_28? ? [:make] : []))
+
+      java_sources = java_sources(sources)
+      enable_dep_tracing = Scala.compatible_28? && java_sources.empty?
+
+      dependencies.unshift target if enable_dep_tracing
+
+      cmd_args = []
+      cmd_args << '-classpath' << dependencies.join(File::PATH_SEPARATOR)
+      source_paths = sources.select { |source| File.directory?(source) }
+      cmd_args << '-sourcepath' << source_paths.join(File::PATH_SEPARATOR) unless source_paths.empty?
+      cmd_args << '-d' << File.expand_path(target)
+      cmd_args += scalac_args
+
+      if enable_dep_tracing
+        dep_dir = File.expand_path(target)
+        Dir.mkdir dep_dir unless File.exists? dep_dir
+
+        cmd_args << '-make:' + options[:make].to_s
+        cmd_args << '-dependencyfile'
+        cmd_args << File.expand_path('.scala-deps', dep_dir)
+      end
+
+      cmd_args += files_from_sources(sources)
+
+      unless Buildr.application.options.dryrun
+        trace((['scalac'] + cmd_args).join(' '))
+
+        if Scalac.use_fsc
+          system(([File.expand_path('bin/fsc', Scalac.scala_home)] + cmd_args).join(' ')) or
+            fail 'Failed to compile, see errors above'
+        else
+          Java.load
+          begin
+            Java.scala.tools.nsc.Main.process(cmd_args.to_java(Java.java.lang.String))
+          rescue => e
+            fail "Scala compiler crashed:\n#{e.inspect}"
+          end
+          fail 'Failed to compile, see errors above' if Java.scala.tools.nsc.Main.reporter.hasErrors
+        end
+
+        unless java_sources.empty?
+          trace 'Compiling mixed Java/Scala sources'
+
+          # TODO  includes scala-compiler.jar
+          deps = dependencies + Scalac.dependencies + [ File.expand_path(target) ]
+          @java.compile(java_sources, target, deps)
+        end
+      end
+    end
+
+  private
+
+    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 Scalac command line arguments from the set of options.
+    def scalac_args #:nodoc:
+      args = []
+      args << "-nowarn" unless options[:warnings]
+      args << "-verbose" if trace?(:scalac)
+      args << "-g" if options[:debug]
+      args << "-deprecation" if options[:deprecation]
+      args << "-optimise" if options[:optimise]
+      args << "-target:jvm-" + options[:target].to_s if options[:target]
+      args + Array(options[:other])
+    end
+
+  end
+
+end
+
+# Scala compiler comes first, ahead of Javac, this allows it to pick
+# projects that mix Scala and Java code by spotting Scala code first.
+Buildr::Compiler.compilers.unshift Buildr::Scala::Scalac