net_dav 0.3.3 → 0.4.0

data/Rakefile

@@ -9,9 +9,11 @@ begin
     gem.description = %Q{WebDAV client library in the style of Net::HTTP, using Net::HTTP and libcurl, if installed}
     gem.email = "c1.github@niftybox.net"
     gem.homepage = "http://github.com/devrandom/net_dav"
-    gem.authors = ["Miron Cuperman"]
+    gem.authors = ["Miron Cuperman","Thomas Flemming"]
+    gem.executables = ["dav"]
     gem.add_dependency "nokogiri", ">= 1.3.0"
     gem.add_development_dependency "rspec", ">= 1.2.0"
+    gem.add_development_dependency "webrick-webdav", ">= 1.0"
 
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end

data/VERSION

@@ -1 +1 @@
-0.3.3
+0.4.0

data/bin/dav

@@ -21,6 +21,7 @@ def print_usage
   puts "    put        Put file from FILE to URL"
   puts "    mkdir      Create directory at URL"
   puts "    gsub       Replace content at URL from REGEXP to VALUE"
+  puts "    props      Display xml properties for file or directory at URL"
   exit
 end
 
@@ -62,13 +63,13 @@ res = dav.start { |dav|
   when 'get'
     if file.nil?
       dav.get(url.path) do |str|
-	$stdout.print str
+        $stdout.print str
       end
     else
       File.open(file, "w") do |stream|
-	dav.get(url.path) do |str|
-	  stream.print str
-	end
+        dav.get(url.path) do |str|
+          stream.print str
+        end
       end
     end
   when 'lsr'
@@ -86,9 +87,11 @@ res = dav.start { |dav|
     val = $*[3]
     dav.find(url.path) do |item|
       if (item.type == :file)
-	item.content = item.content.gsub(re, val)
+        item.content = item.content.gsub(re, val)
       end
     end
+  when 'props'
+    puts dav.propfind(url.path).to_s
   else
     print_usage
   end

data/lib/net/dav/item.rb

@@ -13,34 +13,44 @@ module Net
 
       # Synonym for uri
       def url
-	@uri
+        @uri
       end
 
       def initialize(dav, uri, type, size) #:nodoc:
-	@uri = uri
-	@size = size.to_i rescue nil
-	@type = type
-	@dav = dav
+        @uri = uri
+        @size = size.to_i rescue nil
+        @type = type
+        @dav = dav
       end
 
       # Get content from server if needed and return as string
       def content
-	return @content unless @content.nil?
-	@content = @dav.get(@uri.path)
+        return @content unless @content.nil?
+        @content = @dav.get(@uri.path)
       end
 
       # Put content to server
       def content=(str)
-	@dav.put_string(@uri.path, str)
-	@content = str
+        @dav.put_string(@uri.path, str)
+        @content = str
+      end
+
+      # Proppatch item
+      def proppatch(xml_snippet)
+        @dav.proppatch(@uri.path,xml_snippet)
+      end
+
+      #Properties for this item
+      def propfind
+        return @dav.propfind(@uri.path)
       end
 
       def to_s #:nodoc:
-	"#<Net::DAV::Item URL:#{@uri.to_s} type:#{@type}>"
+        "#<Net::DAV::Item URL:#{@uri.to_s} type:#{@type}>"
       end
 
       def inspect #:nodoc:
-	"#<Net::DAV::Item URL:#{@uri.to_s} type:#{@type}>"
+        "#<Net::DAV::Item URL:#{@uri.to_s} type:#{@type}>"
       end
     end
   end

data/lib/net/dav.rb

@@ -19,252 +19,261 @@ module Net #:nodoc:
       attr_accessor :disable_basic_auth
 
       def verify_callback=(callback)
-	@http.verify_callback = callback
+        @http.verify_callback = callback
       end
 
       def verify_server=(value)
-	@http.verify_mode = value ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+        @http.verify_mode = value ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
       end
 
       def initialize(uri)
-	@disable_basic_auth = false
-	@uri = uri
-	case @uri.scheme
-	when "http"
-	  @http = Net::HTTP.new(@uri.host, @uri.port)
-	when "https"
-	  @http = Net::HTTP.new(@uri.host, @uri.port)
-	  @http.use_ssl = true
-	  self.verify_server = true
-	else
-	  raise "unknown uri scheme"
-	end
+        @disable_basic_auth = false
+        @uri = uri
+        case @uri.scheme
+        when "http"
+          @http = Net::HTTP.new(@uri.host, @uri.port)
+        when "https"
+          @http = Net::HTTP.new(@uri.host, @uri.port)
+          @http.use_ssl = true
+          self.verify_server = true
+        else
+          raise "unknown uri scheme"
+        end
       end
 
       def start(&block)
-	@http.start(&block)
+        @http.start(&block)
       end
 
       def read_timeout
-	@http.read_timeout
+        @http.read_timeout
       end
 
       def read_timeout=(sec)
-	@http.read_timeout = sec
+        @http.read_timeout = sec
       end
 
       def open_timeout
-	@http.read_timeout
+        @http.read_timeout
       end
 
       def open_timeout=(sec)
-	@http.read_timeout = sec
+        @http.read_timeout = sec
       end
 
       def request_sending_stream(verb, path, stream, length, headers)
-	req =
-	  case verb
-	  when :put
-	    Net::HTTP::Put.new(path)
-	  else
-	    raise "unkown sending_stream verb #{verb}"
-	  end
-	req.body_stream = stream
-	req.content_length = length
-	headers.each_pair { |key, value| req[key] = value } if headers
-	req.content_type = 'text/xml; charset="utf-8"'
-	res = handle_request(req, headers)
-	res
+        req =
+          case verb
+          when :put
+            Net::HTTP::Put.new(path)
+          else
+            raise "unkown sending_stream verb #{verb}"
+          end
+        req.body_stream = stream
+        req.content_length = length
+        headers.each_pair { |key, value| req[key] = value } if headers
+        req.content_type = 'text/xml; charset="utf-8"'
+        res = handle_request(req, headers)
+        res
       end
 
       def request_sending_body(verb, path, body, headers)
-	req =
-	  case verb
-	  when :put
-	    Net::HTTP::Put.new(path)
-	  else
-	    raise "unkown sending_body verb #{verb}"
-	  end
-	req.body = body
-	headers.each_pair { |key, value| req[key] = value } if headers
-	req.content_type = 'text/xml; charset="utf-8"'
-	res = handle_request(req, headers)
-	res
+        req =
+          case verb
+          when :put
+            Net::HTTP::Put.new(path)
+          else
+            raise "unkown sending_body verb #{verb}"
+          end
+        req.body = body
+        headers.each_pair { |key, value| req[key] = value } if headers
+        req.content_type = 'text/xml; charset="utf-8"'
+        res = handle_request(req, headers)
+        res
       end
 
       def request_returning_body(verb, path, headers, &block)
-	req =
-	  case verb
-	  when :get
-	    Net::HTTP::Get.new(path)
-	  else
-	    raise "unkown returning_body verb #{verb}"
-	  end
-	headers.each_pair { |key, value| req[key] = value } if headers
-	res = handle_request(req, headers, MAX_REDIRECTS, &block)
-	res.body
+        req =
+          case verb
+          when :get
+            Net::HTTP::Get.new(path)
+          else
+            raise "unkown returning_body verb #{verb}"
+          end
+        headers.each_pair { |key, value| req[key] = value } if headers
+        res = handle_request(req, headers, MAX_REDIRECTS, &block)
+        res.body
       end
 
       def request(verb, path, body, headers)
-	req =
-	  case verb
-	  when :propfind
-	    Net::HTTP::Propfind.new(path)
-	  when :mkcol
-	    Net::HTTP::Mkcol.new(path)
-	  else
-	    raise "unkown verb #{verb}"
-	  end
-	req.body = body
-	headers.each_pair { |key, value| req[key] = value } if headers
-	req.content_type = 'text/xml; charset="utf-8"'
-	res = handle_request(req, headers)
-	res
+        req =
+          case verb
+          when :propfind
+            Net::HTTP::Propfind.new(path)
+          when :mkcol
+            Net::HTTP::Mkcol.new(path)
+          when :delete
+            Net::HTTP::Delete.new(path)
+          when :move
+            Net::HTTP::Move.new(path)
+          when :copy
+            Net::HTTP::Copy.new(path)
+          when :proppatch
+            Net::HTTP::Proppatch.new(path)
+          else
+            raise "unkown verb #{verb}"
+          end
+        req.body = body
+        headers.each_pair { |key, value| req[key] = value } if headers
+        req.content_type = 'text/xml; charset="utf-8"'
+        res = handle_request(req, headers)
+        res
       end
 
       def handle_request(req, headers, limit = MAX_REDIRECTS, &block)
-	# You should choose better exception. 
-	raise ArgumentError, 'HTTP redirect too deep' if limit == 0
-
-	response = nil
-	if block
-	  @http.request(req) {|res|
-	    # Only start returning a body if we will not retry
-	    res.read_body nil, &block if !res.is_a?(Net::HTTPUnauthorized) && !res.is_a?(Net::HTTPRedirection)
-	    response = res
-	  }
-	else
-	  response = @http.request(req)
-	end
-	case response
-	when Net::HTTPSuccess     then
-	  return response
-	when Net::HTTPUnauthorized     then
-	  response.error! unless @user
-	  response.error! if req['authorization']
-	  new_req = clone_req(req.path, req, headers)
-	  if response['www-authenticate'] =~ /^Basic/
-	    if disable_basic_auth
-	      raise "server requested basic auth, but that is disabled"
-	    end
-	    new_req.basic_auth @user, @pass
-	  else
-	    digest_auth(new_req, @user, @pass, response)
-	  end
-	  return handle_request(new_req, headers, limit - 1, &block)
-	when Net::HTTPRedirection then
-	  location = URI.parse(response['location'])
-	  if (@uri.scheme != location.scheme ||
-	      @uri.host != location.host ||
-	      @uri.port != location.port)
-	    raise ArgumentError, "cannot redirect to a different host #{@uri} => #{location}"
-	  end
-	  new_req = clone_req(location.path, req, headers)
-	  return handle_request(new_req, headers, limit - 1, &block)
-	else
-	  response.error!
-	end
+        # You should choose better exception.
+        raise ArgumentError, 'HTTP redirect too deep' if limit == 0
+
+        response = nil
+        if block
+          @http.request(req) {|res|
+            # Only start returning a body if we will not retry
+            res.read_body nil, &block if !res.is_a?(Net::HTTPUnauthorized) && !res.is_a?(Net::HTTPRedirection)
+            response = res
+          }
+        else
+          response = @http.request(req)
+        end
+        case response
+        when Net::HTTPSuccess     then
+          return response
+        when Net::HTTPUnauthorized     then
+          response.error! unless @user
+          response.error! if req['authorization']
+          new_req = clone_req(req.path, req, headers)
+          if response['www-authenticate'] =~ /^Basic/
+            if disable_basic_auth
+              raise "server requested basic auth, but that is disabled"
+            end
+            new_req.basic_auth @user, @pass
+          else
+            digest_auth(new_req, @user, @pass, response)
+          end
+          return handle_request(new_req, headers, limit - 1, &block)
+        when Net::HTTPRedirection then
+          location = URI.parse(response['location'])
+          if (@uri.scheme != location.scheme ||
+              @uri.host != location.host ||
+              @uri.port != location.port)
+            raise ArgumentError, "cannot redirect to a different host #{@uri} => #{location}"
+          end
+          new_req = clone_req(location.path, req, headers)
+          return handle_request(new_req, headers, limit - 1, &block)
+        else
+          response.error!
+        end
       end
+
       def clone_req(path, req, headers)
-	new_req = req.class.new(path)
-	new_req.body = req.body if req.body
-	new_req.body_stream = req.body_stream if req.body_stream
-	headers.each_pair { |key, value| new_req[key] = value } if headers
-	return new_req
+        new_req = req.class.new(path)
+        new_req.body = req.body if req.body
+        new_req.body_stream = req.body_stream if req.body_stream
+        headers.each_pair { |key, value| new_req[key] = value } if headers
+        return new_req
       end
 
       CNONCE = Digest::MD5.hexdigest("%x" % (Time.now.to_i + rand(65535))).slice(0, 8)
 
       def digest_auth(request, user, password, response)
-	# based on http://segment7.net/projects/ruby/snippets/digest_auth.rb
-	@nonce_count = 0 if @nonce_count.nil?
-	@nonce_count += 1
-
-	raise "bad www-authenticate header" unless (response['www-authenticate'] =~ /^(\w+) (.*)/)
-
-	params = {}
-	$2.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }
-
-	a_1 = "#{user}:#{params['realm']}:#{password}"
-	a_2 = "#{request.method}:#{request.path}"
-	request_digest = ''
-	request_digest << Digest::MD5.hexdigest(a_1)
-	request_digest << ':' << params['nonce']
-	request_digest << ':' << ('%08x' % @nonce_count)
-	request_digest << ':' << CNONCE
-	request_digest << ':' << params['qop']
-	request_digest << ':' << Digest::MD5.hexdigest(a_2)
-
-	header = []
-	header << "Digest username=\"#{user}\""
-	header << "realm=\"#{params['realm']}\""
-	header << "nonce=\"#{params['nonce']}\""
-	header << "uri=\"#{request.path}\""
-	header << "cnonce=\"#{CNONCE}\""
-	header << "nc=#{'%08x' % @nonce_count}"
-	header << "qop=#{params['qop']}"
-	header << "response=\"#{Digest::MD5.hexdigest(request_digest)}\""
-	header << "algorithm=\"MD5\""
-
-	header = header.join(', ')
-	request['Authorization'] = header
+        # based on http://segment7.net/projects/ruby/snippets/digest_auth.rb
+        @nonce_count = 0 if @nonce_count.nil?
+        @nonce_count += 1
+
+        raise "bad www-authenticate header" unless (response['www-authenticate'] =~ /^(\w+) (.*)/)
+
+        params = {}
+        $2.gsub(/(\w+)="(.*?)"/) { params[$1] = $2 }
+
+        a_1 = "#{user}:#{params['realm']}:#{password}"
+        a_2 = "#{request.method}:#{request.path}"
+        request_digest = ''
+        request_digest << Digest::MD5.hexdigest(a_1)
+        request_digest << ':' << params['nonce']
+        request_digest << ':' << ('%08x' % @nonce_count)
+        request_digest << ':' << CNONCE
+        request_digest << ':' << params['qop']
+        request_digest << ':' << Digest::MD5.hexdigest(a_2)
+
+        header = []
+        header << "Digest username=\"#{user}\""
+        header << "realm=\"#{params['realm']}\""
+        header << "nonce=\"#{params['nonce']}\""
+        header << "uri=\"#{request.path}\""
+        header << "cnonce=\"#{CNONCE}\""
+        header << "nc=#{'%08x' % @nonce_count}"
+        header << "qop=#{params['qop']}"
+        header << "response=\"#{Digest::MD5.hexdigest(request_digest)}\""
+        header << "algorithm=\"MD5\""
+
+        header = header.join(', ')
+        request['Authorization'] = header
       end
     end
 
 
     class CurlHandler < NetHttpHandler
       def verify_callback=(callback)
-	super
-	curl = make_curl
-	$stderr.puts "verify_callback not implemented in Curl::Easy"
+        super
+        curl = make_curl
+        $stderr.puts "verify_callback not implemented in Curl::Easy"
       end
 
       def verify_server=(value)
-	super
-	curl = make_curl
-	curl.ssl_verify_peer = value
-	curl.ssl_verify_host = value
+        super
+        curl = make_curl
+        curl.ssl_verify_peer = value
+        curl.ssl_verify_host = value
       end
 
       def make_curl
-	unless @curl
-	  @curl = Curl::Easy.new
-	  @curl.timeout = @http.read_timeout
-	  @curl.follow_location = true
-	  @curl.max_redirects = MAX_REDIRECTS
-	  if disable_basic_auth
-	    @curl.http_auth_types = Curl::CURLAUTH_DIGEST
-	  end
-	end
-	@curl
+        unless @curl
+          @curl = Curl::Easy.new
+          @curl.timeout = @http.read_timeout
+          @curl.follow_location = true
+          @curl.max_redirects = MAX_REDIRECTS
+          if disable_basic_auth
+            @curl.http_auth_types = Curl::CURLAUTH_DIGEST
+          end
+        end
+        @curl
       end
 
       def request_returning_body(verb, path, headers)
-	raise "unkown returning_body verb #{verb}" unless verb == :get
-	url = @uri.merge(path)
-	curl = make_curl
-	curl.url = url.to_s
-	headers.each_pair { |key, value| curl.headers[key] = value } if headers
-	if (@user)
-	  curl.userpwd = "#{@user}:#{@pass}"
-	else
-	  curl.userpwd = nil
-	end
-	res = nil
-	if block_given?
-	  curl.on_body do |frag|
-	    yield frag
-	    frag.length
-	  end
-	end
-	curl.perform
-	unless curl.response_code >= 200 && curl.response_code < 300
-	  header_block = curl.header_str.split(/\r?\n\r?\n/)[-1]
-	  msg = header_block.split(/\r?\n/)[0]
-	  msg.gsub!(/^HTTP\/\d+.\d+ /, '')
-	  raise Net::HTTPError.new(msg, nil)
-	end
-	curl.body_str
+        raise "unkown returning_body verb #{verb}" unless verb == :get
+        url = @uri.merge(path)
+        curl = make_curl
+        curl.url = url.to_s
+        headers.each_pair { |key, value| curl.headers[key] = value } if headers
+        if (@user)
+          curl.userpwd = "#{@user}:#{@pass}"
+        else
+          curl.userpwd = nil
+        end
+        res = nil
+        if block_given?
+          curl.on_body do |frag|
+            yield frag
+            frag.length
+          end
+        end
+        curl.perform
+        unless curl.response_code >= 200 && curl.response_code < 300
+          header_block = curl.header_str.split(/\r?\n\r?\n/)[-1]
+          msg = header_block.split(/\r?\n/)[0]
+          msg.gsub!(/^HTTP\/\d+.\d+ /, '')
+          raise Net::HTTPError.new(msg, nil)
+        end
+        curl.body_str
       end
 
     end
@@ -325,7 +334,7 @@ module Net #:nodoc:
     def initialize(uri, options = nil)
       @have_curl = Curl rescue nil
       if options && options.has_key?(:curl) && !options[:curl]
-	@have_curl = false
+        @have_curl = false
       end
       @uri = uri
       @uri = URI.parse(@uri) if @uri.is_a? String
@@ -343,7 +352,7 @@ module Net #:nodoc:
     #  end
     def start(&block) # :yield: dav
       @handler.start do
-	return yield(self)
+        return yield(self)
       end
     end
 
@@ -362,6 +371,16 @@ module Net #:nodoc:
 
     # Find files and directories, yields Net::DAV::Item
     #
+    # The :filename option can be a regexp or string, and is used
+    # to filter the yielded items.
+    #
+    # If :suppress_errors is passed, exceptions that occurs when
+    # reading directory information is ignored, and a warning is
+    # printed out stderr instead.
+    #
+    # The default is to not traverse recursively, unless the :recursive
+    # options is passed.
+    #
     # Examples:
     #
     #  res = Net::DAV.start(url) do |dav|
@@ -370,29 +389,63 @@ module Net #:nodoc:
     #      puts item.content
     #    end
     #  end
+    #
+    #  dav = Net::DAV.new(url)
+    #  dav.find(url.path, :filename => /\.html/, :suppress_errors => true)
+    #    puts item.url.to_s
+    #  end
     def find(path, options = {})
       path = @uri.merge(path).path
       namespaces = {'x' => "DAV:"}
-      doc = propfind(path)
+      begin
+        doc = propfind(path)
+      rescue Net::HTTPServerException => e
+        msg = e.to_s + ": " + path.to_s
+        if(options[:suppress_errors])then
+          # Ignore dir if propfind returns an error
+          warn("Warning: " + msg)
+          return nil
+        else
+          raise Net::HTTPServerException.new(msg, nil)
+        end
+      end
       path.sub!(/\/$/, '')
       doc./('.//x:response', namespaces).each do |item|
-	uri = @uri.merge(item.xpath("x:href", namespaces).inner_text)
-	size = item.%(".//x:getcontentlength", namespaces).inner_text rescue nil
-	type = item.%(".//x:collection", namespaces) ? :directory : :file
-	res = Item.new(self, uri, type, size)
-	if type == :file
-	  yield res
-	elsif uri.path == path || uri.path == path + "/"
-	  # This is the top-level dir, skip it
-	elsif options[:recursive] && type == :directory
-	  yield res
-	  # This is a subdir, recurse
-	  find(uri.path, options) do |sub_res|
-	    yield sub_res
-	  end
-	else
-	  yield res
-	end
+        uri = @uri.merge(item.xpath("x:href", namespaces).inner_text)
+        size = item.%(".//x:getcontentlength", namespaces).inner_text rescue nil
+        type = item.%(".//x:collection", namespaces) ? :directory : :file
+        res = Item.new(self, uri, type, size)
+        if type == :file then
+
+          if(options[:filename])then
+            search_term = options[:filename]
+            filename = File.basename(uri.path)
+            if(search_term.class == Regexp and search_term.match(filename))then
+              yield res
+            elsif(search_term.class == String and search_term == filename)then
+              yield res
+            end
+          else
+            yield res
+          end
+
+        elsif uri.path == path || uri.path == path + "/"
+          # This is the top-level dir, skip it
+        elsif options[:recursive] && type == :directory
+
+          if(!options[:filename])then
+            yield res
+          end
+
+          # This is a subdir, recurse
+          find(uri.path, options) do |sub_res|
+            yield sub_res
+          end
+        else
+          if(!options[:filename])then
+            yield res
+          end
+        end
       end
     end
 
@@ -400,7 +453,7 @@ module Net #:nodoc:
     def cd(url)
       new_uri = @uri.merge(url)
       if new_uri.host != @uri.host || new_uri.port != @uri.port || new_uri.scheme != @uri.scheme
-	raise Exception , "uri must have same scheme, host and port"
+        raise Exception , "uri must have same scheme, host and port"
       end
       @uri = new_uri
     end
@@ -441,6 +494,58 @@ module Net #:nodoc:
       res.body
     end
 
+    # Delete request
+    #
+    # Example:
+    #   dav.delete(uri.path)
+    def delete(path)
+      path = @uri.merge(path).path
+      res = @handler.request(:delete, path, nil, nil)
+      res.body
+    end
+
+    # Send a move request to the server.
+    #
+    # Example:
+    #   dav.move(original_path, new_path)
+    def move(path,destination)
+      path = @uri.merge(path).path
+      destination = @uri.merge(destination).to_s
+      headers = {'Destination' => destination}
+      res = @handler.request(:move, path, nil, headers)
+      res.body
+    end
+
+    # Send a copy request to the server.
+    #
+    # Example:
+    #   dav.copy(original_path, destination)
+    def copy(path,destination)
+      path = @uri.merge(path).path
+      destination = @uri.merge(destination).to_s
+      headers = {'Destination' => destination}
+      res = @handler.request(:copy, path, nil, headers)
+      res.body
+    end
+
+    # Do a proppatch request to the server to
+    # update properties on resources or collections.
+    #
+    # Example:
+    #   dav.proppatch(uri.path,"<d:creationdate>#{new_date}</d:creationdate>")
+    def proppatch(path, xml_snippet)
+      headers = {'Depth' => '1'}
+      body =  '<?xml version="1.0"?>' +
+      '<d:propertyupdate xmlns:d="DAV:">' +
+      '<d:set>' +
+          '<d:prop>' +
+            xml_snippet +
+          '</d:prop>' +
+        '</d:set>' +
+      '</d:propertyupdate>'
+      res = @handler.request(:proppatch, path, body, headers)
+      Nokogiri::XML.parse(res.body)
+    end
 
     # Makes a new directory (collection)
     def mkdir(path)

data/net_dav.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{net_dav}
-  s.version = "0.3.3"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Miron Cuperman"]
-  s.date = %q{2009-11-19}
+  s.authors = ["Miron Cuperman", "Thomas Flemming"]
+  s.date = %q{2009-12-10}
   s.default_executable = %q{dav}
   s.description = %q{WebDAV client library in the style of Net::HTTP, using Net::HTTP and libcurl, if installed}
   s.email = %q{c1.github@niftybox.net}
@@ -30,7 +30,9 @@ Gem::Specification.new do |s|
      "lib/net/dav/item.rb",
      "net_dav.gemspec",
      "script/multi-test",
-     "spec/net_dav_spec.rb",
+     "spec/fixtures/file.html",
+     "spec/integration/net_dav_spec.rb",
+     "spec/integration/webdav_server.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb",
      "tmp/.gitignore"
@@ -41,8 +43,9 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{WebDAV client library in the style of Net::HTTP}
   s.test_files = [
-    "spec/net_dav_spec.rb",
-     "spec/spec_helper.rb"
+    "spec/spec_helper.rb",
+     "spec/integration/webdav_server.rb",
+     "spec/integration/net_dav_spec.rb"
   ]
 
   if s.respond_to? :specification_version then
@@ -52,13 +55,16 @@ Gem::Specification.new do |s|
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<nokogiri>, [">= 1.3.0"])
       s.add_development_dependency(%q<rspec>, [">= 1.2.0"])
+      s.add_development_dependency(%q<webrick-webdav>, [">= 1.0"])
     else
       s.add_dependency(%q<nokogiri>, [">= 1.3.0"])
       s.add_dependency(%q<rspec>, [">= 1.2.0"])
+      s.add_dependency(%q<webrick-webdav>, [">= 1.0"])
     end
   else
     s.add_dependency(%q<nokogiri>, [">= 1.3.0"])
     s.add_dependency(%q<rspec>, [">= 1.2.0"])
+    s.add_dependency(%q<webrick-webdav>, [">= 1.0"])
   end
 end
 

data/spec/fixtures/file.html

@@ -0,0 +1 @@
+Content

data/spec/integration/net_dav_spec.rb

@@ -0,0 +1,96 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/webdav_server')
+
+describe "Net::Dav" do
+
+  before(:all) do
+    # Start webdav server in subprocess
+    @pid = fork do
+      webdav_server(:port => 10080,:authentication => false)
+    end
+    # Wait for webdavserver to start
+    sleep(10)
+  end
+
+  it "should create a Net::Dav object" do
+    Net::DAV.new("http://localhost.localdomain/").should_not be_nil
+  end
+
+  it "should read properties from webdav server" do
+    dav = Net::DAV.new("http://localhost:10080/")
+    @props = dav.propfind("/").to_s
+    @props.should match(/200 OK/)
+  end
+
+  it "should write files to webdav server" do
+    dav = Net::DAV.new("http://localhost:10080/")
+    @props = find_props_or_error(dav, "/new_file.html")
+    @props.should match(/404.*Not found/i)
+
+    dav.put_string("/new_file.html","File contents")
+
+    @props = find_props_or_error(dav, "/new_file.html")
+    @props.should match(/200 OK/i)
+  end
+
+   it "should delete files from webdav server" do
+     dav = Net::DAV.new("http://localhost:10080/")
+
+     @props = find_props_or_error(dav, "/new_file.html")
+     @props.should match(/200 OK/i)
+
+     dav.delete("/new_file.html")
+     @props = find_props_or_error(dav, "/new_file.html")
+     @props.should match(/404.*Not found/i)
+   end
+
+  it "should copy files on webdav server" do
+    dav = Net::DAV.new("http://localhost:10080/")
+
+    @props = find_props_or_error(dav, "/file.html")
+    @props.should match(/200 OK/i)
+
+    dav.copy("/file.html","/copied_file.html")
+    @props = find_props_or_error(dav, "/copied_file.html")
+    @props.should match(/200 OK/i)
+
+    dav.delete("/copied_file.html")
+
+    @props = find_props_or_error(dav, "/copied_file.html")
+    @props.should match(/404.*Not found/i)
+  end
+
+  it "should move files on webdav server" do
+    dav = Net::DAV.new("http://localhost:10080/")
+
+    @props = find_props_or_error(dav, "/file.html")
+    @props.should match(/200 OK/i)
+
+    dav.move("/file.html","/moved_file.html")
+    @props = find_props_or_error(dav, "/moved_file.html")
+    @props.should match(/200 OK/i)
+
+    @props = find_props_or_error(dav, "/file.html")
+    @props.should match(/404.*Not found/i)
+
+    dav.move("/moved_file.html","/file.html")
+    @props = find_props_or_error(dav, "/file.html")
+    @props.should match(/200 OK/i)
+  end
+
+# proppatch seems to work, but our simple webdav server don't update properties
+#   it "should alter properties on resources on webdav server" do
+#     dav = Net::DAV.new("http://localhost:10080/")
+#     @props = find_props_or_error(dav, "/file.html")
+#     puts @props
+#     dav.proppatch("/file.html", "<d:resourcetype>static-file</d:resourcetype>")
+#     @props = find_props_or_error(dav, "/file.html")
+#     puts @props
+#   end
+
+  after(:all) do
+    # Shut down webdav server
+    Process.kill('SIGKILL', @pid) rescue nil
+  end
+
+end

data/spec/integration/webdav_server.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/ruby
+# -*- coding: utf-8 -*-
+require 'rubygems'
+require 'webrick'
+require 'webrick/httpservlet/webdavhandler'
+
+# Web server with WebDAV extensions
+#
+# Usage: ruby webdav_server.rb
+
+# Code based on:
+# http://github.com/aslakhellesoy/webdavjs/blob/master/spec/webdav_server.rb
+
+
+# Monkey patch REXML to always nil-indent. The indentation is broken in REXML
+# on Ruby 1.8.6 and even when fixed it confuses OS-X.
+module REXML
+  module Node
+    alias old_to_s to_s
+    def to_s(indent=nil)
+      old_to_s(nil)
+    end
+  end
+end
+
+# http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/223386
+# http://gmarrone.objectblues.net/cgi-bin/wiki/WebDAV_-_Linux_server%2c_Mac_OS_X_client
+module WEBrick
+  module HTTPServlet
+    class WebDAVHandlerVersion2 < WebDAVHandler
+
+      def do_OPTIONS(req, res)
+        super
+        res["DAV"] = "1,2"
+      end
+
+      def do_LOCK(req, res)
+        res.body << "<XXX-#{Time.now.to_s}/>"
+      end
+
+    end
+
+    class WebDAVHandlerVersion3 < WebDAVHandlerVersion2
+
+      # Enable authentication
+      $REALM = "WebDav share"
+      $USER = "myuser"
+      $PASS = "mypass"
+
+      def service(req, res)
+        HTTPAuth.basic_auth(req, res, $REALM) {|user, pass|
+          # this block returns true if
+          # authentication token is valid
+          user == $USER && pass == $PASS
+        }
+        super
+      end
+
+    end
+
+  end
+end
+
+def webdav_server(*options)
+  port = 10080
+  if(options and options[0][:port])
+    port = options[0][:port]
+  end
+  log = WEBrick::Log.new
+  log.level = WEBrick::Log::DEBUG if $DEBUG
+  serv = WEBrick::HTTPServer.new({:Port => port, :Logger => log})
+
+  dir = File.expand_path(File.dirname(__FILE__)) +  '/../fixtures'
+  if(options and options[0][:authentication])
+    serv.mount("/", WEBrick::HTTPServlet::WebDAVHandlerVersion3, dir)
+  else
+    serv.mount("/", WEBrick::HTTPServlet::WebDAVHandlerVersion2, dir)
+  end
+
+  trap(:INT){ serv.shutdown }
+  serv.start
+end
+
+if($0 ==  __FILE__)
+
+  webdav_server(:port => 10080,:authentication => false)
+end

data/spec/spec_helper.rb

@@ -6,5 +6,14 @@ require 'spec'
 require 'spec/autorun'
 
 Spec::Runner.configure do |config|
-  
+
+end
+
+# Profind helper. Returns properties or error
+def find_props_or_error(dav, path)
+  begin
+    return dav.propfind(path).to_s
+  rescue Net::HTTPServerException => e
+    return e.to_s
+  end
 end

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification 
 name: net_dav
 version: !ruby/object:Gem::Version 
-  version: 0.3.3
+  version: 0.4.0
 platform: ruby
 authors: 
 - Miron Cuperman
+- Thomas Flemming
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-11-19 00:00:00 -08:00
+date: 2009-12-10 00:00:00 -08:00
 default_executable: dav
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,6 +33,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.2.0
     version: 
+- !ruby/object:Gem::Dependency 
+  name: webrick-webdav
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+    version: 
 description: WebDAV client library in the style of Net::HTTP, using Net::HTTP and libcurl, if installed
 email: c1.github@niftybox.net
 executables: 
@@ -53,7 +64,9 @@ files:
 - lib/net/dav/item.rb
 - net_dav.gemspec
 - script/multi-test
-- spec/net_dav_spec.rb
+- spec/fixtures/file.html
+- spec/integration/net_dav_spec.rb
+- spec/integration/webdav_server.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 - tmp/.gitignore
@@ -86,5 +99,6 @@ signing_key:
 specification_version: 3
 summary: WebDAV client library in the style of Net::HTTP
 test_files: 
-- spec/net_dav_spec.rb
 - spec/spec_helper.rb
+- spec/integration/webdav_server.rb
+- spec/integration/net_dav_spec.rb

data/spec/net_dav_spec.rb

@@ -1,7 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "Net::Dav" do
-  it "should create a Net::Dav object" do
-    Net::DAV.new("http://localhost.localdomain/").should_not be_nil
-  end
-end