davclient 0.0.3

data/README.rdoc

@@ -0,0 +1,76 @@
+= DavClient
+
+* http://davclient.rubyforge.org
+* http://rubyforge.org/mailman/listinfo/davclient-general
+
+== DESCRIPTION:
+
+WebDAV command line client written in Ruby for managing content on
+webservers that support the WebDAV extensions.
+
+== Requirements
+
+The command line utility curl installed and available in your unix path.
+
+== LIRBRARY SYNOPSIS:
+
+  require 'rubygems'
+  require 'davclient'
+
+  # Print url of all files in webdav folder recursively
+  # with basic tree walking
+
+  url = 'http://test.webdav.org/dav/'
+  WebDAV.find(url, :recursive => true) do |item|
+    puts item.href
+  end
+
+== COMMAND LINE UTILITIES:
+
+DavClient includes the command line utility 'dav'. It is inspired by git and should be familiar to unix users.
+The command 'dav cd url' sets current working url, 'dav ls' list files and 'dav pwd'
+prints current working url. , users can access files, folders and their properties on webdav servers.
+
+The only authentication method supported at the moment, is by reading usernames and passwords from
+a file named ~/.netrc. If username is missing, the 'dav' command will print out detailed instructions
+on how to add username etc. to the '~/.netrc' file.
+
+== COMMAND LINE SYNOPSIS:
+
+  >dav cd http://test.webdav.org/dav/
+  http://test.webdav.org/dav/
+  >dav ls
+  images/
+  index.html
+  >dav pwd
+  http://test.webdav.org/dav/
+
+== INSTALL:
+
+  [sudo] gem install davclient
+
+or
+
+  git clone git://github.com/thomasfl/davclient.git
+  cd davclient
+  gem build Rakefile
+  sudo gem install davclient-x.x.x.gem
+
+Curl comes preinstalled on Mac OS X. It can be downloaded from
+http://curl.haxx.se/ . If you are using debian or ubuntu, it
+can be installed by:
+
+  sudo apt-get install curl
+
+== Background:
+
+There has been posted a few examples on the web of how to make a WebDAV client.
+The problem is that they all seem to support only one type of username and password
+authentication. DavClient instead uses the command line tool 'curl' to do all the
+authentication and networking. To avoid handling authentication all togheter, curl
+are told to look up all usernames and passwords are in a file named ~/.netrc.
+
+The command 'dav' is  non-interactive and inspired by git, making it suitable for
+use in scripts. If you can script in Ruby, the examples folder includes sample
+scripts using the davclient Ruby library.
+

data/bin/dav

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'davclient'
+require 'davclient/davcli'
+
+DavCLI.dav(ARGV)

data/lib/davclient/curl_commands.rb

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+
+def remove_newlines(string)
+  string.gsub("\n","").gsub(/ +/," ") + " "
+end
+
+# Templates for curl commands:
+curl_propfind_cmd = <<EOF
+#{$curl}
+  --request PROPFIND
+  --header 'Content-Type: text/xml; charset="utf-8"'
+  --header "Depth: 1"
+  --data-ascii '<?xml version="1.0" encoding="utf-8"?>
+      <DAV:propfind xmlns:DAV="DAV:"><DAV:allprop/></DAV:propfind>'
+  --netrc
+EOF
+CURL_PROPFIND = remove_newlines(curl_propfind_cmd)
+
+curl_proppatch_cmd = <<EOF
+#{$curl}
+  --request PROPPATCH
+  --header 'Content-Type: text/xml; charset="utf-8"'
+  --header "Depth: 1"
+  --data-ascii '<?xml version="1.0"?>
+      <d:propertyupdate xmlns:d="DAV:" xmlns:v="vrtx">
+        <d:set>
+          <d:prop>
+            <!--property-and-value-->
+          </d:prop>
+        </d:set>
+      </d:propertyupdate>'
+  --netrc
+EOF
+CURL_PROPPATCH = remove_newlines(curl_proppatch_cmd)
+
+curl_delete_cmd = <<EOF
+#{$curl}
+  --request DELETE
+  --header 'Content-Type: text/xml; charset="utf-8"'
+  --netrc
+EOF
+CURL_DELETE = remove_newlines(curl_delete_cmd)
+
+curl_mkcol_cmd = <<EOF
+#{$curl}
+  --request MKCOL
+  --header 'Content-Type: text/xml; charset="utf-8"'
+  --netrc
+EOF
+CURL_MKCOL = remove_newlines(curl_mkcol_cmd)
+
+CURL_OPTIONS = "#{$curl} -i -X OPTIONS --netrc "
+
+curl_copy = <<EOF
+#{$curl}
+  --request COPY
+  --header 'Content-Type: text/xml; charset="utf-8"'
+  --header 'Destination: <!--destination-->'
+  --netrc
+EOF
+
+CURL_COPY  = remove_newlines(curl_copy)
+
+
+curl_move = <<EOF
+#{$curl}
+  --request MOVE
+  --header 'Content-Type: text/xml; charset="utf-8"'
+  --header 'Destination: <!--destination-->'
+  --netrc
+EOF
+
+CURL_MOVE  = remove_newlines(curl_move)

data/lib/davclient/dav-ls.rb

@@ -0,0 +1,88 @@
+# WebDav ls command line utility
+# Synopsis:
+#       dav ls [options][url]
+#
+# or standalone:
+#
+#     ruby dav-ls  [options][url]
+
+require 'rubygems'
+require 'davclient'
+require 'optparse'
+
+class LsCLI
+
+  def self.ls(args)
+    options = read_options(args)
+    url = args[0]
+    tmp_cwurl = WebDAV.CWURL
+    if(not url)then
+      url = WebDAV.CWURL
+      if(not url)then
+        puts "#{$0} ls: no current working url"
+        puts "Usage: Use '#{$0} cd [url|dir] to set current working url"
+        exit
+      end
+    else
+      WebDAV.cd(url)
+    end
+
+    url = WebDAV.CWURL
+    WebDAV.find(url, :recursive => false ) do |item|
+      if(options[:showUrl])then
+        puts item.href
+      elsif(options[:longFormat])
+
+      else
+        print item.basename
+        print "/" if item.isCollection?
+        puts
+      end
+    end
+
+    # Restore CWURL
+    WebDAV.cd(tmp_cwurl)
+  end
+
+  private
+
+  def self.read_options(args)
+    options = {}
+
+    optparse = OptionParser.new do|opts|
+      opts.banner = "Usage: #{$0} ls [options] url"
+
+      opts.on( '-h', '--help', 'Display this screen' ) do
+        puts opts
+        exit
+      end
+
+      options[:longFormat] = false
+      opts.on( '-l', "List in long format" ) do
+        options[:longFormat] = true
+      end
+
+      options[:showUrl] = false
+      opts.on('-a', "Include full url in names.") do
+        options[:showUrl] = true
+      end
+
+    end
+
+    begin
+      optparse.parse! args
+    rescue
+      puts "Error: " + $!
+      puts optparse
+      exit
+    end
+
+    return options
+  end
+
+end
+
+# Make this file an executable script
+if $0 == __FILE__
+  LsCLI.ls(ARGV)
+end

data/lib/davclient/dav-propfind.rb

@@ -0,0 +1,92 @@
+# Handle 'dav propfind [URL]' command
+require 'rubygems'
+require 'davclient'
+require 'optparse'
+
+class PropfindCLI
+
+  def self.propfind(args)
+    options = read_options(args)
+
+    url = args[0]
+    if(not(url)) then
+      url = WebDAV.CWURL
+    end
+
+    if(not(url)) then
+      puts "Error: Missing mandatory url"
+      puts optparse
+      exit
+    end
+
+    if(options[:xml])then
+      puts WebDAV.propfind(url, :xml => true)
+    else
+
+      # TODO This is experimental code in desperat need
+      # of love and attention
+      item = WebDAV.propfind(url)
+      puts item.collection
+
+      prev_url = nil
+      WebDAV.find(url, :children => options[:children]) do | url, item |
+        if(prev_url != url) then
+          puts
+          puts "url = " + url.to_s
+          prev_url = url
+        end
+
+        name = item.prefix
+        if(item.namespace)then
+          name = name + "(" + item.namespace + ")"
+        end
+        name = name + item.name
+        puts name.ljust(40) + " = '" + item.text.to_s + "'"
+      end
+
+    end
+
+  end
+
+  private
+
+  def self.read_options(args)
+    options = {}
+
+    title = nil
+    optparse = OptionParser.new do|opts|
+      opts.banner = "Usage: #{$0} propfind [options] url"
+
+      opts.on( '-h', '--help', 'Display this screen' ) do
+        puts opts
+        exit
+      end
+
+      options[:xml] = true
+      opts.on( '-p', '--pretty', "Pretty print output instead of returning xml" ) do
+        options[:xml] = false
+      end
+
+      options[:children] = false
+      opts.on('-c', '--children', "Show children if viewing collection (folder)") do
+        options[:children] = true
+      end
+
+    end
+
+    begin
+      optparse.parse!
+    rescue
+      puts "Error: " + $!
+      puts optparse
+      exit
+    end
+
+    return options
+  end
+
+end
+
+if $0 == __FILE__
+  PropfindCLI.propfind(ARGV)
+end

data/lib/davclient/dav-put.rb

@@ -0,0 +1,71 @@
+# WebDav put command line utility
+# Synopsis:
+#       dav put [options][url]
+#
+# or standalone:
+#
+#     ruby dav-ls  [options][url]
+
+require 'rubygems'
+require 'davclient'
+require 'optparse'
+
+class PutCLI
+
+  def self.put(args)
+    options = read_options(args)
+    url = args[0]
+    if(options[:string])then
+      begin
+        WebDAV.put_string(url,options[:string])
+      rescue
+        puts $0 + ": " + $!
+      end
+      puts "Published content to " + url
+    else
+      puts "PUT file not implemented"
+    end
+
+  end
+
+  private
+
+  def self.usage()
+    puts "Usage: #{$0} put --string \"<html>..</html>\" url"
+  end
+
+  def self.read_options(args)
+    options = {}
+
+    optparse = OptionParser.new do|opts|
+      opts.banner = "Usage: #{$0} put [options] url"
+
+      opts.on( '-h', '--help', 'Display this screen' ) do
+        puts opts
+        exit
+      end
+
+      options[:string] = false
+      opts.on( '-s', '--string', "Put contents of string" ) do |str |
+        options[:string] = str
+      end
+
+    end
+
+    begin
+      optparse.parse! args
+    rescue
+      puts "Error: " + $!
+      puts optparse
+      exit
+    end
+
+    return options
+  end
+
+end
+
+# Make this file an executable script
+if $0 == __FILE__
+  PutCLI.put(ARGV)
+end

data/lib/davclient/davcli.rb

@@ -0,0 +1,166 @@
+require 'davclient/dav-ls'
+require 'davclient/dav-put'
+require 'davclient/dav-propfind'
+
+# Handle the 'dav' command line commands
+
+class DavCLI
+
+  def self.cat(args)
+    if(args.size == 1)
+      url = args[0]
+      puts WebDAV.get(url)
+    else
+      puts "Illegal arguments: " + args[1..100].join(" ")
+      puts "#{$0}: usage '#{$0} cat [url|filename]"
+    end
+  end
+
+  def self.pwd(args)
+    cwurl = WebDAV.CWURL
+    if(cwurl)
+      puts cwurl
+    else
+      puts "#{$0}: No working url set. Use 'dav cd url' to set url"
+    end
+
+  end
+
+  def self.cd(args)
+    url = args[0]
+    if(url == nil)then
+      puts "#{$0} cd: Missing mandatory url."
+      exit
+    end
+    begin
+      WebDAV.cd(url)
+      puts "Changing WebDAV URL to: " + WebDAV.CWURL
+    rescue Exception => exception
+      puts exception
+    end
+  end
+
+  def self.mkcol(args)
+    if(args.size == 1 )
+      WebDAV.mkcol(args[0])
+    else
+      puts "#{$0}: usage '#{$0} mkcol url|path"
+    end
+  end
+
+  def self.delete(args)
+    if(args.size == 1)
+      url = WebDAV.delete(args[0])
+      puts "#{$0} delete: Deleted '#{url}'"
+    else
+      puts "#{$0}: usage '#{$0} delete url|path"
+    end
+  end
+
+  def self.options(args)
+    if(args.size == 0 or args.size == 1)
+      puts WebDAV.options(args[0])
+    else
+      puts "#{$0}: usage '#{$0} options [url]"
+    end
+  end
+
+  def self.propfind(args)
+    PropfindCLI.propfind(args)
+  end
+
+  def self.ls(args)
+    LsCLI.ls(args)
+  end
+
+  def self.cp(args)
+    if(args.size == 2 )
+      WebDAV.cp(args[0], args[1])
+    else
+      puts "#{$0}: usage '#{$0} cp src dest"
+    end
+  end
+
+
+  def self.mv(args)
+    if(args.size == 2 )
+      WebDAV.mv(args[0], args[1])
+    else
+      puts "#{$0}: usage '#{$0} copy mv dest"
+    end
+  end
+
+  def self.print_dav_usage
+    puts "usage: #{$0} COMMAND [ARGS]"
+    puts ""
+    puts "Available #{$0} commands:"
+    puts "   ls        List files on webdav server"
+    puts "   pwd       Print current working url"
+    puts "   cd        Change current working url"
+    puts "   cp        Copy resource"
+    puts "   mv        Move resource"
+    puts "   rm        Remove resource"
+    puts "   cat       Print content of resource"
+    puts "   propfind  Print webdav properties for url"
+    puts "   mkcol     Make collection"
+    puts "   options   Display webservers WebDAV options"
+    puts ""
+    puts "See '#{$0} COMMAND -h' for more information on a specific command."
+    exit
+  end
+
+  def self.dav(args)
+    command =  args[0]
+
+    if(command == "-h" or command =~ /help/ or command =~ /\?/) then
+      print_dav_usage
+    end
+
+    if(command == "-v" or command =~ /version/ ) then
+      puts "#{$0} version " + WebDAV.version
+      exit
+    end
+
+    args = args[1..100]
+    case command
+      when "cat" then
+        cat(args)
+      when "ls" then
+        LsCLI.ls(args)
+      when "pwd"
+        pwd(args)
+      when "cd"
+        cd(args)
+      when "cp"
+        cp(args)
+      when "copy"
+        cp(args)
+      when "mv"
+        mv(args)
+      when "move"
+        mv(args)
+      when "mkcol"
+         mkcol(args)
+      when "mkdir"
+         mkcol(args)
+      when "put"
+         PutCLI.put(args)
+      when "delete"
+        delete(args)
+      when "del"
+        delete(args)
+      when "rm"
+        delete(args)
+      when "propfind"
+        propfind(args)
+      when "props"
+        propfind(args)
+      when "options"
+        options(args)
+      else
+        puts "Unknown command :'" + command + "'"
+        print_dav_usage
+      end
+  end
+
+end

data/lib/davclient/hpricot_extensions.rb

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+
+require 'rubygems'
+require 'hpricot'
+
+# Extensions to the Hpricot XML parser.
+module Hpricot
+
+
+
+  class Elem
+
+    # Makes properties available as simple method calls.
+    #
+    # Example:
+    #    print item.creationdate()
+    def method_missing(method_name, *args)
+      if(args.size == 0) then
+        return property(method_name.to_s)
+      end
+      raise "Method missing"
+    end
+
+    # Resource url
+    def href()
+      self.at("d:href").innerText
+    end
+
+    # Returns true of resource is a collection, i.e. a folder and not a file.
+    def isCollection?()
+      self.at("d:collection") != nil
+    end
+
+  end
+
+  # TODO Not used. Delete???
+  def type_convert_value(value)
+    if(returnValue == "true")then
+      return true
+    end
+    if(returnValue == "false")then
+      return false
+    end
+    # Number format???
+    ## Dato format
+    return returnValue
+  end
+
+  # TODO: Make list of recognized namespace prefixes configurable
+  # Get property.
+  # Example:
+  #    page = WebDAV.find(url)
+  #    print page.property("published-date")
+  def property(name)
+
+    property = property = self.at(name)
+    if(property)then
+      returnValue = property.innerText
+      return returnValue
+    end
+
+    property = property = self.at(name.downcase)
+    if(property)then
+      return property.innerText
+    end
+
+    vrtx_property = self.at("v:" + name)
+    if(vrtx_property)then
+      return vrtx_property.innerText
+    end
+
+    vrtx_property = self.at("v:" + name.downcase)
+    if(vrtx_property)then
+      return vrtx_property.innerText
+    end
+
+    dav_property = self.at("d:" +name)
+    if( dav_property)then
+      return dav_property.innerText
+    end
+
+    dav_property = self.at("d:" +name.downcase)
+    if( dav_property)then
+      return dav_property.innerText
+    end
+
+    return nil
+  end
+
+  def basename
+    File.basename(self.at("d:href").innerText)
+  end
+
+  # TODO: Move to vortex_lib.rb
+  def dateProperty(name)
+    date = self.property(name)
+    if(date =~ /\dZ$/)then
+      # Fix for bug in vortex:
+      #
+      # Some date properties are in xmlshcema datetime format, but
+      # all tough the time seems to be localtime the timezone is
+      # specified as Z not CEST. Fix is to set timezone and add
+      # 2 hours.
+      date = date.gsub(/\dZ$/," CEST")
+      time = Time.parse(date)
+      time = time + (60 * 60 * 2)
+      return time
+    end
+    time = Time.parse(date)
+    return time
+  end
+
+  # Set the items WebDAV properties. Properties must be a string with XML.
+  def proppatch(properties)
+    WebDAV.proppatch(href, properties)
+  end
+
+end

data/lib/davclient.rb

@@ -0,0 +1,451 @@
+# -*- coding: utf-8 -*-
+
+require 'hpricot'
+require 'tempfile'
+require 'open3'
+require 'pathname'
+require 'davclient/hpricot_extensions'
+
+# :stopdoc:
+
+# Path to curl executable:
+$curl = "curl"
+
+require 'davclient/curl_commands'
+
+# :startdoc:
+
+# WebDAV client
+module WebDAV
+
+  # :stopdoc:
+  VERSION = '0.0.5'
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns current working url. Used by command line utilites
+  def self.CWURL
+    return $CWURL if($CWURL) # Used by tests
+    cwurl = nil
+    filename = cwurl_filename
+    if(File.exists?(filename))
+      File.open(filename, 'r') {|f| cwurl = f.read() }
+    end
+    return cwurl
+  end
+
+  # Make relative url absolute. Returns error if no current working
+  # url has been set.
+  #
+  # Example:
+  #
+  #   WebDAV.cd("https://example.org/subfolder")
+  #   print WebDAV.absoluteUrl("..")  => "https://example.org/"
+  def self.absoluteUrl(url)
+    if(not(url =~ /^http.?:\/\//))then
+      cwurl = Pathname.new(self.CWURL)
+      cwurl = cwurl + url
+      url = cwurl.to_s
+      # url = url + "/" if(not(url =~ /\/$/))
+
+      if(not(url =~ /^http.?:\/\//))then
+        warn "#{$0}: Error: illegal url: " + url
+        exit
+      end
+    end
+    return url
+  end
+
+  # Change current working url. Takes relative pathnames.
+  #
+  # Examples:
+  #
+  #   WebDAV.cd("http://www.example.org")
+  #
+  #   WebDAV.cd("../folder")
+  def self.cd(url)
+    url = absoluteUrl(url)
+    url = url + "/" if(not(url =~ /\/$/))
+
+    resource = WebDAV.propfind(url)
+    if(resource and resource.isCollection?)then
+      WebDAV.CWURL = url
+    else
+      # TODO Make proper exception
+      raise Exception, "cd: URL '#{cwurl} is not a WebDAV collection."
+    end
+  end
+
+  # Sets current working url by storing url in a tempfile with parent process pid
+  # as part of the filename.
+  def self.CWURL=(url)
+    $CWURL = url # Used by tests
+    File.open(cwurl_filename, 'w') {|f| f.write(url) }
+  end
+
+  # Get content of resource as string
+  #
+  # Example:
+  #
+  #    html = WebDAV.get(url)
+  #
+  #    html = WebDAV.get("file_in_current_working_folder.html")
+  def self.get(url)
+    url = absoluteUrl(url)
+
+    curl_command = "#{$curl} --netrc " + url
+    return exec_curl(curl_command)
+  end
+
+  # Set WebDAV properties for url as xml.
+  #
+  # Example:
+  #
+  #   WebDAV.proppatch("https://dav.webdav.org/folder","<contentLastModified>2007-12-12 12:00:00 GMT</contentLastModified>
+  def self.proppatch(href, property)
+    curl_command = CURL_PROPPATCH + " \""+href+"\""
+    curl_command = curl_command.gsub("<!--property-and-value-->",property)
+    response = exec_curl(curl_command)
+    if(not(response =~ /200 OK/)) then
+      puts "Error:\nRequest:\n" + curl_command + "\n\nResponse: " + response
+      exit(0)
+    end
+  end
+
+  # Get WebDAV properties
+  #
+  # Examples:
+  #   item = propfind(url)                - Returns a Hpricot::Elem object
+  #
+  #   xml = propfind(url, :xml => true)   - Returns xml for debugging.
+  def self.propfind(*args)
+    url = args[0]
+    url = absoluteUrl(url)
+    options = args[1]
+
+    curl_command = CURL_PROPFIND + " \"" + url + "\""
+    response = exec_curl(curl_command)
+
+    if(response == "")then
+      return nil
+    end
+
+    if(not(response =~ /200 OK/)) then
+      puts "Error:\nRequest:\n" + curl_command + "\n\nResponse: " + response
+      exit(0)
+    end
+
+    if(options and options[:xml])then
+      return response
+    end
+    doc = Hpricot( response )
+    items_filtered = Array.new()
+    items = doc.search("//d:response").reverse
+    items.each do |item|
+
+      # Only return root item if folder
+      if(item.href == url or item.href == url + "/" ) then
+        return item
+      end
+    end
+    return nil
+  end
+
+  # Find files and folders.
+  #
+  # Examples:
+  #
+  #  result = find( url )
+  #
+  #  result = find( url, :type => "collection" ,:recursive => true)
+  #
+  # You can also pass a block of code:
+  #
+  #  find( url, :type => "collection" ,:recursive => true) do |folder|
+  #    puts folder.href
+  #  end
+  #
+  def self.find(*args, &block)
+    href = args[0]
+    options = args[1]
+    type = nil
+    recursive = false
+    if(options)then
+
+      if(options[:type])then
+        type = options[:type]
+      end
+      if(options[:recursive])then
+        recursive = options[:recursive]
+      end
+    end
+    dav_xml_output = propfind(href, :xml => true)
+    if(not(dav_xml_output))then
+      return nil
+    end
+
+    doc = Hpricot( dav_xml_output )
+    items_filtered = Array.new()
+    items = doc.search("//d:response").reverse
+
+    # filter items
+    items.each do |item|
+
+      # Ignore info about root item (file or folder)
+      if(item.href != href) then
+
+        if(type == nil)then
+          # No filters
+          items_filtered.push(item)
+          if(block) then
+            yield item
+          end
+
+        else
+          # Filter result set
+          if((type == "collection" or type == "folder") and item.collection )then
+            items_filtered.push(item)
+            if(block) then
+              yield item
+            end
+          end
+          if(type == "file" and item.collection == false )then
+            items_filtered.push(item)
+            if(block) then
+              yield item
+            end
+          end
+        end
+
+      end
+    end
+
+    if(recursive)then
+      items_filtered.each do |item|
+        if(item.collection && item.href != args[0])then
+          result = find(item.href, args[1], &block)
+          if(result != nil)
+            items_filtered.concat( result)
+          end
+        end
+      end
+    end
+
+    return items_filtered
+  end
+
+  # Make collection
+  # Accepts relative url's
+  def self.mkcol(*args) # url, props)
+    url = args[0]
+    props = args[3]
+    url = absoluteUrl(url)
+    curl_command = CURL_MKCOL + " " + url
+    response = exec_curl(curl_command)
+
+    if(props)then
+      proppatch(url,props)
+    end
+    if(response =~ />Created</)then
+      return true
+    end
+    return response
+  end
+
+  # Returns true if resource exists
+  def self.exists?(url)
+    url = absoluteUrl(url)
+    props = WebDAV.propfind(url)
+    if(props.to_s.size == 0)then
+      return false
+    else
+      return true
+    end
+  end
+
+  # Copy resources
+  #
+  # Examples:
+  #
+  #     WebDAV.cp("src.html","https://example.org/destination/destination.html"
+  def self.cp(src,dest)
+    srcUrl = absoluteUrl(src)
+    destUrl = absoluteUrl(dest)
+
+    # puts "DEBUG: " + srcUrl + " => " + destUrl
+    curl_command = CURL_COPY.sub("<!--destination-->", destUrl) + " " + srcUrl
+    response = exec_curl(curl_command)
+
+    if(response  == "")then
+      return destUrl
+    end
+    return false
+  end
+
+
+  # Move resources
+  #
+  # Examples:
+  #
+  #     WebDAV.mv("src.html","https://example.org/destination/destination.html"
+  def self.mv(src,dest)
+    srcUrl = absoluteUrl(src)
+    destUrl = absoluteUrl(dest)
+
+    # puts "DEBUG: " + srcUrl + " => " + destUrl
+    curl_command = CURL_MOVE.sub("<!--destination-->", destUrl) + " " + srcUrl
+    response = exec_curl(curl_command)
+
+    if(response  == "")then
+      return destUrl
+    end
+    return false
+  end
+
+
+  # Delete resource
+  #
+  # Examples:
+  #
+  #   WebDAV.cd("https://example.org/folder")
+  #   WebDAV.mkcol("subfolder")
+  #   WebDAV.delete("subfolder")
+  def self.delete(url)
+
+    url = absoluteUrl(url)
+
+    curl_command = CURL_DELETE + url
+    response = exec_curl(curl_command)
+
+    if(response  == "")then
+      return url
+    end
+    if(not(response =~ /200 OK/)) then
+      puts "Error:\nRequest:\n" + curl_command + "\n\nResponse: " + response
+      return false
+    end
+    return url
+  end
+
+
+  # Low level WebDAV publish
+  #
+  # Example:
+  #
+  #   WebDAV.publish("https://dav.example.org/index.html","<h1>Hello</h1>",nil)
+  def self.publish(url, string, props)
+    self.put_string(url, string)
+    if(props)then
+      self.proppatch(url,props)
+    end
+  end
+
+
+  # Puts content of string to file on server with url
+  #
+  # Example:
+  #
+  #   WebDAV.put("https://dav.webdav.org/file.html", "<html><h1>Test</h1></html>"
+  def self.put_string(url, html)
+    url = absoluteUrl(url)
+
+    if(url =~ /\/$/)then
+      raise "Error: WebDAV.put_html: url can not be a collection (folder)."
+    end
+
+    tmp_dir = "/tmp/" + rand.to_s[2..10] + "/"
+    FileUtils.mkdir_p tmp_dir
+    tmp_file = tmp_dir + "webdav.tmp"
+    File.open(tmp_file, 'w') {|f| f.write(html) }
+
+    curl_command = "#{$curl} --netrc --silent --upload-file #{tmp_file} #{url}"
+    response = exec_curl(curl_command)
+    if(response != "" and not(response =~ /200 OK/)) then
+      raise "Error:\n WebDAV.put: WebDAV Request:\n" + curl_command + "\n\nResponse: " + response
+    end
+  end
+
+  # Returns a string with the webservers WebDAV options (PUT, PROPFIND, etc.)
+  def self.options(url)
+    if(not(url))
+      url = self.CWURL
+    end
+    return self.exec_curl(CURL_OPTIONS + url )
+  end
+
+  # :stopdoc:
+
+  # TODO put file utility
+  # TESTME
+  def put_file(filename, href)
+    # TODO Detect if href is a collection or not??
+    curl_command = "#{$curl} --netrc --request PUT #{filename} #{href}"
+    return exec_curl(curl_command)
+    # return execute_curl_cmd(curl_put_cmd)
+  end
+  # :startdoc:
+
+  private
+
+  # Returns filename /tmp/cwurl.#pid that holds the current working directory
+  # for the shell's pid
+  def self.cwurl_filename
+    tmp_file = Tempfile.new("dummy").path
+    basename = File.basename(tmp_file)
+    tmp_folder = tmp_file.gsub(basename, "")
+    return tmp_folder +  "cwurl." + Process.ppid.to_s
+  end
+
+  # Display instructions for adding credentials to .netrc file
+  def self.display_unauthorized_message(href)
+    puts "Error: 401 Unauthorized: " + href
+    href.match(/^http.*\/\/([^\/]*)/)
+    puts "\nTry adding the following to your ~/.netrc file:"
+    puts ""
+    puts "machine #{$1}"
+    puts "  login    " + ENV['USER']
+    puts "  password ********"
+    puts ""
+  end
+
+
+  # Run 'curl' as a subprocess
+  def self.exec_curl(curl_command)
+    response = ""
+
+    puts curl_command if($DEBUG)
+
+    Open3.popen3(curl_command) do |stdin, stdout, stderr|
+
+      response = stdout.readlines.join("")
+
+      if(response == "")
+        stderr = stderr.readlines.join("").sub(/^\W/,"")
+        if(stderr  =~ /command/)
+          puts "Error: " + stderr
+          exit
+        end
+        if(stderr  =~ /^curl:/)
+          puts "Error: " + stderr
+          puts
+          puts curl_command
+          puts
+          exit
+        end
+      end
+    end
+    if(response =~ /401 Unauthorized/)then
+      href = curl_command.match( /"(http[^\"]*)"$/ )[0].gsub(/"/,"")
+      self.display_unauthorized_message(href)
+      exit
+    end
+    return response
+  end
+
+
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: davclient
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+platform: ruby
+authors: 
+- Thomas Flemming
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-10 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.6"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: zentest
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "3.5"
+    version: 
+description: WebDAV command line client written in Ruby for managing content on webservers that support the WebDAV extensions.
+email: thomasfl@usit.uio.no
+executables: 
+- dav
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- lib/davclient.rb
+- lib/davclient/hpricot_extensions.rb
+- lib/davclient/curl_commands.rb
+- bin/dav
+- lib/davclient/davcli.rb
+- lib/davclient/dav-put.rb
+- lib/davclient/dav-ls.rb
+- lib/davclient/dav-propfind.rb
+- README.rdoc
+has_rdoc: true
+homepage: http://folk.uio.no/thomasfl
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: 
+- cURL command line tool available from http://curl.haxx.se/
+- Servername, username and password must be supplied in ~/.netrc file.
+rubyforge_project: davclient
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Command line WebDAV client and Ruby library.
+test_files: []
+