buildr 1.3.0-java

data/lib/buildr/core/environment.rb

@@ -0,0 +1,120 @@
+# 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 'yaml'
+
+
+module Buildr
+
+  # Collection of options for controlling Buildr.
+  class Options
+
+    # We use this to present environment variable as arrays.
+    class EnvArray < Array #:nodoc:
+    
+      def initialize(name)
+        @name = name.upcase
+        replace((ENV[@name] || ENV[@name.downcase] || '').split(/\s*,\s*/).reject(&:empty?))
+      end
+
+      (Array.instance_methods - Object.instance_methods - Enumerable.instance_methods).sort.each do |method|
+        class_eval %{def #{method}(*args, &block) ; result = super ; write ; result ; end}
+      end
+
+    private
+
+      def write
+        ENV[@name.downcase] = nil
+        ENV[@name] = map(&:to_s).join(',')
+      end
+
+    end
+
+
+    # Wraps around the proxy environment variables:
+    # * :http -- HTTP_PROXY
+    # * :exclude -- NO_PROXY
+    class Proxies
+
+      # Returns the HTTP_PROXY URL.
+      def http
+        ENV['HTTP_PROXY'] || ENV['http_proxy']
+      end
+
+      # Sets the HTTP_PROXY URL.
+      def http=(url)
+        ENV['http_proxy'] = nil
+        ENV['HTTP_PROXY'] = url
+      end
+   
+      # Returns list of hosts to exclude from proxying (NO_PROXY). 
+      def exclude
+        @exclude ||= EnvArray.new('NO_PROXY')
+      end
+
+      # Sets list of hosts to exclude from proxy (NO_PROXY). Accepts host name, array of names,
+      # or nil to clear the list.
+      def exclude=(url)
+        exclude.clear
+        exclude.concat [url].flatten if url
+        exclude
+      end
+
+    end
+
+    # :call-seq:
+    #   proxy => options
+    #
+    # Returns the proxy options. Currently supported options are:
+    # * :http -- HTTP proxy for use when downloading.
+    # * :exclude -- Do not use proxy for these hosts/domains.
+    #
+    # For example:
+    #   options.proxy.http = 'http://proxy.acme.com:8080'
+    # You can also set it using the environment variable HTTP_PROXY.
+    #
+    # You can exclude individual hosts from being proxied, or entire domains, for example:
+    #   options.proxy.exclude = 'optimus'
+    #   options.proxy.exclude = ['optimus', 'prime']
+    #   options.proxy.exclude << '*.internal'
+    def proxy
+      @proxy ||= Proxies.new
+    end
+
+  end
+
+
+  class << self
+
+    # :call-seq:
+    #   options => Options
+    #
+    # Returns the Buildr options. See Options.
+    def options
+      @options ||= Options.new
+    end
+
+  end
+
+  # :call-seq:
+  #   options => Options
+  #
+  # Returns the Buildr options. See Options.
+  def options
+    Buildr.options
+  end
+
+end

data/lib/buildr/core/filter.rb

@@ -0,0 +1,258 @@
+# 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
+
+  # A filter knows how to copy files from one directory to another, applying mappings to the
+  # contents of these files.
+  #
+  # You can specify the mapping using a Hash, and it will map ${key} fields found in each source
+  # file into the appropriate value in the target file. For example:
+  #
+  #   filter.using 'version'=>'1.2', 'build'=>Time.now
+  #
+  # will replace all occurrences of <tt>${version}</tt> with <tt>1.2</tt>, and <tt>${build}</tt>
+  # with the current date/time.
+  #
+  # You can also specify the mapping by passing a proc or a method, that will be called for
+  # each source file, with the file name and content, returning the modified content.
+  #
+  # Without any mapping, the filter simply copies files from the source directory into the target
+  # directory.
+  #
+  # A filter has one target directory, but you can specify any number of source directories,
+  # either when creating the filter or calling #from. Include/exclude patterns are specified
+  # relative to the source directories, so:
+  #   filter.include '*.png'
+  # will only include PNG files from any of the source directories.
+  #
+  # See Buildr#filter.
+  class Filter
+
+    def initialize #:nodoc:
+      clear
+    end
+
+    # Returns the list of source directories (each being a file task).
+    attr_reader :sources
+
+    # :call-seq: 
+    #   clear => self
+    # 
+    # Clear filter sources and include/exclude patterns
+    def clear
+      @include = []
+      @exclude = []
+      @sources = []
+      self
+    end
+
+    # :call-seq:
+    #   from(*sources) => self
+    #
+    # Adds additional directories from which to copy resources.
+    #
+    # For example:
+    #   filter.from('src').into('target').using('build'=>Time.now)
+    def from(*sources)
+      @sources |= sources.flatten.map { |dir| file(File.expand_path(dir.to_s)) }
+      self
+    end
+
+    # The target directory as a file task.
+    attr_reader :target
+
+    # :call-seq:
+    #   into(dir) => self
+    #
+    # Sets the target directory into which files are copied and returns self.
+    #
+    # For example:
+    #   filter.from('src').into('target').using('build'=>Time.now)
+    def into(dir)
+      @target = file(File.expand_path(dir.to_s)) { |task| run if target == task && !sources.empty? }
+      self
+    end
+
+    # :call-seq:
+    #   include(*files) => self
+    #
+    # Specifies files to include and returns self. See FileList#include.
+    #
+    # By default all files are included. You can use this method to only include specific
+    # files form the source directory.
+    def include(*files)
+      @include += files
+      self
+    end
+    alias :add :include 
+
+    # :call-seq:
+    #   exclude(*files) => self
+    #
+    # Specifies files to exclude and returns self. See FileList#exclude.
+    def exclude(*files)
+      @exclude += files
+      self
+    end
+
+    # The mapping. See #using.
+    attr_accessor :mapping
+
+    # The mapper to use. See #using.
+    attr_accessor :mapper
+
+    # :call-seq:
+    #   using(mapping) => self
+    #   using { |file_name, contents| ... } => self
+    #
+    # Specifies the mapping to use and returns self.
+    #
+    # The most typical mapping uses a Hash, and the default mapping uses the Maven style, so
+    # <code>${key}</code> are mapped to the values. You can change that by passing a different
+    # format as the first argument. Currently supports:
+    # * :ant -- Map <code>@key@</code>.
+    # * :maven -- Map <code>${key}</code> (default).
+    # * :ruby -- Map <code>#{key}</code>.
+    # * Regexp -- Maps the matched data (e.g. <code>/=(.*?)=/</code>
+    #
+    # For example:
+    #   filter.using 'version'=>'1.2'
+    # Is the same as:
+    #   filter.using :maven, 'version'=>'1.2'
+    #
+    # You can also pass a proc or method. It will be called with the file name and content,
+    # to return the mapped content.
+    #
+    # Without any mapping, all files are copied as is.
+    def using(*args, &block)
+      case args.first
+      when Hash # Maven hash mapping
+        using :maven, *args
+      when Symbol # Mapping from a method
+        raise ArgumentError, 'Expected mapper type followed by mapping hash' unless args.size == 2 && Hash === args[1]
+        @mapper, @mapping = *args
+      when Regexp # Mapping using a regular expression
+        raise ArgumentError, 'Expected regular expression followed by mapping hash' unless args.size == 2 && Hash === args[1]
+        @mapper, @mapping = *args
+      else
+        raise ArgumentError, 'Expected proc, method or a block' if args.size > 1 || (args.first && block)
+        @mapping = args.first || block
+      end
+      self
+    end
+
+    # :call-seq:
+    #    run => boolean
+    #
+    # Runs the filter.
+    def run
+      raise 'No source directory specified, where am I going to find the files to filter?' if sources.empty?
+      sources.each { |source| raise "Source directory #{source} doesn't exist" unless File.exist?(source.to_s) }
+      raise 'No target directory specified, where am I going to copy the files to?' if target.nil?
+
+      copy_map = sources.flatten.map(&:to_s).inject({}) do |map, source|
+        files = Util.recursive_with_dot_files(source).
+          map { |file| Util.relative_path(file, source) }.
+          select { |file| @include.empty? || @include.any? { |pattern| File.fnmatch(pattern, file, File::FNM_PATHNAME) } }.
+          reject { |file| @exclude.any? { |pattern| File.fnmatch(pattern, file, File::FNM_PATHNAME) } }
+        files.each do |file|
+          src, dest = File.expand_path(file, source), File.expand_path(file, target.to_s)
+          map[file] = src if !File.exist?(dest) || File.stat(src).mtime > File.stat(dest).mtime
+        end
+        map
+      end
+        
+      return false if copy_map.empty?
+
+      verbose(Buildr.application.options.trace || false) do
+        mkpath target.to_s
+        copy_map.each do |path, source|
+          dest = File.expand_path(path, target.to_s)
+          if File.directory?(source)
+            mkpath dest
+          else
+            mkpath File.dirname(dest)
+            case mapping
+            when Proc, Method # Call on input, accept output.
+              mapped = mapping.call(path, File.open(source, 'rb') { |file| file.read })
+              File.open(dest, 'wb') { |file| file.write mapped }
+            when Hash # Map ${key} to value
+              content = File.open(source, 'rb') { |file| file.read }
+              if Symbol === @mapper
+                mapped = send("#{@mapper}_mapper", content) { |key| mapping[key] }
+              else
+                mapped = regexp_mapper(content) { |key| mapping[key] }
+              end
+                #gsub(/\$\{[^}]*\}/) { |str| mapping[str[2..-2]] || str }
+              File.open(dest, 'wb') { |file| file.write mapped }
+            when nil # No mapping.
+              cp source, dest
+              File.chmod(0664, dest)
+            else
+              fail "Filter can be a hash (key=>value), or a proc/method; I don't understand #{mapping}"
+            end
+          end
+        end
+        touch target.to_s 
+      end
+      true
+    end
+
+    # Returns the target directory. 
+    def to_s
+      @target.to_s
+    end
+
+  private
+
+    def maven_mapper(content)
+      content.gsub(/\$\{.*?\}/) { |str| yield(str[2..-2]) || str }
+    end
+
+    def ant_mapper(content)
+      content.gsub(/@.*?@/) { |str| yield(str[1..-2]) || str }
+    end
+
+    def ruby_mapper(content)
+      content.gsub(/#\{.*?\}/) { |str| yield(str[2..-2]) || str }
+    end
+
+    def regexp_mapper(content)
+      content.gsub(@mapper) { |str| yield(str.scan(@mapper).join) || str }
+    end
+
+  end
+
+  # :call-seq:
+  #   filter(*source) => Filter
+  #
+  # Creates a filter that will copy files from the source directory(ies) into the target directory.
+  # You can extend the filter to modify files by mapping <tt>${key}</tt> into values in each
+  # of the copied files, and by including or excluding specific files.
+  #
+  # A filter is not a task, you must call the Filter#run method to execute it.
+  #
+  # For example, to copy all files from one directory to another:
+  #   filter('src/files').into('target/classes').run
+  # To include only the text files, and replace each instance of <tt>${build}</tt> with the current
+  # date/time:
+  #   filter('src/files').into('target/classes').include('*.txt').using('build'=>Time.now).run
+  def filter(*sources)
+    Filter.new.from(*sources)
+  end
+
+end

data/lib/buildr/core/generate.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.
+
+
+require 'buildr/java/pom'
+
+
+module Buildr
+  module Generate #:nodoc:
+
+    task "generate" do
+      script = nil 
+      choose do |menu|
+        menu.header = "To use Buildr you need a buildfile. Do you want me to create one?"
+
+        menu.choice("From maven2 pom file") { script = Generate.from_maven2_pom(true).join("\n") } if File.exists?("pom.xml")
+        menu.choice("From directory structure") { script = Generate.from_directory(true).join("\n") }
+        menu.choice("Skip") { }
+      end
+       
+      if script    
+        buildfile = File.expand_path(Buildr::Application::DEFAULT_BUILDFILES.first)
+        File.open(buildfile, "w") { |file| file.write script }
+        puts "Created #{buildfile}"
+      end        
+    end
+
+    class << self
+
+
+      HEADER = "# Generated by Buildr #{Buildr::VERSION}, change to your liking\n\n"
+
+
+      def from_directory(root = false)
+        name = File.basename(Dir.pwd)
+        if root
+          script = HEADER.split("\n")
+          header = <<-EOF
+# Version number for this release
+VERSION_NUMBER = "1.0.0"
+# Version number for the next release
+NEXT_VERSION = "1.0.1"
+# Group identifier for your projects
+GROUP = "#{name}"
+COPYRIGHT = ""
+
+# Specify Maven 2.0 remote repositories here, like this:
+repositories.remote << "http://www.ibiblio.org/maven2/"
+
+desc "The #{name.capitalize} project"
+define "#{name}" do
+
+  project.version = VERSION_NUMBER
+  project.group = GROUP
+  manifest["Implementation-Vendor"] = COPYRIGHT
+EOF
+          script += header.split("\n")
+        else
+          script = [ %{define "#{name}" do} ]
+        end
+        script <<  "  compile.with # Add classpath dependencies" if File.exist?("src/main/java")
+        script <<  "  resources" if File.exist?("src/main/resources")
+        script <<  "  test.compile.with # Add classpath dependencies" if File.exist?("src/test/java")
+        script <<  "  test.resources" if File.exist?("src/test/resources")
+        if File.exist?("src/main/webapp")
+          script <<  "  package(:war)"
+        elsif File.exist?("src/main/java")
+          script <<  "  package(:jar)"
+        end
+        dirs = FileList["*"].exclude("src", "target", "report").
+          select { |file| File.directory?(file) && File.exist?(File.join(file, "src")) }
+        unless dirs.empty?
+          script << ""
+          dirs.sort.each do |dir|
+            Dir.chdir(dir) { script << from_directory.flatten.map { |line| "  " + line } << "" }
+          end
+        end
+        script << "end"
+        script.flatten
+      end
+
+      def from_maven2_pom(root = false)
+        pom = Buildr::POM.load('pom.xml')
+        project = pom.project
+
+        artifactId = project['artifactId'].first
+        description = project['name'] || "The #{artifactId} project"
+        project_name = File.basename(Dir.pwd)
+
+        if root
+          script = HEADER.split("\n")
+
+          settings_file = ENV["M2_SETTINGS"] || File.join(ENV['HOME'], ".m2/settings.xml")
+          settings = XmlSimple.xml_in(IO.read(settings_file)) if File.exists?(settings_file)
+
+          if settings
+            proxy = settings['proxies'].first['proxy'].find { |proxy|
+              proxy["active"].nil? || proxy["active"].to_s =~ /true/
+            } rescue nil
+            
+            if proxy
+              url = %{#{proxy["protocol"].first}://#{proxy["host"].first}:#{proxy["port"].first}}
+              exclude = proxy["nonProxyHosts"].to_s.gsub("|", ",") if proxy["nonProxyHosts"]
+              script << "options.proxy.http = '#{url}'"
+              script << "options.proxy.exclude << '#{exclude}'" if exclude
+              script << ''
+              # In addition, we need to use said proxies to download artifacts.
+              Buildr.options.proxy.http = url
+              Buildr.options.proxy.exclude << exclude if exclude
+            end
+          end
+
+          repositories = project["repositories"].first["repository"].select { |repository|
+            legacy = repository["layout"].to_s =~ /legacy/
+            !legacy
+          } rescue nil
+          repositories = [{"name" => "Standard maven2 repository", "url" => "http://www.ibiblio.org/maven2/"}] if repositories.nil? || repositories.empty?
+          repositories.each do |repository|
+            name, url = repository["name"], repository["url"]
+            script << "# #{name}"
+            script << "repositories.remote << '#{url}'"
+            # In addition we need to use said repositores to download artifacts.
+            Buildr.repositories.remote << url.to_s
+          end
+          script << ""
+        else
+          script = []
+        end
+
+        script << "desc '#{description}'"
+        script << "define '#{project_name}' do"
+
+        groupId = project['groupId']
+        script << "  project.group = '#{groupId}'" if groupId
+
+        version = project['version']
+        script << "  project.version = '#{version}'" if version
+
+        #get plugins configurations
+        plugins = project['build'].first['plugins'].first['plugin'] rescue {}
+        compile_plugin = plugins.find{|pl| (pl['groupId'].nil? or pl['groupId'].first == 'org.apache.maven.plugins') and pl['artifactId'].first == 'maven-compiler-plugin'}
+        if compile_plugin
+          source = compile_plugin.first['configuration'].first['source'] rescue nil
+          target = compile_plugin.first['configuration'].first['target'] rescue nil
+
+          script << "  compile.options.source = '#{source}'" if source
+          script << "  compile.options.target = '#{target}'" if target
+        end
+
+        compile_dependencies = pom.dependencies
+        dependencies = compile_dependencies.sort.map{|d| "'#{d}'"}.join(', ')
+        script <<  "  compile.with #{dependencies}" unless dependencies.empty?
+
+        test_dependencies = (pom.dependencies(['test']) - compile_dependencies).reject{|d| d =~ /^junit:junit:jar:/ }
+        #check if we have testng
+        use_testng = test_dependencies.find{|d| d =~ /^org.testng:testng:jar:/}
+        if use_testng
+          script <<  "  test.using :testng"
+          test_dependencies = pom.dependencies(['test']).reject{|d| d =~ /^org.testng:testng:jar:/ }
+        end
+
+        test_dependencies = test_dependencies.sort.map{|d| "'#{d}'"}.join(', ')
+        script <<  "  test.with #{test_dependencies}" unless test_dependencies.empty?
+
+        packaging = project['packaging'] ? project['packaging'].first : 'jar'
+        if %w(jar war).include?(packaging)
+          script <<  "  package :#{packaging}, :id => '#{artifactId}'"
+        end
+
+        modules = project['modules'].first['module'] rescue nil
+        if modules
+          script << ""
+          modules.each do |mod|
+            chdir(mod) { script << from_maven2_pom.flatten.map { |line| "  " + line } << "" }
+          end
+        end
+        script << "end"
+        script.flatten
+      end
+       
+    end
+  end
+end