webdavtools 0.0.1

data/README.rdoc

@@ -0,0 +1,57 @@
+= WebDAVTools
+
+* http://webdavtools.rubyforge.org
+* http://rubyforge.org/mailman/listinfo/webdavtools-general
+
+== DESCRIPTION:
+
+WebDAVTools is a Ruby library for creating scripts to administrate content
+and properties on servers that supports the WebDAV protocol. It can be used
+to publish content to CMS systems like Plone and Content repositories like
+Apache JackRabbit, that support the WebDAV protocol.
+
+== Requirements
+
+Unix and the command line utility curl installed.
+
+== LIRBRARY SYNOPSIS:
+
+  require 'rubygems'
+  require 'webdavtools'
+
+  # Basic recursive tree walking
+  url = 'http://test.webdav.org/dav/'
+  WebDAV.find(url, :recursive => true) do |item|
+    puts item.href
+  end
+
+== COMMAND LINE UTILITES:
+
+WebDAVTools includes a small set of command line utilities, that should be familiar to unix users.
+By using commands like wdcd to set current working url, wdls to list files and wdpwd to print
+current working url, users can access files and folders on webdav servers. At the moment
+only authentication by adding usernames and passwords to ~/.netrc file is supported.
+
+
+== COMMAND LINE SYNOPSIS:
+
+  >wdcd http://test.webdav.org/dav/
+  http://test.webdav.org/dav/
+  >wdls
+  images/
+  index.html
+  >wdpwd
+  http://test.webdav.org/dav/
+
+== INSTALL:
+
+  [sudo] gem sources -a http://gems.github.com
+  [sudo] gem install webdavtools
+
+or
+
+  git clone git://github.com/thomasfl/webdavtools.git
+  cd webdavtools
+  rake install
+
+

data/bin/wdcd

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'webdavtools'
+
+url = ARGV[0]
+if(url =~ /^http/)then
+  resource = WebDAV.propfind(url)
+  if(resource and resource.isCollection?)then
+    WebDAV.CWURL = url
+    puts "Set WebDAV URL: " + url
+  else
+    puts "Error: URL is not a WebDAV collection."
+  end
+elsif(url)then
+  cwurl = WebDAV.CWURL
+  if(not cwurl =~ /\/$/)then
+    cwurl += "/"
+  end
+
+  item = WebDAV.propfind(cwurl)
+  require 'pp'
+  # pp item
+  type = item.collection?
+  puts "DEBUG: type:" + type.to_s
+end
+
+
+exit
+
+if(not url)then
+  url = WebDAV.CWURL
+  if(not url)then
+    puts "wdls: no current working url"
+    puts "Usage: Use 'wdopen url' or 'wdcd [url|dir] to set current working url "
+    exit
+  end
+end
+
+WebDAV.find(url, :recursive => false ) do |item|
+  puts item.href
+end
+
+# TODO only works on collections, should give som info about resources too.

data/bin/wdls

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'webdavtools'
+require 'optparse'
+
+options = {}
+
+optparse = OptionParser.new do|opts|
+  opts.banner = "Usage: #{$0} [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!
+rescue
+  puts "Error: " + $!
+  puts optparse
+  exit
+end
+
+
+url = ARGV[0]
+if(not url)then
+  url = WebDAV.CWURL
+  if(not url)then
+    puts "wdls: no current working url"
+    puts "Usage: Use 'wdopen url' or 'wdcd [url|dir] to set current working url "
+    exit
+  end
+end
+
+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
+
+# TODO only works on collections, should give som info about resources too.

data/bin/wdprops

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'webdavtools'
+require 'optparse'
+
+options = {}
+
+title = nil
+optparse = OptionParser.new do|opts|
+  opts.banner = "Usage: #{$0} [options] url"
+
+  opts.on( '-h', '--help', 'Display this screen' ) do
+    puts opts
+    exit
+  end
+
+  options[:xml] = false
+  opts.on( '-x', '--xml', "Return full xml" ) do
+    options[:xml] = true
+  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
+
+url = ARGV[0]
+if(not(url)) then
+  puts "Error: Missing mandatory url"
+  puts optparse
+  exit
+end
+
+if(options[:xml])then
+  puts WebDAV.propfind(url, :xml => true)
+  exit
+end
+
+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
+    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

data/bin/wdput

@@ -0,0 +1,3 @@
+#!/bin/env ruby
+require 'webdavtools'
+

data/bin/wdpwd

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'webdavtools'
+
+url = WebDAV.CWURL
+if(url)then
+  puts url
+else
+  puts "wdpwd: no current working url set. Use 'wdcd url' to set url."
+end

data/lib/webdavtools.rb

@@ -0,0 +1,444 @@
+# -*- coding: utf-8 -*-
+# File: webdavtools.rb  - WebDAV library
+
+require 'rubygems'
+require 'hpricot'
+
+# :stopdoc:
+
+# Path to curl executable:
+$curl = "/usr/local/bin/curl"
+
+# 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
+  --silent
+EOF
+CURL_PROPFIND = curl_propfind_cmd.gsub("\n","").gsub(/ +/," ")
+
+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
+  --silent
+EOF
+CURL_PROPPATCH = curl_proppatch_cmd.gsub("\n","").gsub(/ +/," ")
+
+curl_delete_cmd = <<EOF
+#{$curl}
+  --request DELETE
+  --header 'Content-Type: text/xml; charset="utf-8"'
+  --netrc
+  --silent
+EOF
+CURL_DELETE = curl_delete_cmd.gsub("\n","").gsub(/ +/," ") + " "
+
+curl_mkcol_cmd = <<EOF
+#{$curl}
+  --request MKCOL
+  --header 'Content-Type: text/xml; charset="utf-8"'
+  --netrc
+  --silent
+EOF
+CURL_MKCOL = curl_mkcol_cmd.gsub("\n","").gsub(/ +/," ") + " "
+
+# Disse er ikke i bruk lenger.
+# Lag eventuelt et bibliotek som holder orden
+# på vortex typer ut fra http://vortex-dev.uio.no/vrtx/resourcetypes.txt
+EVENT_FOLDER =   '<v:collection-type xmlns:v="vrtx">event-listing</v:collection-type>' +
+                 '<v:resourceType xmlns:v="vrtx">event-listing</v:resourceType>'
+ARTICLE_FOLDER = '<v:collection-type xmlns:v="vrtx">article-listing</v:collection-type>' +
+                 '<v:resourceType xmlns:v="vrtx">article-listing</v:resourceType>'
+
+# :startdoc:
+
+# WebDAV utility functions
+module WebDAV
+
+  # Returns current working url. Used by command line utilites
+  def self.CWURL
+    cwurl = ""
+    File.open("/tmp/cwurl", 'r') {|f| cwurl = f.read() }
+    return cwurl
+  end
+
+  # Sets current working url
+  def self.CWURL=(url)
+    File.open("/tmp/cwurl", 'w') {|f| f.write(url) }
+  end
+
+  # :stopdoc:
+  VERSION = '0.1.0'
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Get content as string
+  # Example:
+  #    html = WebDAV.get(url)
+  def self.get(href)
+    curlCommand = "#{$curl} --netrc --silent " + href
+    curl_output = IO.popen(curlCommand).readlines().join("")
+    return curl_output
+  end
+
+  # Set WebDAV properties for url as xml.
+  def self.proppatch(href, property)
+    curlCommand = CURL_PROPPATCH + " \""+href+"\""
+    curlCommand = curlCommand.gsub("<!--property-and-value-->",property)
+    response = IO.popen(curlCommand).readlines().join("")
+    if(not(response =~ /200 OK/)) then
+      puts "Error:\nRequest:\n" + curlCommand + "\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)
+    href = args[0]
+    options = args[1]
+
+    curlCommand = CURL_PROPFIND + " \"" + href + "\""
+    dav_xml_output = IO.popen(curlCommand).readlines().join("")
+    if(dav_xml_output =~ /401 Unauthorized/)then
+      self.display_unauthorized_message(href)
+      exit
+    end
+    if(dav_xml_output == "")then
+      # No response
+      return nil
+    end
+    if(not(dav_xml_output =~ /200 OK/)) then
+      puts "Error:\nRequest:\n" + curlCommand + "\n\nResponse: " + dav_xml_output
+      exit(0)
+    end
+
+    if(options and options[:xml])then
+      return dav_xml_output
+    end
+    doc = Hpricot( dav_xml_output )
+    items_filtered = Array.new()
+    items = doc.search("//d:response").reverse
+    items.each do |item|
+
+      # Only return root item if folder
+      if(item.href == href) then
+        return item
+      end
+    end
+    return nil
+  end
+
+  # Find files and folders:
+  # Examples:
+  #
+  #  find( url )
+  #  find( url, :type => "collection" ,:recursive => true)
+  #  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 )
+    # puts dav_xml_output;exit(0)
+    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
+          items_filtered.concat(find(item.href, args[1], &block))
+        end
+      end
+    end
+
+    return items_filtered
+  end
+
+  # Make collection
+  def self.mkcol(href,props)
+    cmd = CURL_MKCOL + " " + href
+    result = execute_curl_cmd(cmd)
+    if(props)then
+      proppatch(href,props)
+    end
+    if(result =~ />Created</)then
+      return true
+    end
+    return result
+  end
+
+  def self.delete(href)
+    curl_delete_command = CURL_DELETE + href
+
+    response = IO.popen(curl_delete_command).readlines().join("")
+    if(response =~ /401 Unauthorized/) then
+      display_unauthorized_message(href)
+      exit
+    end
+    if(response  == "")then
+      return false
+    end
+    if(not(response =~ /200 OK/)) then
+      puts "Error:\nRequest:\n" + curl_delete_command + "\n\nResponse: " + response
+      return false
+    end
+    return true
+  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
+
+
+  # PUT content
+  # Example:
+  #  WebDAV.put("https://dav.webdav.org/file.html", "<html><h1>Test</h1></html>"
+  def self.put_string(url, html)
+    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_put_cmd = "#{$curl} --netrc --silent --upload-file #{tmp_file} #{url}"
+    response = IO.popen(curl_put_cmd).readlines().join("")
+    if(response != "" and not(response =~ /200 OK/)) then
+      raise "Error:\n WebDAV.put: WebDAV Request:\n" + CURL_PUT + "\n\nResponse: " + response
+    end
+  end
+
+  # TODO put file utility
+  # TESTME
+  def put_file(filename, href)
+    # TODO Detect if href is a collection or not??
+    curl_put_cmd = "#{$curl} --netrc --silent --request PUT #{filename} #{href}"
+    return execute_curl_cmd(curl_put_cmd)
+  end
+
+  # TODO  ????
+  def put_html_file(url_folder, filename, html)
+    # Write html
+  end
+
+
+  private
+
+  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
+
+  def self.execute_curl_cmd(cmd)
+    response = IO.popen(cmd).readlines().join("")
+    if(response =~ /401 Unauthorized/) then
+      display_unauthorized_message(href)
+      exit
+    end
+    if(response  == "")then
+      return false
+    end
+    return response
+  end
+
+end
+
+# TODO Extract to ruby sourcefile
+
+# Add custom functionality to the xml parser (monkey patching):
+module Hpricot
+
+
+  # TODO: url method as alias for href
+
+  class Elem
+
+    def method_missing(method_name, *args)
+      if(args.size == 0) then
+        return property(method_name.to_s)
+      end
+      raise "Method missing"
+    end
+
+    def href()
+      self.at("d:href").innerText
+    end
+
+    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

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: webdavtools
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Thomas Flemming
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-05 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: 
+description: "WebDAVTools is a Ruby Library and a set of command line utilities for accessing files and folders on WebDAV servers. "
+email: thomas.flemming@gmail.com
+executables: 
+- wdcd
+- wdls
+- wdprops
+- wdput
+- wdpwd
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- lib/webdavtools.rb
+- bin/wdcd
+- bin/wdls
+- bin/wdprops
+- bin/wdput
+- bin/wdpwd
+- 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: webdavtools
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Command line WebDAV client and Ruby library.
+test_files: []
+