buildr 1.3.2-java → 1.3.3-java

data/lib/buildr/groovy.rb

@@ -0,0 +1,18 @@
+# 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/groovy/compiler'
+require 'buildr/groovy/bdd'

data/lib/buildr/groovy/bdd.rb

@@ -0,0 +1,105 @@
+# 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::Groovy
+
+  # EasyB is a Groovy based BDD framework.
+  # To use in your project:
+  #
+  #   test.using :easyb
+  # 
+  # This framework will search in your project for:
+  #   src/spec/groovy/**/*Story.groovy
+  #   src/spec/groovy/**/*Behavior.groovy
+  #
+  # Support the following options:
+  # * :format -- Report format :txt or :xml, default is :txt
+  # * :properties -- Hash of properties passed to the test suite.
+  # * :java_args -- Arguments passed to the JVM.
+  class EasyB < TestFramework::JavaBDD
+    @lang = :groovy
+    @bdd_dir = :spec
+
+    VERSION = "0.7"
+    TESTS_PATTERN = [ /(Story|Behavior).groovy$/ ]
+    OPTIONS = [:format, :properties, :java_args]
+
+    class << self
+      def version
+        Buildr.settings.build['jbehave'] || VERSION
+      end
+
+      def dependencies
+        @dependencies ||= ["org.easyb:easyb:jar:#{version}",
+          'org.codehaus.groovy:groovy:jar:1.5.3','asm:asm:jar:2.2.3',
+          'commons-cli:commons-cli:jar:1.0','antlr:antlr:jar:2.7.7']
+      end
+
+      def applies_to?(project) #:nodoc:
+        %w{
+          **/*Behaviour.groovy **/*Behavior.groovy **/*Story.groovy
+        }.any? { |glob| !Dir[project.path_to(:source, bdd_dir, lang, glob)].empty? }
+      end
+
+    private
+      def const_missing(const)
+        return super unless const == :REQUIRES # TODO: remove in 1.5
+        Buildr.application.deprecated "Please use JBehave.dependencies/.version instead of JBehave::REQUIRES/VERSION"
+        dependencies
+      end
+    end
+
+    def tests(dependencies) #:nodoc:
+      Dir[task.project.path_to(:source, bdd_dir, lang, "**/*.groovy")].
+        select { |name| TESTS_PATTERN.any? { |pat| pat === name } }
+    end
+
+    def run(tests, dependencies) #:nodoc:
+      options = { :format => :txt }.merge(self.options).only(*OPTIONS)
+    
+      if :txt == options[:format]
+        easyb_format, ext = 'txtstory', '.txt'
+      elsif :xml == options[:format]
+        easyb_format, ext = 'xmlbehavior', '.xml'
+      else
+        raise "Invalid format #{options[:format]} expected one of :txt :xml"
+      end
+    
+      cmd_args = [ 'org.disco.easyb.SpecificationRunner' ]
+      cmd_options = { :properties => options[:properties],
+                      :java_args => options[:java_args],
+                      :classpath => dependencies }
+
+      tests.inject([]) do |passed, test|
+        name = test.sub(/.*?groovy[\/\\]/, '').pathmap('%X')
+        report = File.join(task.report_to.to_s, name + ext)
+        mkpath report.pathmap('%d'), :verbose => false
+        begin
+          Java::Commands.java cmd_args,
+             "-#{easyb_format}", report,
+             test, cmd_options.merge(:name => name)
+        rescue => e
+          passed
+        else
+          passed << test
+        end
+      end
+    end
+  
+  end # EasyB
+  
+end
+
+Buildr::TestFramework << Buildr::Groovy::EasyB

data/lib/buildr/groovy/compiler.rb

@@ -0,0 +1,138 @@
+# 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::Groovy
+
+  # Groovyc compiler:
+  #  compile.using(:groovyc)
+  #
+  # You need to require 'buildr/java/groovyc' if you need to use this compiler.
+  #
+  # Used by default if .groovy files are found in the src/main/groovy directory (or src/test/groovy)
+  # and sets the target directory to target/classes (or target/test/classes).
+  #
+  # Groovyc is a joint compiler, this means that when selected for a project, this compiler is used
+  # to compile both groovy and java sources. It's recommended that Groovy sources are placed in the
+  # src/main/groovy directory, even though this compiler also looks in src/main/java
+  #
+  # Groovyc accepts the following options:
+  #
+  # * :encoding          -- Encoding of source files
+  # * :verbose           -- Asks the compiler for verbose output, true when running in verbose mode.
+  # * :fork              -- Whether to execute groovyc using a spawned instance of the JVM; defaults to no
+  # * :memoryInitialSize -- The initial size of the memory for the underlying VM, if using fork mode; ignored otherwise. 
+  #                                     Defaults to the standard VM memory setting. (Examples: 83886080, 81920k, or 80m)
+  # * :memoryMaximumSize -- The maximum size of the memory for the underlying VM, if using fork mode; ignored otherwise. 
+  #                                     Defaults to the standard VM memory setting. (Examples: 83886080, 81920k, or 80m)
+  # * :listfiles         -- Indicates whether the source files to be compiled will be listed; defaults to no
+  # * :stacktrace        -- If true each compile error message will contain a stacktrace
+  # * :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.
+  # * :deprecation       -- If true, shows deprecation messages.  False by default.
+  # * :optimise          -- Generates faster bytecode by applying optimisations to the program.
+  # * :source            -- Source code compatibility.
+  # * :target            -- Bytecode compatibility.
+  # * :javac             -- Hash of options passed to the ant javac task
+  #
+  class Groovyc < Compiler::Base
+    
+    # The groovyc 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::Groovyc'].groovy = '1.5.4'
+    #
+    # namespace before this file is required.
+    REQUIRES = ArtifactNamespace.for(self) do |ns|
+      ns.groovy!       'org.codehaus.groovy:groovy:jar:>=1.5.3'
+      ns.commons_cli!  'commons-cli:commons-cli:jar:>=1.0'
+      ns.asm!          'asm:asm:jar:>=2.2'
+      ns.antlr!        'antlr:antlr:jar:>=2.7.7'
+    end
+    
+    ANT_TASK = 'org.codehaus.groovy.ant.Groovyc'
+    GROOVYC_OPTIONS = [:encoding, :verbose, :fork, :memoryInitialSize, :memoryMaximumSize, :listfiles, :stacktrace]
+    JAVAC_OPTIONS = [:optimise, :warnings, :debug, :deprecation, :source, :target, :javac]
+    OPTIONS = GROOVYC_OPTIONS + JAVAC_OPTIONS
+
+    class << self
+      def dependencies #:nodoc:
+        REQUIRES.artifacts
+      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 .groovy files
+        paths.any? { |path| !Dir["#{path}/**/*.groovy"].empty? }
+      end
+    end
+    
+    Java.classpath << dependencies
+    
+    specify :language => :groovy, :sources => [:groovy, :java], :source_ext => [:groovy, :java], 
+            :target => 'classes', :target_ext => 'class', :packaging => :jar
+
+    def initialize(project, options) #:nodoc:
+      super
+      options[:debug] = Buildr.options.debug if options[:debug].nil?
+      options[:deprecation] ||= false
+      options[:optimise] ||= false
+      options[:verbose] ||= Buildr.application.options.trace if options[:verbose].nil?
+      options[:warnings] = verbose if options[:warnings].nil?
+      options[:javac] = OpenObject.new if options[:javac].nil?
+    end
+
+    # http://groovy.codehaus.org/The+groovyc+Ant+Task
+    def compile(sources, target, dependencies) #:nodoc:
+      return if Buildr.application.options.dryrun
+      Buildr.ant 'groovyc' do |ant|
+        classpath = dependencies | self.class.dependencies.map(&:to_s)
+        ant.taskdef :name => 'groovyc', :classname => ANT_TASK, :classpath => classpath.join(File::PATH_SEPARATOR)
+        ant.groovyc groovyc_options(sources, target) do
+          sources.each { |src| ant.src :path => src }
+          ant.classpath do
+            classpath.each { |dep| ant.pathelement :path => dep }
+          end
+          ant.javac(javac_options)
+        end
+      end
+    end
+
+   private 
+    def groovyc_options(sources, target)
+      check_options options, OPTIONS
+      groovyc_options = options.to_hash.only(*GROOVYC_OPTIONS)
+      groovyc_options[:destdir] = File.expand_path(target)
+      groovyc_options
+    end
+
+    def javac_options
+      check_options options, OPTIONS
+      javac_options = options.to_hash.only(*JAVAC_OPTIONS)
+      javac_options[:optimize] = (javac_options.delete(:optimise) || false)
+      javac_options[:nowarn] = (javac_options.delete(:warnings) || verbose).to_s !~ /^(true|yes|on)$/i
+      other = javac_options.delete(:javac) || {}
+      javac_options.merge!(other)
+      javac_options
+    end
+    
+  end
+end
+
+# Groovy compiler comes first, ahead of Javac, this allows it to pick
+# projects that mix Groovy and Java code by spotting Groovy code first.
+Buildr::Compiler.compilers.unshift Buildr::Groovy::Groovyc

data/lib/buildr/ide/eclipse.rb

@@ -35,15 +35,6 @@ module Buildr
 
     after_define do |project|
       eclipse = project.task("eclipse")
-      # We need paths relative to the top project's base directory.
-      root_path = lambda { |p| f = lambda { |p| p.parent ? f[p.parent] : p.base_dir } ; f[p] }[project]
-
-      # We want the Eclipse files changed every time the Buildfile changes, but also anything loaded by
-      # the Buildfile (buildr.rb, separate file listing dependencies, etc), so we add anything required
-      # after the Buildfile. So which don't know where Buildr shows up exactly, ignore files that show
-      # in $LOADED_FEATURES that we cannot resolve.
-      sources = Buildr.application.build_files.map { |file| File.expand_path(file) }.select { |file| File.exist?(file) }
-      sources << File.expand_path(Buildr.application.buildfile, root_path) if Buildr.application.buildfile
 
       # Check if project has scala facet
       scala = project.compile.language == :scala
@@ -56,23 +47,14 @@ module Buildr
         eclipse.enhance [ file(project.path_to(".classpath")), file(project.path_to(".project")) ]
 
         # The only thing we need to look for is a change in the Buildfile.
-        file(project.path_to(".classpath")=>sources) do |task|
-          puts "Writing #{task.name}" if verbose
-
-          # Find a path relative to the project's root directory.
-          relative = lambda do |path|
-            path or raise "Invalid path '#{path.inspect}'"
-            msg = [:to_path, :to_str, :to_s].find { |msg| path.respond_to? msg }
-            path = path.__send__(msg)
-            Util.relative_path(File.expand_path(path), project.path_to)
-          end
+        file(project.path_to(".classpath")=>Buildr.application.buildfile) do |task|
+          info "Writing #{task.name}"
 
           m2repo = Buildr::Repositories.instance.local
-          excludes = [ '**/.svn/', '**/CVS/' ].join('|')
 
           File.open(task.name, "w") do |file|
-            xml = Builder::XmlMarkup.new(:target=>file, :indent=>2)
-            xml.classpath do
+            classpathentry = ClasspathEntryWriter.new project, file
+            classpathentry.write do
               # Note: Use the test classpath since Eclipse compiles both "main" and "test" classes using the same classpath
               cp = project.test.compile.dependencies.map(&:to_s) - [ project.compile.target.to_s, project.resources.target.to_s ]
               cp = cp.uniq
@@ -89,81 +71,49 @@ module Buildr
               # Generated: classpath elements in the project are assumed to be generated
               generated, libs = others.partition { |path| path.to_s.index(project.path_to.to_s) == 0 }
 
-              srcs = project.compile.sources
-
-              srcs = srcs.map { |src| relative[src] } + generated.map { |src| relative[src] }
-              srcs.sort.uniq.each do |path|
-                xml.classpathentry :kind=>'src', :path=>path, :excluding=>excludes
-              end
-
-              # Main resources implicitly copied into project.compile.target
-              main_resource_sources = project.resources.sources.map { |src| relative[src] }
-              main_resource_sources.each do |path|
-                if File.exist? project.path_to(path)
-                  xml.classpathentry :kind=>'src', :path=>path, :excluding=>excludes
-                end
-              end
+              classpathentry.src project.compile.sources + generated
+              classpathentry.src project.resources
 
               if project.test.compile.target
-                # Test classes are generated in a separate output directory
-                test_sources = project.test.compile.sources.map { |src| relative[src] }
-                test_sources.each do |paths|
-                  paths.sort.uniq.each do |path|
-                    xml.classpathentry :kind=>'src', :path=>path, :output => relative[project.test.compile.target], :excluding=>excludes
-                  end
-                end
-
-                # Test resources go in separate output directory as well
-                project.test.resources.sources.each do |path|
-                  if File.exist? project.path_to(path)
-                    xml.classpathentry :kind=>'src', :path=>relative[path], :output => relative[project.test.compile.target], :excluding=>excludes
-                  end
-                end
+                classpathentry.src project.test.compile
+                classpathentry.src project.test.resources
               end
 
               # Classpath elements from other projects
-              project_libs.map(&:id).sort.uniq.each do |project_id|
-                xml.classpathentry :kind=>'src', :combineaccessrules=>"false", :path=>"/#{project_id}" 
-              end
+              classpathentry.src_projects project_libs
 
-              { :output => relative[project.compile.target],
-                :lib    => libs.map(&:to_s),
-                :var    => m2_libs.map { |path| path.to_s.sub(m2repo, 'M2_REPO') }
-              }.each do |kind, paths|
-                paths.sort.uniq.each do |path|
-                  xml.classpathentry :kind=>kind, :path=>path
-                end
-              end
+              classpathentry.output project.compile.target
+              classpathentry.lib libs
+              classpathentry.var m2_libs, 'M2_REPO', m2repo
 
-              xml.classpathentry :kind=>'con', :path=>'org.eclipse.jdt.launching.JRE_CONTAINER'
-              xml.classpathentry :kind=>'con', :path=>'ch.epfl.lamp.sdt.launching.SCALA_CONTAINER' if scala
+              classpathentry.con 'ch.epfl.lamp.sdt.launching.SCALA_CONTAINER' if scala
+              classpathentry.con 'org.eclipse.jdt.launching.JRE_CONTAINER'
             end
           end
         end
 
         # The only thing we need to look for is a change in the Buildfile.
-        file(project.path_to(".project")=>sources) do |task|
-          puts "Writing #{task.name}" if verbose
+        file(project.path_to(".project")=>Buildr.application.buildfile) do |task|
+          info "Writing #{task.name}"
           File.open(task.name, "w") do |file|
             xml = Builder::XmlMarkup.new(:target=>file, :indent=>2)
             xml.projectDescription do
               xml.name project.id
               xml.projects
               xml.buildSpec do
-                xml.buildCommand do
-                  xml.name "org.eclipse.jdt.core.javabuilder"
-                end
                 if scala
                   xml.buildCommand do
                     xml.name "ch.epfl.lamp.sdt.core.scalabuilder"
-                    #xml.name "scala.plugin.scalabuilder"
+                  end
+                else
+                  xml.buildCommand do
+                    xml.name "org.eclipse.jdt.core.javabuilder"
                   end
                 end
               end
               xml.natures do
-                xml.nature "org.eclipse.jdt.core.javanature"
                 xml.nature "ch.epfl.lamp.sdt.core.scalanature" if scala
-                #xml.nature "scala.plugin.scalanature" if scala
+                xml.nature "org.eclipse.jdt.core.javanature"
               end
             end
           end
@@ -172,6 +122,87 @@ module Buildr
 
     end
 
+    # Writes 'classpathentry' tags in an xml file.
+    # It converts tasks to paths.
+    # It converts absolute paths to relative paths.
+    # It ignores duplicate directories.
+    class ClasspathEntryWriter
+      def initialize project, target
+        @project = project
+        @xml = Builder::XmlMarkup.new(:target=>target, :indent=>2)
+        @excludes = [ '**/.svn/', '**/CVS/' ].join('|')
+        @paths_written = []
+      end
+      
+      def write &block
+        @xml.classpath &block
+      end
+      
+      def con path
+        @xml.classpathentry :kind=>'con', :path=>path
+      end
+
+      def lib libs
+        libs.map(&:to_s).sort.uniq.each do |path|
+          @xml.classpathentry :kind=>'lib', :path=>path
+        end
+      end
+
+      # Write a classpathentry of kind 'src'.
+      # Accepts an array of absolute paths or a task.
+      def src arg
+        if [:sources, :target].all? { |message| arg.respond_to?(message) }
+          src_from_task arg
+        else
+          src_from_absolute_paths arg
+        end
+      end
+
+      # Write a classpathentry of kind 'src' for dependent projects.
+      # Accepts an array of projects.
+      def src_projects project_libs
+        project_libs.map(&:id).sort.uniq.each do |project_id|
+          @xml.classpathentry :kind=>'src', :combineaccessrules=>"false", :path=>"/#{project_id}"
+        end
+      end
+      
+      def output target
+        @xml.classpathentry :kind=>'output', :path=>relative(target)
+      end
+
+      def var libs, var_name, var_value
+        libs.map { |lib| lib.to_s.sub(var_value, var_name) }.sort.uniq.each do |path|
+          @xml.classpathentry :kind=>'var', :path=>path
+        end
+      end
+              
+      private
+
+      # Find a path relative to the project's root directory.
+      def relative path
+        path or raise "Invalid path '#{path.inspect}'"
+        msg = [:to_path, :to_str, :to_s].find { |msg| path.respond_to? msg }
+        path = path.__send__(msg)
+        Util.relative_path(File.expand_path(path), @project.path_to)
+      end
+
+      def src_from_task task
+        src_from_absolute_paths task.sources, task.target
+      end
+
+      def src_from_absolute_paths absolute_paths, output=nil
+        relative_paths = absolute_paths.map { |src| relative(src) }
+        relative_paths.sort.uniq.each do |path|
+          unless @paths_written.include?(path)
+            attributes = { :kind=>'src', :path=>path, :excluding=>@excludes }
+            attributes[:output] = relative(output) if output
+            @xml.classpathentry attributes
+            @paths_written << path
+          end
+        end
+      end
+    end
+
   end
 end # module Buildr