webdav.rb 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 11276a2f0788ae73a2174746bc48900ef91355d946f0af27b7bd36b00674e8b8
+  data.tar.gz: '08912af75301ee512c4d9c08b52f836e94f055e255762890a5ea03b604cd379c'
+SHA512:
+  metadata.gz: 3997386c5837b0070a49b5a01901e3cc54e2bca7860668375a863753b2b7a12b7ccebac405d327b4349de6a27b3c1b5256eb480b072b3c6ed5bc58ff7d5435c8
+  data.tar.gz: 6a74951f911f9ba0d8e9463f4a17da9bb0348e761728a23fa3e9f93d5afb9935ba4923b1f3cf5407193dcadc04385159b3328bbcea213e56d83ad6b35d33cb22

data/CHANGELOG

@@ -0,0 +1,67 @@
+# CHANGELOG
+
+## 20260821
+
+0.2.1: + webdav.rb.gemspec, so that the gem resolves under both names.
+
+1. + webdav.rb.gemspec: the same code published as webdav.rb, caldav being published as caldav.rb. rubygems has no notion of an alias, so the two are separate gems which must be kept at the same version by hand.
+2. ~ webdav.gemspec: + a comment naming the second gemspec, this being the gem which already exists on rubygems.
+3. gem-publish 0.2.0 is what makes this work: gem build and gem push each take one file, so the earlier `gem build *.gemspec` built whichever the shell listed first and webdav.rb was never built at all.
+4. ~ WebDAV::VERSION: /0.2.0/0.2.1/
+
+## 20260522
+
+0.2.0: Rewrite MultiStatus#parse; align dependencies with http.rb 1.0.0; document WebDAV concepts.
+
+1. ~ WebDAV::MultiStatus#parse: Walk propstat blocks individually; preserve per-propstat status; detect response-level status (for COPY/MOVE/DELETE); preserve namespace URIs on properties. Now private; resources remains the public accessor.
+2. ~ WebDAV::MultiStatus resource shape: Properties move from flat hash keyed by local name to nested hash keyed by namespace URI then local name. Resources now have :propstats (array of {properties:, status:}) and :status (response-level, may be nil) instead of a single :properties and :status pair.
+3. ~ test/WebDAV/MultiStatus_test.rb: Update existing tests for new shape; + tests for per-propstat status, response-level status, namespace preservation, and same-local-name collision across namespaces.
+4. ~ README.md: Document new MultiStatus#resources shape, with paired wire-XML and parsed-Ruby examples for both PROPFIND and collection-cascade Multi-Status; + WebDAV::Response wire example; + Concepts section (properties vs content, collections and the trailing slash, why 207 Multi-Status exists, namespaces).
+5. ~ webdav.gemspec: required_ruby_version />= 2.7/>= 3.2/; http.rb dependency /[]/['~> 1.0']/; minitest pin /'~> 5.27'/'~> 6.0'/; + minitest-mock (minitest 6 split it out).
+6. ~ WebDAV::VERSION: /0.1.2/0.2.0/
+7. ~ CHANGELOG: + 0.2.0 entry
+
+## 20260520
+
+0.1.2: Fix Response#success? to return true only for 2xx responses.
+
+1. ~ WebDAV::Response#success?: Was `code < 400` which incorrectly reported 1xx and 3xx as successful. Now `code >= 200 && code < 300`.
+2. ~ test/WebDAV/Response_test.rb: + tests for 3xx and 5xx behaviour.
+3. ~ webdav.gemspec: Remove http.rb version constraint (was `>= 0.18.0`; the original rationale, Net::HTTP::Report being in http.rb 0.18.0, was reverted in webdav 0.1.1 and http.rb 0.18.1).
+4. ~ webdav.gemspec: + rexml runtime dependency (default gem on Ruby 3+; required by WebDAV::MultiStatus).
+5. ~ webdav.gemspec: Pin minitest development dependency to `~> 5.27` (Minitest 6 split `minitest/mock` into a separate gem).
+6. ~ WebDAV::VERSION: /0.1.1/0.1.2/
+7. ~ CHANGELOG: + 0.1.2 entry
+
+## 20260508
+
+0.1.1: Reinstate Net::HTTP::Report.
+
+1. + lib/Net/HTTP/Report.rb: Reinstated after checking after it was incorrectly removed in 0.1.0. REPORT is from RFC 3253 (WebDAV versioning) and is not a core HTTP method.
+2. ~ lib/webdav.rb: + require_relative './Net/HTTP/Report'
+3. + test/Net/HTTP/Report_test.rb
+4. ~ WebDAV::VERSION: /0.1.0/0.1.1/
+5. ~ CHANGELOG: + 0.1.1
+
+## 20260508
+
+0.1.0: Remove Net::HTTP::Report; now provided by http.rb 0.18.0.
+
+1. - lib/Net/HTTP/Report.rb: Now provided by http.rb 0.18.0.
+2. ~ lib/webdav.rb: - require_relative './Net/HTTP/Report'
+3. ~ webdav.gemspec: Pin http.rb dependency to >= 0.18.0; + development dependencies; + CHANGELOG and Rakefile to files; reformat.
+4. ~ .gitignore: Previously empty. Now with a default and comprehensive set of defaults.
+5. ~ WebDAV::VERSION: /0.0.0/0.1.0/
+6. ~ lib/webdav.rb: - require 'rexml/document'
+7. ~ lib/WebDAV/MultiStatus.rb: + require 'rexml/document'
+
+## 20260325
+
+0.0.0: Initial release.
+
+1. + WebDAV client with 16 verbs
+  a. 8 WebDAV-specific verbs: copy, lock, mkcol, move, propfind, proppatch, report, unlock.
+  b. 8 standard HTTP verbs: delete, get, head, options, patch, post, put, and trace.
+2. + WebDAV::Response response object
+3. + WebDAV::MultiStatus response object
+4. + WebDAV::Error for 4xx/5xx responses

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 thoran
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,305 @@
+# webdav
+
+A WebDAV client library for Ruby.
+
+
+## Installation
+
+```
+gem install webdav
+```
+
+Or in your Gemfile:
+
+```ruby
+gem 'webdav'
+```
+
+
+## Usage
+
+```ruby
+require 'webdav'
+
+dav = WebDAV.new('https://dav.example.com/files/', username: 'user', password: 'pass')
+```
+
+### Discovering resources
+
+```ruby
+response = dav.propfind('/', depth: '1')
+response.resources.each do |resource|
+  puts resource[:href]
+  resource[:propstats].each do |propstat|
+    puts propstat[:status]
+    propstat[:properties].each do |namespace, properties|
+      properties.each do |name, value|
+        puts "  #{namespace} #{name} = #{value}"
+      end
+    end
+  end
+end
+```
+
+### Reading a resource
+
+```ruby
+response = dav.get('/documents/report.txt')
+puts response.body
+```
+
+### Writing a resource
+
+```ruby
+dav.put('/documents/report.txt', body: 'Hello, world.', content_type: 'text/plain')
+```
+
+### Deleting a resource
+
+```ruby
+dav.delete('/documents/report.txt')
+```
+
+### Creating a collection
+
+```ruby
+dav.mkcol('/documents/archive/')
+```
+
+### Copying and moving
+
+```ruby
+dav.copy('/documents/report.txt', to: '/archive/report.txt')
+dav.move('/documents/draft.txt', to: '/documents/final.txt')
+```
+
+### Locking and unlocking
+
+```ruby
+lock_body = <<~XML
+  <?xml version="1.0" encoding="UTF-8"?>
+  <d:lockinfo xmlns:d="DAV:">
+    <d:lockscope><d:exclusive/></d:lockscope>
+    <d:locktype><d:write/></d:locktype>
+  </d:lockinfo>
+XML
+
+response = dav.lock('/documents/report.txt', body: lock_body)
+# ...
+dav.unlock('/documents/report.txt', token: 'urn:uuid:...')
+```
+
+### Reporting
+
+```ruby
+response = dav.report('/calendars/user/', body: report_xml, depth: '1')
+response.resources.each do |resource|
+  puts resource[:href]
+end
+```
+
+
+## Concepts
+
+WebDAV extends HTTP with a few ideas that don't have direct REST analogues. The ones below explain why the API is shaped the way it is.
+
+### Properties vs content
+
+A WebDAV resource has two faces. **Content** is what GET returns — the bytes of the file. **Properties** are metadata associated with the resource: display name, creation date, lock state, content type, and any custom properties the server defines. The same URL identifies both, but different verbs reach them — GET/PUT for content, PROPFIND/PROPPATCH for properties.
+
+### Collections and the trailing slash
+
+A **collection** is WebDAV's directory: a resource that contains other resources. MKCOL creates one. By convention, collection URLs end in `/` and ordinary resources don't; servers that care about the distinction will redirect or 404 if you get it wrong. The distinction matters because COPY, MOVE, and DELETE on a collection cascade to its children — which is also why those verbs can return 207 Multi-Status when children succeed and fail independently.
+
+### Why 207 Multi-Status exists
+
+HTTP assumes one request maps to one status. WebDAV breaks that assumption: PROPFIND on a folder asks about many resources at once; COPY of a tree may succeed on some children and fail on others. The 207 Multi-Status response code says "the request touched many things; here are per-thing outcomes." The XML body carries one `<d:response>` per affected resource. This gem returns those as `WebDAV::MultiStatus`; the `resources` accessor exposes the per-resource detail (see [Responses](#responses)).
+
+### Namespaces
+
+WebDAV properties are XML elements, and XML elements belong to namespaces. The core RFC 4918 properties live in the `DAV:` namespace. Extensions — CalDAV (`urn:ietf:params:xml:ns:caldav`), CardDAV, Exchange, ownCloud, custom server vocabularies — each define their own. Properties from different namespaces can share local names (`<d:displayname>` and `<x:displayname>` are different properties), so the parser preserves namespace URIs as the outer key in the properties hash.
+
+
+## Methods
+
+WebDAV extends HTTP with additional methods for distributed authoring. This gem provides all the methods defined in RFC 4918 ("HTTP Extensions for Web Distributed Authoring and Versioning") and the REPORT method from RFC 3253 ("Versioning Extensions to WebDAV"), which is essential for CalDAV and CardDAV queries.
+
+Ruby's standard library includes request classes for the RFC 4918 methods (Propfind, Proppatch, Mkcol, Copy, Move, Lock, Unlock) but not for REPORT. This gem defines `Net::HTTP::Report` to fill that gap.
+
+These methods are not provided by the `http.rb` gem, which deliberately limits itself to the core HTTP methods defined in RFC 9110 ("HTTP Semantics") and RFC 5789 ("PATCH Method for HTTP").
+
+### Properties (RFC 4918)
+
+- `propfind(path, body:, depth:)` — retrieve properties from a resource
+- `proppatch(path, body:)` — set or remove properties on a resource
+
+### Versioning (RFC 3253)
+
+- `report(path, body:, depth:)` — query for information about a resource; used by CalDAV and CardDAV
+
+### Collections (RFC 4918)
+
+- `mkcol(path)` — create a new collection (directory)
+
+### Namespace (RFC 4918)
+
+- `copy(path, to:, depth:, overwrite:)` — copy a resource
+- `move(path, to:, overwrite:)` — move a resource
+
+### Locking (RFC 4918)
+
+- `lock(path, body:)` — lock a resource
+- `unlock(path, token:)` — unlock a resource
+
+### Standard HTTP
+
+- `get(path)`
+- `head(path)`
+- `post(path, body:, content_type:)`
+- `put(path, body:, content_type:)`
+- `patch(path, body:, content_type:)`
+- `delete(path)`
+- `options(path)`
+- `trace(path)`
+
+
+## Responses
+
+All methods return either a `WebDAV::Response` or a `WebDAV::MultiStatus`.
+
+`WebDAV::Response` provides
+
+- `code`
+- `message`
+- `headers`
+- `body`
+- `etag`
+- `content_type`
+- `success?`
+
+A `GET` response on the wire:
+
+```
+HTTP/1.1 200 OK
+Content-Type: text/plain
+Content-Length: 13
+ETag: "5d41402a"
+
+Hello, world.
+```
+
+Parses to:
+
+```ruby
+response.code          # => 200
+response.message       # => "OK"
+response.body          # => "Hello, world."
+response.etag          # => "\"5d41402a\""
+response.content_type  # => "text/plain"
+response.success?      # => true
+```
+
+`WebDAV::MultiStatus` additionally provides:
+
+- `resources` — an array of hashes, each with:
+  - `href` — the resource URL
+  - `propstats` — an array of `{properties:, status:}` hashes (PROPFIND / PROPPATCH / REPORT). May be empty when the response carries a response-level status instead.
+  - `status` — the response-level status string (COPY / MOVE / DELETE). `nil` when the response has propstats instead.
+
+Within a propstat, `properties` is a nested hash keyed first by XML namespace URI, then by local name. For example, a CalDAV calendar property appears as `propstat[:properties]['urn:ietf:params:xml:ns:caldav']['calendar-data']` and a DAV property as `propstat[:properties]['DAV:']['getetag']`. Keeping the namespace explicit prevents collisions between properties from different namespaces that share a local name.
+
+A PROPFIND response — properties grouped by namespace, status per propstat, response-level status `nil`. The wire XML:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<d:multistatus xmlns:d="DAV:" xmlns:c="urn:ietf:params:xml:ns:caldav">
+  <d:response>
+    <d:href>/calendar/event.ics</d:href>
+    <d:propstat>
+      <d:prop>
+        <d:getetag>"abc123"</d:getetag>
+        <c:calendar-data>BEGIN:VCALENDAR...</c:calendar-data>
+      </d:prop>
+      <d:status>HTTP/1.1 200 OK</d:status>
+    </d:propstat>
+    <d:propstat>
+      <d:prop>
+        <d:getctag/>
+      </d:prop>
+      <d:status>HTTP/1.1 404 Not Found</d:status>
+    </d:propstat>
+  </d:response>
+</d:multistatus>
+```
+
+Parses to:
+
+```ruby
+[
+  {
+    href: '/calendar/event.ics',
+    propstats: [
+      {
+        properties: {
+          'DAV:' => {'getetag' => '"abc123"'},
+          'urn:ietf:params:xml:ns:caldav' => {'calendar-data' => 'BEGIN:VCALENDAR...'}
+        },
+        status: 'HTTP/1.1 200 OK'
+      },
+      {
+        properties: {'DAV:' => {'getctag' => ''}},
+        status: 'HTTP/1.1 404 Not Found'
+      }
+    ],
+    status: nil
+  }
+]
+```
+
+A COPY / MOVE / DELETE on a collection where a child resource failed — the server returns 207 Multi-Status with one `<d:response>` per affected child, each carrying a response-level status rather than propstats. Single-resource lifecycle operations don't go through this path; they return a plain `WebDAV::Response` with the status code as the whole story. The wire XML:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<d:multistatus xmlns:d="DAV:">
+  <d:response>
+    <d:href>/dir/file.txt</d:href>
+    <d:status>HTTP/1.1 403 Forbidden</d:status>
+  </d:response>
+</d:multistatus>
+```
+
+Parses to:
+
+```ruby
+[
+  {
+    href: '/dir/file.txt',
+    propstats: [],
+    status: 'HTTP/1.1 403 Forbidden'
+  }
+]
+```
+
+
+## Errors
+
+Responses with status >= 400 raise `WebDAV::Error`, which has `code`, `message`, and `body`.
+
+
+## Dependencies
+
+- [http.rb](https://github.com/thoran/http.rb)
+
+
+## Contributing
+
+1. Fork it [https://github.com/thoran/webdav/fork](https://github.com/thoran/webdav/fork)
+2. Create your feature branch (git checkout -b my-new-feature)
+3. Commit your changes (git commit -am 'Add some feature')
+4. Push to the branch (git push origin my-new-feature)
+5. Create a new pull request
+
+
+## Licence
+
+MIT

data/Rakefile

@@ -0,0 +1,9 @@
+# Rakefile
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/lib/Net/HTTP/Report.rb

@@ -0,0 +1,16 @@
+# Net/HTTP/Report.rb
+# Net::HTTP::Report
+
+require 'net/http'
+
+module Net
+  class HTTP
+    class Report < Net::HTTPRequest
+
+      METHOD = 'REPORT'
+      REQUEST_HAS_BODY = true
+      RESPONSE_HAS_BODY = true
+
+    end
+  end
+end

data/lib/String/to_const.rb

@@ -0,0 +1,7 @@
+# String/to_const.rb
+# String#to_const
+
+# 20250819
+# 0.2.0
+
+require 'Thoran/String/ToConst/to_const'

data/lib/Thoran/Array/AllButFirst/all_but_first.rb

@@ -0,0 +1,28 @@
+# Thoran/Array/AllButFirst/all_but_first.rb
+# Thoran::Array::AllButFirst#all_but_first
+
+# 20141223
+# 0.1.0
+
+# Description: This returns a copy of the receiving array with the first element removed.  
+
+# Changes:
+# 1. + Thoran namespace.
+
+require 'Thoran/Array/FirstX/firstX'
+
+module Thoran
+  module Array
+    module AllButFirst
+
+      def all_but_first
+        d = self.dup
+        d.first!
+        d
+      end
+
+    end
+  end
+end
+
+Array.send(:include, Thoran::Array::AllButFirst)

data/lib/Thoran/Array/FirstX/firstX.rb

@@ -0,0 +1,32 @@
+# Thoran/Array/FirstX/firstX.rb
+# Thoran::Array::FirstX#first!
+
+# 20180804
+# 0.3.3
+
+# Description: Sometimes it makes more sense to treat arrays this way.
+
+# Changes since 0.2:
+# 1. Added the original version 0.1.0 of the implementation to the later 0.1.0!
+# 0/1
+# 2. Switched the tests to spec-style.
+# 1/2
+# 3. Added a test for the state of the array afterward, since this is meant to be an in place change.
+# 2/3
+# 4. Added tests for the extended functionality introduced in the first version 0.1.0.
+
+module Thoran
+  module Array
+    module FirstX
+
+      def first!(n = 1)
+        return_value = []
+        n.times{return_value << self.shift}
+        return_value.size == 1 ? return_value[0] : return_value
+      end
+
+    end
+  end
+end
+
+Array.send(:include, Thoran::Array::FirstX)

data/lib/Thoran/String/ToConst/to_const.rb

@@ -0,0 +1,47 @@
+# Thoran/String/ToConst/to_const.rb
+# Thoran::String::ToConst#to_const
+
+# 20141223
+# 0.2.0
+
+# Description: This takes a string and returns a constant, with unlimited namespacing.
+
+# History: Derived from Object#to_const 0.3.0, and superceding Object#to_const.
+
+# Changes:
+# 1. + Thoran namespace.
+
+# Todo:
+# 1. This only works for two levels of constants.  Three and you're stuffed.  So, this needs to be recursive...
+#   Done iteratively as of 0.1.0.
+# 2. Make this work for symbols.  However, this will only work if there's no namespacing.  ie. :A is OK, but :A::B is not.
+
+# Discussion:
+# 1. Should this go separately into classes for which ::const_get will work and be removed from Object?  Done as of 0.1.0.
+
+require 'Thoran/Array/AllButFirst/all_but_first'
+
+module Thoran
+  module String
+    module ToConst
+
+      def to_const
+        if self =~ /::/
+          constants = self.split('::')
+          constant = Object.const_get(constants.first)
+          constants = constants.all_but_first
+          until constants.empty? do
+            constant = constant.const_get(constants.shift)
+          end
+        else
+          constant = Object.const_get(self)
+        end
+        constant
+      end
+      alias_method :to_constant, :to_const
+
+    end
+  end
+end
+
+String.send(:include, Thoran::String::ToConst)

data/lib/WebDAV/Error.rb

@@ -0,0 +1,17 @@
+# WebDAV/Error.rb
+# WebDAV::Error.rb
+
+class WebDAV
+  class Error < StandardError
+    attr_reader :code, :message, :body
+
+    private
+
+    def initialize(response)
+      @code = response.code.to_i
+      @message = response.message
+      @body = response.body
+      super("HTTP #{@code}: #{@message}")
+    end
+  end
+end

data/lib/WebDAV/MultiStatus.rb

@@ -0,0 +1,56 @@
+# WebDAV/MultiStatus.rb
+# WebDAV::MultiStatus
+
+require 'rexml/document'
+
+require_relative './Response'
+
+class WebDAV
+  class MultiStatus < Response
+    attr_reader :resources
+
+    private
+
+    def initialize(response)
+      super
+      @resources = parse
+    end
+
+    def parse
+      doc = REXML::Document.new(body)
+      doc.elements.collect('//d:response'){|response_element| parse_response(response_element)}
+    end
+
+    def parse_response(response_element)
+      {
+        href: response_element.elements['d:href']&.text,
+        propstats: parse_propstats(response_element),
+        status: parse_response_status(response_element)
+      }
+    end
+
+    def parse_propstats(response_element)
+      response_element.elements.collect('d:propstat'){|propstat_element| parse_propstat(propstat_element)}
+    end
+
+    def parse_propstat(propstat_element)
+      {
+        properties: parse_properties(propstat_element.elements['d:prop']),
+        status: propstat_element.elements['d:status']&.text
+      }
+    end
+
+    def parse_properties(prop_element)
+      return {} unless prop_element
+      prop_element.elements.to_a.each_with_object({}) do |property_element, result|
+        result[property_element.namespace] ||= {}
+        result[property_element.namespace][property_element.name] = property_element.text || property_element.to_s
+      end
+    end
+
+    def parse_response_status(response_element)
+      return nil if response_element.elements['d:propstat']
+      response_element.elements['d:status']&.text
+    end
+  end
+end

data/lib/WebDAV/Response.rb

@@ -0,0 +1,29 @@
+# WebDAV/Response.rb
+# WebDAV::Response.rb
+
+class WebDAV
+  class Response
+    attr_reader :code, :message, :headers, :body
+
+    def success?
+      code >= 200 && code < 300
+    end
+
+    def etag
+      headers['ETag']
+    end
+
+    def content_type
+      headers['Content-Type']
+    end
+
+    private
+
+    def initialize(response)
+      @code = response.code.to_i
+      @message = response.message
+      @headers = response
+      @body = response.body
+    end
+  end
+end

data/lib/WebDAV/VERSION.rb

@@ -0,0 +1,6 @@
+# WebDAV/VERSION.rb
+# WebDAV::VERSION
+
+class WebDAV
+  VERSION = '0.2.1'
+end