buildr 1.3.0-java → 1.3.1-java

data/lib/buildr/core/compile.rb

@@ -403,7 +403,7 @@ module Buildr
       @filter = Buildr::Filter.new
       @filter.using Buildr.settings.profile['filter'] if Hash === Buildr.settings.profile['filter']
       enhance do
-        filter.run if target && !sources.empty?
+        filter.run if target
       end
     end
 

data/lib/buildr/core/filter.rb

@@ -83,7 +83,7 @@ module Buildr
     # 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? }
+      @target = file(File.expand_path(dir.to_s)) { |task| run if target == task }
       self
     end
 
@@ -160,7 +160,6 @@ module Buildr
     #
     # 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?
 
@@ -176,10 +175,10 @@ module Buildr
         map
       end
         
+      mkpath target.to_s
       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)
@@ -198,7 +197,7 @@ module Buildr
                 mapped = regexp_mapper(content) { |key| mapping[key] }
               end
                 #gsub(/\$\{[^}]*\}/) { |str| mapping[str[2..-2]] || str }
-              File.open(dest, 'wb') { |file| file.write mapped }
+                File.open(dest, 'wb') { |file| file.write mapped }
             when nil # No mapping.
               cp source, dest
               File.chmod(0664, dest)
@@ -207,7 +206,7 @@ module Buildr
             end
           end
         end
-        touch target.to_s 
+        touch target.to_s
       end
       true
     end

data/lib/buildr/core/transports.rb

@@ -20,9 +20,9 @@ require 'net/https'
 require 'net/ssh'
 require 'net/sftp'
 require 'uri'
-require 'uri/sftp'
 require 'digest/md5'
 require 'digest/sha1'
+require 'stringio'
 require 'tempfile'
 require 'buildr/core/progressbar'
 
@@ -259,17 +259,17 @@ module URI
     # The block is yielded with a progress object that implements a single method.
     # Call << for each block of bytes down/uploaded.
     def with_progress_bar(show, file_name, size, &block) #:nodoc:
-      options = { :total=>size, :title=>file_name }
+      options = { :total=>size || 0, :title=>file_name }
       options[:hidden] = true unless show
       ProgressBar.start options, &block
     end
 
     # :call-seq:
-    #   proxy_uri() => URI?
+    #   proxy_uri => URI?
     #
     # Returns the proxy server to use. Obtains the proxy from the relevant environment variable (e.g. HTTP_PROXY).
     # Supports exclusions based on host name and port number from environment variable NO_PROXY.
-    def proxy_uri()
+    def proxy_uri
       proxy = ENV["#{scheme.upcase}_PROXY"]
       proxy = URI.parse(proxy) if String === proxy
       excludes = ENV['NO_PROXY'].to_s.split(/\s*,\s*/).compact
@@ -289,60 +289,106 @@ module URI
     # See URI::Generic#read
     def read(options = nil, &block)
       options ||= {}
-      headers = { 'If-Modified-Since' => CGI.rfc1123_date(options[:modified].utc) } if options[:modified]
-
-      if proxy = proxy_uri
-        proxy = URI.parse(proxy) if String === proxy
-        http = Net::HTTP.new(host, port, proxy.host, proxy.port, proxy.user, proxy.password)
-      else
-        http = Net::HTTP.new(host, port)
+      connect do |http|
+        puts "Requesting #{self}"  if Buildr.application.options.trace
+        headers = { 'If-Modified-Since' => CGI.rfc1123_date(options[:modified].utc) } if options[:modified]
+        request = Net::HTTP::Get.new(request_uri.empty? ? '/' : request_uri, headers)
+        request.basic_auth self.user, self.password if self.user
+        http.request request do |response|
+          case response
+          when Net::HTTPNotModified
+            # No modification, nothing to do.
+            puts 'Not modified since last download' if Buildr.application.options.trace
+            return nil
+          when Net::HTTPRedirection
+            # Try to download from the new URI, handle relative redirects.
+            puts "Redirected to #{response['Location']}" if Buildr.application.options.trace
+            return (self + URI.parse(response['location'])).read(options, &block)
+          when Net::HTTPOK
+            puts "Downloading #{self}" if verbose
+            result = nil
+            with_progress_bar options[:progress], path.split('/').last, response.content_length do |progress|
+              if block
+                response.read_body do |chunk|
+                  block.call chunk
+                  progress << chunk
+                end
+              else
+                result = ''
+                response.read_body do |chunk|
+                  result << chunk
+                  progress << chunk
+                end
+              end
+            end
+            return result
+          when Net::HTTPNotFound
+            raise NotFoundError, "Looking for #{self} and all I got was a 404!"
+          else
+            raise RuntimeError, "Failed to download #{self}: #{response.message}"
+          end
+        end
       end
-      http.use_ssl = true if self.instance_of? URI::HTTPS
+    end
+
+  private
+
+    def write_internal(options, &block) #:nodoc:
+      options ||= {}
+      connect do |http|
+        puts "Uploading to #{path}" if Buildr.application.options.trace
+        content = StringIO.new
+        while chunk = yield(32 * 4096)
+          content << chunk
+        end
+        headers = { 'Content-MD5'=>Digest::MD5.hexdigest(content.string) }
+        request = Net::HTTP::Put.new(request_uri.empty? ? '/' : request_uri, headers)
+        request.basic_auth self.user, self.password if self.user
+        response = nil
+        with_progress_bar options[:progress], path.split('/').last, content.size do |progress|
+          request.content_length = content.size
+          content.rewind
+          stream = Object.new
+          class << stream ; self ;end.send :define_method, :read do |count|
+            bytes = content.read(count)
+            progress << bytes if bytes
+            bytes
+          end
+          request.body_stream = stream
+          response = http.request(request)
+        end
 
-      puts "Requesting #{self}"  if Buildr.application.options.trace
-      request = Net::HTTP::Get.new(path.empty? ? '/' : path, headers)
-      request.basic_auth self.user, self.password if self.user
-      http.request request do |response|
         case response
-        #case response = http.request(request)
-        when Net::HTTPNotModified
-          # No modification, nothing to do.
-          puts 'Not modified since last download' if Buildr.application.options.trace
-          return nil
         when Net::HTTPRedirection
           # Try to download from the new URI, handle relative redirects.
           puts "Redirected to #{response['Location']}" if Buildr.application.options.trace
-          return (self + URI.parse(response['location'])).read(options, &block)
-        when Net::HTTPOK
-          puts "Downloading #{self}" if verbose
-          result = nil
-          with_progress_bar options[:progress], path.split('/').last, response.content_length do |progress|
-            if block
-              response.read_body do |chunk|
-                block.call chunk
-                progress << chunk
-              end
-            else
-              result = ''
-              response.read_body do |chunk|
-                result << chunk
-                progress << chunk
-              end
-            end
-          end
-          return result
-        when Net::HTTPNotFound
-          raise NotFoundError, "Looking for #{self} and all I got was a 404!"
+          content.rewind
+          return (self + URI.parse(response['location'])).write_internal(options) { |bytes| content.read(bytes) }
+        when Net::HTTPSuccess
         else
-          raise RuntimeError, "Failed to download #{self}: #{response.message}"
+          raise RuntimeError, "Failed to upload #{self}: #{response.message}"
         end
       end
     end
 
+    def connect
+      if proxy = proxy_uri
+        proxy = URI.parse(proxy) if String === proxy
+        http = Net::HTTP.new(host, port, proxy.host, proxy.port, proxy.user, proxy.password)
+      else
+        http = Net::HTTP.new(host, port)
+      end
+      http.use_ssl = true if self.instance_of? URI::HTTPS
+      yield http
+    end
+
   end
 
 
-  class SFTP #:nodoc:
+  class SFTP < Generic #:nodoc:
+
+    DEFAULT_PORT = 22
+    COMPONENT = [ :scheme, :userinfo, :host, :port, :path ].freeze
 
     class << self
       # Caching of passwords, so we only need to ask once.
@@ -351,16 +397,40 @@ module URI
       end
     end
 
-  protected
+    def initialize(*arg)
+      super
+    end
 
-    def write_internal(options, &block) #:nodoc:
+    def read(options = {}, &block)
       # SSH options are based on the username/password from the URI.
-      ssh_options = { :port=>port, :username=>user, :password=>password }.merge(options[:ssh_options] || {})
+      ssh_options = { :port=>port, :password=>password }.merge(options[:ssh_options] || {})
       ssh_options[:password] ||= SFTP.passwords[host]
       begin
         puts "Connecting to #{host}" if Buildr.application.options.trace
-        session = Net::SSH.start(host, ssh_options)
-        SFTP.passwords[host] = ssh_options[:password]
+        result = nil
+        Net::SFTP.start(host, user, ssh_options) do |sftp|
+          SFTP.passwords[host] = ssh_options[:password]
+          puts 'connected' if Buildr.application.options.trace
+
+          with_progress_bar options[:progress] && options[:size], path.split('/'), options[:size] || 0 do |progress|
+            puts "Downloading to #{path}" if Buildr.application.options.trace
+            sftp.file.open(path, 'r') do |file|
+              if block
+                while chunk = file.read(32 * 4096)
+                  block.call chunk
+                  progress << chunk
+                end
+              else
+                result = ''
+                while chunk = file.read(32 * 4096)
+                  result << chunk
+                  progress << chunk
+                end
+              end
+            end
+          end
+        end
+        return result
       rescue Net::SSH::AuthenticationFailed=>ex
         # Only if running with console, prompt for password.
         if !ssh_options[:password] && $stdout.isatty
@@ -370,39 +440,55 @@ module URI
         end
         raise
       end
+    end
 
-      session.sftp.connect do |sftp|
-        puts 'connected' if Buildr.application.options.trace
+  protected
 
-        # To create a path, we need to create all its parent. We use realpath to determine if
-        # the path already exists, otherwise mkdir fails.
-        puts "Creating path #{path}" if Buildr.application.options.trace
-        File.dirname(path).split('/').inject('') do |base, part|
-          combined = base + part
-          sftp.realpath combined rescue sftp.mkdir combined, {}
-          "#{combined}/"
-        end
+    def write_internal(options, &block) #:nodoc:
+      # SSH options are based on the username/password from the URI.
+      ssh_options = { :port=>port, :password=>password }.merge(options[:ssh_options] || {})
+      ssh_options[:password] ||= SFTP.passwords[host]
+      begin
+        puts "Connecting to #{host}" if Buildr.application.options.trace
+        Net::SFTP.start(host, user, ssh_options) do |sftp|
+          SFTP.passwords[host] = ssh_options[:password]
+          puts 'connected' if Buildr.application.options.trace
+
+          # To create a path, we need to create all its parent. We use realpath to determine if
+          # the path already exists, otherwise mkdir fails.
+          puts "Creating path #{path}" if Buildr.application.options.trace
+          File.dirname(path).split('/').inject('') do |base, part|
+            combined = base + part
+            sftp.realpath combined rescue sftp.mkdir combined, {}
+            "#{combined}/"
+          end
 
-        with_progress_bar options[:progress] && options[:size], path.split('/'), options[:size] || 0 do |progress|
-          puts "Uploading to #{path}" if Buildr.application.options.trace
-          sftp.open_handle(path, 'w') do |handle|
-            # Writing in chunks gives us the benefit of a progress bar,
-            # but also require that we maintain a position in the file,
-            # since write() with two arguments always writes at position 0.
-            pos = 0
-            while chunk = yield(32 * 4096)
-              sftp.write(handle, chunk, pos)
-              pos += chunk.size
-              progress << chunk
+          with_progress_bar options[:progress] && options[:size], path.split('/'), options[:size] || 0 do |progress|
+            puts "Uploading to #{path}" if Buildr.application.options.trace
+            sftp.file.open(path, 'w') do |file|
+              while chunk = yield(32 * 4096)
+                file.write chunk
+                progress << chunk
+              end
+              sftp.setstat(path, :permissions => options[:permissions]) if options[:permissions]
             end
-            sftp.setstat(path, :permissions => options[:permissions]) if options[:permissions]
           end
         end
+      rescue Net::SSH::AuthenticationFailed=>ex
+        # Only if running with console, prompt for password.
+        if !ssh_options[:password] && $stdout.isatty
+          password = ask("Password for #{host}:") { |q| q.echo = '*' }
+          ssh_options[:password] = password
+          retry
+        end
+        raise
       end
     end
 
   end
 
+  @@schemes['SFTP'] = SFTP
+
 
   # File URL. Keep in mind that file URLs take the form of <code>file://host/path</code>, although the host
   # is not used, so typically all you will see are three backslashes. This methods accept common variants,
@@ -448,14 +534,14 @@ module URI
       end
     end
 
-    def to_s()
+    def to_s
       "file://#{host}#{path}"
     end
 
     # The URL path always starts with a backslash. On most operating systems (Linux, Darwin, BSD) it points
     # to the absolute path on the file system. But on Windows, it comes before the drive letter, creating an
     # unusable path, so real_path fixes that. Ugly but necessary hack.
-    def real_path() #:nodoc:
+    def real_path #:nodoc:
       RUBY_PLATFORM =~ /win32/ && path =~ /^\/[a-zA-Z]:\// ? path[1..-1] : path
     end
 

data/lib/buildr/java.rb

@@ -14,7 +14,7 @@
 # the License.
 
 
-ENV['JAVA_HOME'] = '/System/Library/Frameworks/JavaVM.framework/Home' if Config::CONFIG['host_os'] =~ /darwin/i
+ENV['JAVA_HOME'] ||= '/System/Library/Frameworks/JavaVM.framework/Home' if Config::CONFIG['host_os'] =~ /darwin/i
 require PLATFORM == 'java' ? 'buildr/java/jruby' : 'buildr/java/rjb'
 
 

data/lib/buildr/java/bdd_frameworks.rb

@@ -49,7 +49,7 @@ module Buildr
       project.task('test:resources').tap do |res|
         res.send :associate_with, project, bdd_dir
         res.filter.clear
-        project.path_to(:source, bdd_dir, :resources).tap { |dir| resources.from dir if File.exist?(dir) }
+        project.path_to(:source, bdd_dir, :resources).tap { |dir| res.from dir if File.exist?(dir) }
       end
       super
     end
@@ -59,7 +59,10 @@ module Buildr
     include TestFramework::JavaBDD
     self.lang = :ruby
 
-    REQUIRES = ['org.jruby:jruby-complete:jar:1.1']
+    
+    REQUIRES = []
+    REQUIRES.unshift 'org.jruby:jruby-complete:jar:1.1.1' unless RUBY_PLATFORM =~ /java/
+    
     TESTS_PATTERN = [ /_spec.rb$/ ]
     OPTIONS = [:properties, :java_args]
 
@@ -77,7 +80,9 @@ module Buildr
 
     def run(tests, dependencies) #:nodoc:
       cmd_options = task.options.only(:properties, :java_args)
+      dependencies.push *Dir.glob(File.join(jruby_home, "lib/*.jar")) if RUBY_PLATFORM =~ /java/
       cmd_options.update :classpath => dependencies, :project => task.project
+
       # TODO:  Setting up JRuby is something to do before running Buildr.
       #install_gems(cmd_options)
 
@@ -86,7 +91,6 @@ module Buildr
       ENV['CI_REPORTS'] = report_dir
 
       jruby("-Ilib", "-S", "spec",
-      #"--require", gem_path(task.project, "ci_reporter", "lib/ci/reporter/rake/rspec_loader"),
       "--require", "ci/reporter/rake/rspec_loader",
       "--format", "CI::Reporter::RSpecDoc", tests,
       cmd_options.merge({:name => "RSpec"}))
@@ -94,7 +98,7 @@ module Buildr
     end
 
     private
-    def jruby_home(project)
+    def jruby_home
       @jruby_home ||= RUBY_PLATFORM =~ /java/ ? Config::CONFIG['prefix'] : File.expand_path(".jruby", ENV['HOME'])
     end
 
@@ -113,16 +117,10 @@ module Buildr
       java_args << {} unless Hash === args.last
       cmd_options = java_args.last
       project = cmd_options.delete(:project)
-      if RUBY_PLATFORM =~ /java/
-        # when run from within JRuby, use jars in launched-JRuby's classpath rather than the
-        # stated dependency
-        cmd_options[:classpath].delete_if {|e| File.basename(e) =~ /^jruby-complete-.*\.jar$/ }
-        cmd_options[:classpath].unshift *(java.lang.System.getProperty("java.class.path").split(File::PATH_SEPARATOR))
-      end
       cmd_options[:java_args] ||= []
       cmd_options[:java_args] << "-Xmx512m" unless cmd_options[:java_args].detect {|a| a =~ /^-Xmx/}
       cmd_options[:properties] ||= {}
-      cmd_options[:properties]["jruby.home"] = jruby_home(project)
+      cmd_options[:properties]["jruby.home"] = jruby_home
       Java::Commands.java(*java_args)
     end
 

data/lib/buildr/java/commands.rb

@@ -50,6 +50,7 @@ module Java
           puts "Running #{name}" if verbose
           block = lambda { |ok, res| fail "Failed to execute #{name}, see errors above" unless ok } unless block
           puts cmd_args.join(' ') if Buildr.application.options.trace
+          cmd_args = cmd_args.map(&:inspect).join(' ') if Util.win_os?
           system(*cmd_args).tap do |ok|
             block.call ok, $?
           end