buildr 1.2.10 → 1.3.0

data/lib/{core → buildr/core}/transports.rb

@@ -1,15 +1,30 @@
-require "cgi"
-require "net/http"
-require "net/ssh"
-require "net/sftp"
-require "uri"
-require "uri/sftp"
-require "digest/md5"
-require "digest/sha1"
-require "facet/progressbar"
-require "highline"
-require "tempfile"
-require "uri/sftp"
+# 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 'cgi'
+require 'net/http'
+require 'net/https'
+require 'net/ssh'
+require 'net/sftp'
+require 'uri'
+require 'uri/sftp'
+require 'digest/md5'
+require 'digest/sha1'
+require 'tempfile'
+require 'buildr/core/progressbar'
 
 
 # Monkeypatching: SFTP never defines the mkdir method on its session or the underlying
@@ -49,11 +64,11 @@ module URI
     # the second form yields to the block with each chunk of content (usually more than one).
     #
     # For example:
-    #   File.open "image.jpg", "w" do |file|
-    #     URI.read("http://example.com/image.jpg") { |chunk| file.write chunk }
+    #   File.open 'image.jpg', 'w' do |file|
+    #     URI.read('http://example.com/image.jpg') { |chunk| file.write chunk }
     #   end
     # Shorter version:
-    #   File.open("image.jpg", "w") { |file| file.write URI.read("http://example.com/image.jpg") }
+    #   File.open('image.jpg', 'w') { |file| file.write URI.read('http://example.com/image.jpg') }
     #
     # Supported options:
     # * :modified -- Only download if file modified since this timestamp. Returns nil if not modified.
@@ -86,11 +101,11 @@ module URI
     # block. Each yield should return up to the specified number of bytes, the last yield returns nil.
     #
     # For example:
-    #   File.open "killer-app.jar", "rb" do |file|
-    #     write("sftp://localhost/jars/killer-app.jar") { |chunk| file.read(chunk) }
+    #   File.open 'killer-app.jar', 'rb' do |file|
+    #     write('sftp://localhost/jars/killer-app.jar') { |chunk| file.read(chunk) }
     #   end
     # Or:
-    #   write "sftp://localhost/jars/killer-app.jar", File.read("killer-app.jar")
+    #   write 'sftp://localhost/jars/killer-app.jar', File.read('killer-app.jar')
     #
     # Supported options:
     # * :progress -- Show the progress bar while reading.
@@ -126,7 +141,7 @@ module URI
     #
     # For options, see URI::read.
     def read(options = nil, &block)
-      fail "This protocol doesn't support reading (yet, how about helping by implementing it?)"
+      fail 'This protocol doesn\'t support reading (yet, how about helping by implementing it?)'
     end
 
     # :call-seq:
@@ -158,7 +173,7 @@ module URI
         read({:progress=>verbose}.merge(options || {}).merge(:modified=>target.mtime)) { |chunk| target.write chunk }
         target.flush
       else
-        raise ArgumentError, "Expecting a target that is either a file name (string, task) or object that responds to write (file, pipe)." unless target.respond_to?(:write)
+        raise ArgumentError, 'Expecting a target that is either a file name (string, task) or object that responds to write (file, pipe).' unless target.respond_to?(:write)
         read({:progress=>verbose}.merge(options || {})) { |chunk| target.write chunk }
         target.flush
       end
@@ -177,7 +192,7 @@ module URI
       options = args.pop if Hash === args.last
       options ||= {}
       if String === args.first
-        ios = StringIO.new(args.first, "r")
+        ios = StringIO.new(args.first, 'r')
         write(options.merge(:size=>args.first.size)) { |bytes| ios.read(bytes) }
       elsif args.first.respond_to?(:read)
         size = args.first.size rescue nil
@@ -185,7 +200,7 @@ module URI
       elsif args.empty? && block
         write_internal options, &block
       else
-        raise ArgumentError, "Either give me the content, or pass me a block, otherwise what would I upload?"
+        raise ArgumentError, 'Either give me the content, or pass me a block, otherwise what would I upload?'
       end
     end
 
@@ -203,14 +218,14 @@ module URI
       source = source.name if Rake::Task === source
       options ||= {}
       if String === source
-        raise NotFoundError, "No source file/directory to upload." unless File.exist?(source)
+        raise NotFoundError, 'No source file/directory to upload.' unless File.exist?(source)
         if File.directory?(source)
           Dir.glob("#{source}/**/*").reject { |file| File.directory?(file) }.each do |file|
-            uri = self + (File.join(self.path, file.sub(source, "")))
+            uri = self + (File.join(self.path, file.sub(source, '')))
             uri.upload file, {:digests=>[]}.merge(options)
           end
         else
-          File.open(source, "rb") { |input| upload input, options }
+          File.open(source, 'rb') { |input| upload input, options }
         end
       elsif source.respond_to?(:read)
         digests = (options[:digests] || [:md5, :sha1]).
@@ -226,14 +241,14 @@ module URI
             (options).merge(:progress=>false)
         end
       else
-        raise ArgumentError, "Expecting source to be a file name (string, task) or any object that responds to read (file, pipe)."
+        raise ArgumentError, 'Expecting source to be a file name (string, task) or any object that responds to read (file, pipe).'
       end
     end
 
   protected
 
     # :call-seq:
-    #   with_progress_bar(enable, file_name, size) { |progress| ... }
+    #   with_progress_bar(show, file_name, size) { |progress| ... }
     #
     # Displays a progress bar while executing the block. The first argument must be true for the
     # progress bar to show (TTY output also required), as a convenient for selectively using the
@@ -243,45 +258,10 @@ 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(enable, file_name, size) #:nodoc:
-      if enable && $stdout.isatty
-        progress_bar = Console::ProgressBar.new(file_name, size)
-        # Extend the progress bar so we can display count/total.
-        class << progress_bar
-          def total()
-            convert_bytes(@total)
-          end
-        end
-        # Squeeze the filename into 30 characters.
-        if file_name.size > 30
-          base, ext = file_name.split(".")
-          truncated = "#{base[0..26-ext.to_s.size]}...#{ext}"
-        else
-          truncated = file_name
-        end
-        progress_bar.format = "#{truncated}: %3d%% %s %s/%s %s"
-        progress_bar.format = "%3d%% %s %s/%s %s"
-        progress_bar.format_arguments = [:percentage, :bar, :bytes, :total, :stat]
-        progress_bar.bar_mark = "."
-
-        begin
-          class << progress_bar
-            def <<(bytes)
-              inc bytes.respond_to?(:size) ? bytes.size : bytes
-            end
-          end
-          yield progress_bar
-        ensure
-          progress_bar.finish
-        end
-      else
-        progress_bar = Object.new
-        class << progress_bar
-          def <<(bytes)
-          end
-        end
-        yield progress_bar
-      end
+    def with_progress_bar(show, file_name, size, &block) #:nodoc:
+      options = { :total=>size, :title=>file_name }
+      options[:hidden] = true unless show
+      ProgressBar.start options, &block
     end
 
     # :call-seq:
@@ -292,13 +272,13 @@ module URI
     def proxy_uri()
       proxy = ENV["#{scheme.upcase}_PROXY"]
       proxy = URI.parse(proxy) if String === proxy
-      excludes = (ENV["NO_PROXY"] || "").split(/\s*,\s*/).compact
+      excludes = ENV['NO_PROXY'].to_s.split(/\s*,\s*/).compact
       excludes = excludes.map { |exclude| exclude =~ /:\d+$/ ? exclude : "#{exclude}:*" }
       return proxy unless excludes.any? { |exclude| File.fnmatch(exclude, "#{host}:#{port}") }
     end
 
     def write_internal(options, &block) #:nodoc:
-      fail "This protocol doesn't support writing (yet, how about helping by implementing it?)"
+      fail 'This protocol doesn\'t support writing (yet, how about helping by implementing it?)'
     end
 
   end
@@ -309,54 +289,54 @@ 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]
 
-      headers = { "If-Modified-Since" => CGI.rfc1123_date(options[:modified].utc) } if options[:modified]
-      result = nil
-      request = lambda do |http|
-        puts "Requesting #{self}"  if Rake.application.options.trace
-        http.request_get(path, headers) do |response|
-          case response
-          when Net::HTTPNotModified
-            # No modification, nothing to do.
-            puts "Not modified since last download" if Rake.application.options.trace
-
-          when Net::HTTPRedirection
-            # Try to download from the new URI, handle relative redirects.
-            puts "Redirected to #{response['Location']}" if Rake.application.options.trace
-            result = (self + URI.parse(response["location"])).read(options, &block)
-
-          when Net::HTTPOK
-            puts "Downloading #{self}" if verbose
-            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
+      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
+
+      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
-
-          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
+          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
-
-      if proxy = proxy_uri
-        proxy = URI.parse(proxy) if String === proxy
-        Net::HTTP.start(host, port, proxy.host, proxy.port, proxy.user, proxy.password) { |http| request[http] }
-      else
-        Net::HTTP.start(host, port) { |http| request[http] }
-      end
-      result
     end
 
   end
@@ -366,7 +346,7 @@ module URI
 
     class << self
       # Caching of passwords, so we only need to ask once.
-      def passwords()
+      def passwords
         @passwords ||= {}
       end
     end
@@ -375,16 +355,16 @@ module URI
 
     def write_internal(options, &block) #:nodoc:
       # SSH options are based on the username/password from the URI.
-      ssh_options = { :port=>port, :username=>user }.merge(options[:ssh_options] || {})
+      ssh_options = { :port=>port, :username=>user, :password=>password }.merge(options[:ssh_options] || {})
       ssh_options[:password] ||= SFTP.passwords[host]
       begin
-        puts "Connecting to #{host}" if Rake.application.options.trace
+        puts "Connecting to #{host}" if Buildr.application.options.trace
         session = Net::SSH.start(host, ssh_options)
         SFTP.passwords[host] = ssh_options[:password]
       rescue Net::SSH::AuthenticationFailed=>ex
         # Only if running with console, prompt for password.
         if !ssh_options[:password] && $stdout.isatty
-          password = HighLine.new.ask("Password for #{host}:") { |q| q.echo = "*" }
+          password = ask("Password for #{host}:") { |q| q.echo = '*' }
           ssh_options[:password] = password
           retry
         end
@@ -392,20 +372,20 @@ module URI
       end
 
       session.sftp.connect do |sftp|
-        puts "connected" if Rake.application.options.trace
+        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 #{@base_path}" if Rake.application.options.trace
-        File.dirname(path).split("/").inject("") do |base, part|
+        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 Rake.application.options.trace
-          sftp.open_handle(path, "w") do |handle|
+        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.
@@ -442,7 +422,7 @@ module URI
         end
       end
       # Sadly, file://something really means file://something/ (something being server)
-      set_path "/" if path.empty?
+      set_path '/' if path.empty?
 
       # On windows, file://c:/something is not a valid URL, but people do it anyway, so if we see a drive-as-host,
       # we'll just be nice enough to fix it. (URI actually strips the colon here)
@@ -455,14 +435,14 @@ module URI
     # See URI::Generic#read
     def read(options = nil, &block)
       options ||= {}
-      raise ArgumentError, "Either you're attempting to read a file from another host (which we don't support), or you used two slashes by mistake, where you should have file:///<path>." unless host.blank?
+      raise ArgumentError, 'Either you\'re attempting to read a file from another host (which we don\'t support), or you used two slashes by mistake, where you should have file:///<path>.' if host
 
       path = real_path
       # TODO: complain about clunky URLs
       raise NotFoundError, "Looking for #{self} and can't find it." unless File.exists?(path)
       raise NotFoundError, "Looking for the file #{self}, and it happens to be a directory." if File.directory?(path)
-      File.open path, "rb" do |input|
-        with_progress_bar options[:progress], path.split("/").last, input.stat.size do |progress|
+      File.open path, 'rb' do |input|
+        with_progress_bar options[:progress], path.split('/').last, input.stat.size do |progress|
           block ? block.call(input.read) : input.read
         end
       end
@@ -482,11 +462,11 @@ module URI
   protected
 
     def write_internal(options, &block) #:nodoc:
-      raise ArgumentError, "Either you're attempting to write a file to another host (which we don't support), or you used two slashes by mistake, where you should have file:///<path>." unless host.blank?
+      raise ArgumentError, 'Either you\'re attempting to write a file to another host (which we don\'t support), or you used two slashes by mistake, where you should have file:///<path>.' if host
       temp = nil
       Tempfile.open File.basename(path) do |temp|
         temp.binmode
-        with_progress_bar options[:progress] && options[:size], path.split("/"), options[:size] || 0 do |progress|
+        with_progress_bar options[:progress] && options[:size], path.split('/'), options[:size] || 0 do |progress|
           while chunk = yield(32 * 4096)
             temp.write chunk
             progress << chunk
@@ -499,7 +479,7 @@ module URI
       end
     end
 
-    @@schemes["FILE"] = FILE
+    @@schemes['FILE'] = FILE
 
   end
 

data/lib/buildr/core/util.rb

@@ -0,0 +1,235 @@
+# 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 'rbconfig'
+require 'pathname'
+
+
+module Buildr
+  
+  module Util
+    extend self
+
+    def java_platform?
+      RUBY_PLATFORM =~ /java/
+    end
+
+    # In order to determine if we are running on a windows OS,
+    # prefer this function instead of using Gem.win_platform?.
+    #
+    # Gem.win_platform? only checks the RUBY_PLATFORM global,
+    # that in some cases like when running on JRuby is not 
+    # succifient for our purpose:
+    #
+    # For JRuby, the value for RUBY_PLATFORM will always be 'java'
+    # That's why this function checks on Config::CONFIG['host_os']
+    def win_os?
+      Config::CONFIG['host_os'] =~ /windows|cygwin|bccwin|cygwin|djgpp|mingw|mswin|wince/i
+    end
+
+    # Runs Ruby with these command line arguments.  The last argument may be a hash,
+    # supporting the following keys:
+    #   :command  -- Runs the specified script (e.g., :command=>'gem')
+    #   :sudo     -- Run as sudo on operating systems that require it.
+    #   :verbose  -- Override Rake's verbose flag.
+    def ruby(*args)
+      options = Hash === args.last ? args.pop : {}
+      cmd = []
+      ruby_bin = File.expand_path(Config::CONFIG['ruby_install_name'], Config::CONFIG['bindir'])
+      if options.delete(:sudo) && !(win_os? || Process.uid == File.stat(ruby_bin).uid)
+        cmd << 'sudo' << '-u' << "##{File.stat(ruby_bin).uid}"
+      end
+      cmd << ruby_bin
+      cmd << '-S' << options.delete(:command) if options[:command]
+      sh *cmd.push(*args.flatten).push(options) do |ok, status|
+        ok or fail "Command failed with status (#{status ? status.exitstatus : 'unknown'}): [#{cmd.join(" ")}]"
+      end
+    end
+
+    # Just like File.expand_path, but for windows systems it
+    # capitalizes the drive name and ensures backslashes are used
+    def normalize_path(path, *dirs)
+      path = File.expand_path(path, *dirs)
+      if win_os?
+        path.gsub!('/', '\\').gsub!(/^[a-zA-Z]+:/) { |s| s.upcase }
+      else
+        path
+      end
+    end
+    
+    # Return the timestamp of file, without having to create a file task
+    def timestamp(file)
+      if File.exist?(file)
+        File.mtime(file)
+      else
+        Rake::EARLY
+      end
+    end
+
+    # Return the path to the first argument, starting from the path provided by the
+    # second argument.
+    #
+    # For example:
+    #   relative_path('foo/bar', 'foo')
+    #   => 'bar'
+    #   relative_path('foo/bar', 'baz')
+    #   => '../foo/bar'
+    #   relative_path('foo/bar')
+    #   => 'foo/bar'
+    #   relative_path('/foo/bar', 'baz')
+    #   => '/foo/bar'
+    def relative_path(to, from = '.')
+      to = Pathname.new(to).cleanpath
+      return to.to_s if from.nil?
+      to_path = Pathname.new(File.expand_path(to.to_s, "/"))
+      from_path = Pathname.new(File.expand_path(from.to_s, "/"))
+      to_path.relative_path_from(from_path).to_s
+    end
+
+    # Generally speaking, it's not a good idea to operate on dot files (files starting with dot).
+    # These are considered invisible files (.svn, .hg, .irbrc, etc).  Dir.glob/FileList ignore them
+    # on purpose.  There are few cases where we do have to work with them (filter, zip), a better
+    # solution is welcome, maybe being more explicit with include.  For now, this will do.
+    def recursive_with_dot_files(*dirs)
+      FileList[dirs.map { |dir| File.join(dir, '/**/{*,.*}') }].reject { |file| File.basename(file) =~ /^[.]{1,2}$/ }
+    end
+
+  end
+end
+
+
+module Kernel #:nodoc:
+  # Borrowed from Ruby 1.9.
+  def tap
+    yield self if block_given?
+    self
+  end unless method_defined?('tap')
+end
+
+
+class Symbol #:nodoc:
+  # Borrowed from Ruby 1.9.
+  def to_proc
+    Proc.new{|*args| args.shift.__send__(self, *args)}
+  end unless method_defined?('to_proc')
+end
+
+
+# Also borrowed from Ruby 1.9.
+class BasicObject #:nodoc:
+  (instance_methods - ['__send__', '__id__', '==', 'send', 'send!', 'respond_to?', 'equal?', 'object_id']).
+    each do |method|
+      undef_method method
+    end
+
+  def self.ancestors
+    [Kernel]
+  end
+end
+
+
+class OpenObject < Hash
+
+  def initialize(source=nil, &block)
+    @hash = Hash.new(&block)
+    @hash.update(source) if source
+  end
+
+  def [](key)
+    @hash[key]
+  end
+
+  def []=(key, value)
+    @hash[key] = value
+  end
+
+  def delete(key)
+    @hash.delete(key)
+  end
+
+  def to_hash
+    @hash.clone
+  end
+
+  def method_missing(symbol, *args)
+    if symbol.to_s =~ /=$/
+      self[symbol.to_s[0..-2].to_sym] = args.first
+    else
+      self[symbol]
+    end
+  end
+end
+
+
+class Hash
+
+  class << self
+
+    # :call-seq:
+    #   Hash.from_java_properties(string)
+    #
+    # Returns a hash from a string in the Java properties file format. For example:
+    #   str = 'foo=bar\nbaz=fab'
+    #   Hash.from_properties(str)
+    #   => { 'foo'=>'bar', 'baz'=>'fab' }.to_properties
+    def from_java_properties(string)
+      string.gsub(/\\\n/, '').split("\n").select { |line| line =~ /^[^#].*=.*/ }.
+        map { |line| line.gsub(/\\[trnf\\]/) { |escaped| {?t=>"\t", ?r=>"\r", ?n=>"\n", ?f=>"\f", ?\\=>"\\"}[escaped[1]] } }.
+        map { |line| line.split('=') }.
+        inject({}) { |hash, (name, value)| hash.merge(name=>value) }
+    end
+
+  end
+
+  # :call-seq:
+  #   only(keys*) => hash
+  #
+  # Returns a new hash with only the specified keys.
+  #
+  # For example:
+  #   { :a=>1, :b=>2, :c=>3, :d=>4 }.only(:a, :c)
+  #   => { :a=>1, :c=>3 }
+  def only(*keys)
+    keys.inject({}) { |hash, key| has_key?(key) ? hash.merge(key=>self[key]) : hash }
+  end
+
+
+  # :call-seq:
+  #   except(keys*) => hash
+  #
+  # Returns a new hash without the specified keys.
+  #
+  # For example:
+  #   { :a=>1, :b=>2, :c=>3, :d=>4 }.except(:a, :c)
+  #   => { :b=>2, :d=>4 }
+  def except(*keys)
+    (self.keys - keys).inject({}) { |hash, key| hash.merge(key=>self[key]) }
+  end
+
+  # :call-seq:
+  #   to_java_properties => string
+  #
+  # Convert hash to string format used for Java properties file. For example:
+  #   { 'foo'=>'bar', 'baz'=>'fab' }.to_properties
+  #   => foo=bar
+  #      baz=fab
+  def to_java_properties
+    keys.sort.map { |key|
+      value = self[key].gsub(/[\t\r\n\f\\]/) { |escape| "\\" + {"\t"=>"t", "\r"=>"r", "\n"=>"n", "\f"=>"f", "\\"=>"\\"}[escape] }
+      "#{key}=#{value}"
+    }.join("\n")
+  end
+
+end