webdav 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1721f681cfb816034b039f48242101233a096ac8ca65eee54ff8e7cac6e419eb
+  data.tar.gz: 3c8cd82ee3191f3cb957b63c4be8c2d86f362fb470bbd9f5989f8548a417580a
+SHA512:
+  metadata.gz: f8af2a0aaa9a4388ede4af98c93a0303b27c803a6233ec357e0a118098bd95afdd032f005e8c075d0133ad6fc9159871bf24007b1165b0dbadf5b1b281cb06a3
+  data.tar.gz: 7b680af432e9913a56c163c199d9908cdbc657bf4246175e8a3cd76030116adb66764c8cfc8b270c5a6e575875032d597a63be23fad374a3f6b48e57c85cd800

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,148 @@
+# webdav
+
+A Ruby WebDAV client library.
+
+## 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]
+  puts resource[:properties]
+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:...')
+```
+
+### REPORT
+
+```ruby
+response = dav.report('/calendars/user/', body: report_xml, depth: '1')
+response.resources.each do |resource|
+  puts resource[:href]
+end
+```
+
+## Verbs
+
+### WebDAV (RFC 4918 / RFC 3253)
+
+- `propfind(path, body:, depth:)` — Retrieve properties
+- `proppatch(path, body:)` — Modify properties
+- `report(path, body:, depth:)` — Run a report query
+- `mkcol(path)` — Create a collection
+- `copy(path, to:, depth:, overwrite:)` — Copy a resource
+- `move(path, to:, overwrite:)` — Move a resource
+- `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?`
+
+`WebDAV::MultiStatus` additionally provides:
+
+- `resources`
+— an array of hashes, each with:
+  - `href`
+  - `properties`
+  - `status`
+
+## Errors
+
+Responses with status >= 400 raise `WebDAV::Error`, which has `code`, `message`, and `body`.
+
+## Dependencies
+
+- [http.rb](https://github.com/thoran/http.rb)
+
+## Licence
+
+MIT

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,32 @@
+# WebDAV/MultiStatus.rb
+# WebDAV::MultiStatus
+
+require_relative './Response'
+
+class WebDAV
+  class MultiStatus < Response
+    attr_reader :resources
+
+    def parse
+      doc = REXML::Document.new(body)
+      resources = []
+      doc.elements.each('//d:response') do |resp|
+        href = resp.elements['.//d:href']&.text
+        properties = {}
+        resp.elements.each('.//d:prop/*') do |prop|
+          properties[prop.name] = prop.text || prop.to_s
+        end
+        status = resp.elements['.//d:status']&.text
+        resources << {href: href, properties: properties, status: status}
+      end
+      resources
+    end
+
+    private
+
+    def initialize(response)
+      super
+      @resources = parse
+    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 < 400
+    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.0.0'
+end

data/lib/webdav.rb

@@ -0,0 +1,158 @@
+# WebDAV.rb
+# WebDAV
+
+gem 'http.rb'; require 'http.rb'
+require 'net/http'
+require 'rexml/document'
+require 'uri'
+
+require_relative './Net/HTTP/Report'
+require_relative './String/to_const'
+require_relative './WebDAV/Error'
+require_relative './WebDAV/MultiStatus'
+require_relative './WebDAV/Response'
+
+class WebDAV
+
+  # Properties
+
+  def propfind(path = '/', body: nil, depth: '1')
+    response = request(:propfind, path, body: body, headers: {'Depth' => depth})
+    handle_response(response)
+  end
+
+  def proppatch(path, body:)
+    response = request(:proppatch, path, body: body)
+    handle_response(response)
+  end
+
+  # Reports
+
+  def report(path, body:, depth: '1')
+    response = request(:report, path, body: body, headers: {'Depth' => depth})
+    handle_response(response)
+  end
+
+  # Collections
+
+  def mkcol(path)
+    response = request(:mkcol, path)
+    handle_response(response)
+  end
+
+  # Namespace
+
+  def copy(path, to:, depth: 'infinity', overwrite: true)
+    response = request(:copy, path, headers: {
+      'Destination' => resolve_uri(to).to_s,
+      'Depth' => depth,
+      'Overwrite' => overwrite ? 'T' : 'F'
+    })
+    handle_response(response)
+  end
+
+  def move(path, to:, overwrite: true)
+    response = request(:move, path, headers: {
+      'Destination' => resolve_uri(to).to_s,
+      'Overwrite' => overwrite ? 'T' : 'F'
+    })
+    handle_response(response)
+  end
+
+  # Locking
+
+  def lock(path, body:)
+    response = request(:lock, path, body: body)
+    handle_response(response)
+  end
+
+  def unlock(path, token:)
+    response = request(:unlock, path, headers: {'Lock-Token' => "<#{token}>"})
+    handle_response(response)
+  end
+
+  # Standard HTTP
+
+  def get(path)
+    response = request(:get, path)
+    handle_response(response)
+  end
+
+  def head(path)
+    response = request(:head, path)
+    handle_response(response)
+  end
+
+  def post(path, body:, content_type: 'application/xml')
+    response = request(:post, path, body: body, headers: {'Content-Type' => content_type})
+    handle_response(response)
+  end
+
+  def put(path, body:, content_type: 'application/octet-stream')
+    response = request(:put, path, body: body, headers: {'Content-Type' => content_type})
+    handle_response(response)
+  end
+
+  def patch(path, body:, content_type: 'application/xml')
+    response = request(:patch, path, body: body, headers: {'Content-Type' => content_type})
+    handle_response(response)
+  end
+
+  def delete(path)
+    response = request(:delete, path)
+    handle_response(response)
+  end
+
+  def options(path = '/')
+    response = request(:options, path)
+    handle_response(response)
+  end
+
+  def trace(path)
+    response = request(:trace, path)
+    handle_response(response)
+  end
+
+  private
+
+  def initialize(uri, username:, password:)
+    @uri = uri.is_a?(URI) ? uri : URI.parse(uri)
+    @username = username
+    @password = password
+  end
+
+  def resolve_uri(path)
+    URI.join(@uri, path)
+  end
+
+  def request_uri(path)
+    resolve_uri(path).request_uri
+  end
+
+  def default_headers
+    {'Content-Type' => 'application/xml; charset=utf-8'}
+  end
+
+  def request_class(verb)
+    "Net::HTTP::#{verb.to_s.capitalize}".to_const
+  end
+
+  def request(verb, path, body: nil, headers: {})
+    request_object = request_class(verb).new(request_uri(path))
+    request_object.basic_auth(@username, @password)
+    request_object.body = body if body
+    merged_headers = default_headers.merge(headers)
+    merged_headers.each{|k, v| request_object[k] = v}
+    HTTP.request(resolve_uri(path), request_object)
+  end
+
+  def handle_response(response)
+    raise WebDAV::Error.new(response) if response.code.to_i >= 400
+    case response.code.to_i
+    when 207
+      MultiStatus.new(response)
+    else
+      Response.new(response)
+    end
+  end
+end

data/test/WebDAV/Error_test.rb

@@ -0,0 +1,85 @@
+# test/WebDAV/Error_test.rb
+
+require_relative '../helper'
+
+describe WebDAV::Error do
+  let(:mock_response) do
+    MockResponse.new(
+      code: '404',
+      message: 'Not Found',
+      body: '<!DOCTYPE html><html><body>Not Found</body></html>'
+    )
+  end
+
+  let(:error){WebDAV::Error.new(mock_response)}
+
+  describe "#code" do
+    it "returns the status code as an integer" do
+      _(error.code).must_equal 404
+    end
+  end
+
+  describe "#message" do
+    it "returns the status message" do
+      _(error.message).must_equal 'Not Found'
+    end
+  end
+
+  describe "#body" do
+    it "returns the response body" do
+      _(error.body).must_include 'Not Found'
+    end
+  end
+
+  describe "#to_s" do
+    it "includes the status code and message" do
+      _(error.to_s).must_equal 'HTTP 404: Not Found'
+    end
+  end
+
+  describe "inheritance" do
+    it "is a StandardError" do
+      _(error).must_be_kind_of StandardError
+    end
+
+    it "can be raised and rescued" do
+      assert_raises(WebDAV::Error) do
+        raise WebDAV::Error.new(mock_response)
+      end
+    end
+  end
+
+  describe "with a 401 status code" do
+    let(:mock_response) do
+      MockResponse.new(
+        code: '401',
+        message: 'Unauthorized',
+        body: ''
+      )
+    end
+
+    let(:error){WebDAV::Error.new(mock_response)}
+
+    it "handles a 401 error" do
+      _(error.code).must_equal 401
+      _(error.to_s).must_equal 'HTTP 401: Unauthorized'
+    end
+  end
+
+  describe "with a 500 status code" do
+    let(:mock_response) do
+      MockResponse.new(
+        code: '500',
+        message: 'Internal Server Error',
+        body: ''
+      )
+    end
+
+    let(:error){WebDAV::Error.new(mock_response)}
+
+    it "handles a 500 error" do
+      _(error.code).must_equal 500
+      _(error.to_s).must_equal 'HTTP 500: Internal Server Error'
+    end
+  end
+end

data/test/WebDAV/MultiStatus_test.rb

@@ -0,0 +1,102 @@
+# test/WebDAV/MultiStatus_test.rb
+
+require_relative '../helper'
+
+describe WebDAV::MultiStatus do
+  let(:multistatus_xml) do
+    <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <d:multistatus xmlns:d="DAV:">
+        <d:response>
+          <d:href>/dav/calendars/user/test/calendar1/</d:href>
+          <d:propstat>
+            <d:prop>
+              <d:displayname>Work</d:displayname>
+              <d:resourcetype><d:collection/></d:resourcetype>
+            </d:prop>
+            <d:status>HTTP/1.1 200 OK</d:status>
+          </d:propstat>
+        </d:response>
+        <d:response>
+          <d:href>/dav/calendars/user/test/calendar2/</d:href>
+          <d:propstat>
+            <d:prop>
+              <d:displayname>Personal</d:displayname>
+              <d:resourcetype><d:collection/></d:resourcetype>
+            </d:prop>
+            <d:status>HTTP/1.1 200 OK</d:status>
+          </d:propstat>
+        </d:response>
+      </d:multistatus>
+    XML
+  end
+
+  let(:mock_response) do
+    MockResponse.new(
+      code: '207',
+      message: 'Multi-Status',
+      body: multistatus_xml
+    )
+  end
+
+  let(:response){WebDAV::MultiStatus.new(mock_response)}
+
+  describe "#code" do
+    it "returns 207" do
+      _(response.code).must_equal 207
+    end
+  end
+
+  describe "#success?" do
+    it "returns true" do
+      _(response.success?).must_equal true
+    end
+  end
+
+  describe "#resources" do
+    it "returns an array" do
+      _(response.resources).must_be_kind_of Array
+    end
+
+    it "parses the correct number of resources" do
+      _(response.resources.length).must_equal 2
+    end
+
+    it "extracts href from each resource" do
+      _(response.resources[0][:href]).must_equal '/dav/calendars/user/test/calendar1/'
+      _(response.resources[1][:href]).must_equal '/dav/calendars/user/test/calendar2/'
+    end
+
+    it "extracts properties from each resource" do
+      _(response.resources[0][:properties]['displayname']).must_equal 'Work'
+      _(response.resources[1][:properties]['displayname']).must_equal 'Personal'
+    end
+
+    it "extracts status from each resource" do
+      _(response.resources[0][:status]).must_equal 'HTTP/1.1 200 OK'
+    end
+  end
+
+  describe "with empty multistatus" do
+    let(:empty_xml) do
+      <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <d:multistatus xmlns:d="DAV:">
+        </d:multistatus>
+      XML
+    end
+
+    let(:empty_response) do
+      MockResponse.new(
+        code: '207',
+        message: 'Multi-Status',
+        body: empty_xml
+      )
+    end
+
+    it "returns an empty array" do
+      r = WebDAV::MultiStatus.new(empty_response)
+      _(r.resources).must_equal []
+    end
+  end
+end

data/test/WebDAV/Response_test.rb

@@ -0,0 +1,60 @@
+# test/WebDAV/Response_test.rb
+
+require_relative '../helper'
+
+describe WebDAV::Response do
+  let(:mock_response) do
+    headers = {'ETag' => '"abc123"', 'Content-Type' => 'text/html'}
+    response = MockResponse.new(
+      code: '200',
+      message: 'OK',
+      body: '<html>Hello</html>',
+      headers_hash: headers
+    )
+    response
+  end
+
+  let(:response){WebDAV::Response.new(mock_response)}
+
+  describe "#code" do
+    it "returns the status code as an integer" do
+      _(response.code).must_equal 200
+    end
+  end
+
+  describe "#message" do
+    it "returns the status message" do
+      _(response.message).must_equal 'OK'
+    end
+  end
+
+  describe "#body" do
+    it "returns the response body" do
+      _(response.body).must_equal '<html>Hello</html>'
+    end
+  end
+
+  describe "#success?" do
+    it "returns true for 2xx responses" do
+      _(response.success?).must_equal true
+    end
+
+    it "returns false for 4xx responses" do
+      error_response = MockResponse.new(code: '404', message: 'Not Found', body: '')
+      r = WebDAV::Response.new(error_response)
+      _(r.success?).must_equal false
+    end
+  end
+
+  describe "#etag" do
+    it "returns the ETag header" do
+      _(response.etag).must_equal '"abc123"'
+    end
+  end
+
+  describe "#content_type" do
+    it "returns the Content-Type header" do
+      _(response.content_type).must_equal 'text/html'
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,13 @@
+# test/helper.rb
+
+require 'minitest/autorun'
+require 'minitest/mock'
+require 'minitest/spec'
+
+require_relative '../lib/webdav'
+
+MockResponse = Struct.new(:code, :message, :body, :headers_hash, keyword_init: true) do
+  def [](key)
+    headers_hash&.dig(key)
+  end
+end

data/test/webdav_test.rb

@@ -0,0 +1,254 @@
+# test/webdav_test.rb
+
+require_relative './helper'
+
+describe WebDAV do
+  let(:base_uri){'https://dav.example.com/files/'}
+  let(:username){'user'}
+  let(:password){'pass'}
+
+  let(:dav) do
+    WebDAV.new(base_uri, username: username, password: password)
+  end
+
+  let(:ok_response) do
+    MockResponse.new(
+      code: '200',
+      message: 'OK',
+      body: 'Hello'
+    )
+  end
+
+  let(:created_response) do
+    MockResponse.new(
+      code: '201',
+      message: 'Created',
+      body: ''
+    )
+  end
+
+  let(:no_content_response) do
+    MockResponse.new(
+      code: '204',
+      message: 'No Content',
+      body: ''
+    )
+  end
+
+  let(:multistatus_response) do
+    MockResponse.new(
+      code: '207',
+      message: 'Multi-Status',
+      body: <<~XML,
+        <?xml version="1.0" encoding="UTF-8"?>
+        <d:multistatus xmlns:d="DAV:">
+          <d:response>
+            <d:href>/files/doc.txt</d:href>
+            <d:propstat>
+              <d:prop>
+                <d:displayname>doc.txt</d:displayname>
+              </d:prop>
+              <d:status>HTTP/1.1 200 OK</d:status>
+            </d:propstat>
+          </d:response>
+        </d:multistatus>
+      XML
+    )
+  end
+
+  let(:not_found_response) do
+    MockResponse.new(
+      code: '404',
+      message: 'Not Found',
+      body: 'Not Found'
+    )
+  end
+
+  # Properties
+
+  describe "#propfind" do
+    it "returns a MultiStatus response" do
+      dav.stub(:request, multistatus_response) do
+        result = dav.propfind('/')
+        _(result).must_be_kind_of WebDAV::MultiStatus
+        _(result.resources.length).must_equal 1
+      end
+    end
+  end
+
+  describe "#proppatch" do
+    it "returns a MultiStatus response" do
+      dav.stub(:request, multistatus_response) do
+        result = dav.proppatch('/doc.txt', body: '<d:propertyupdate/>')
+        _(result).must_be_kind_of WebDAV::MultiStatus
+      end
+    end
+  end
+
+  # Reports
+
+  describe "#report" do
+    it "returns a MultiStatus response" do
+      dav.stub(:request, multistatus_response) do
+        result = dav.report('/calendars/', body: '<c:calendar-query/>')
+        _(result).must_be_kind_of WebDAV::MultiStatus
+      end
+    end
+  end
+
+  # Collections
+
+  describe "#mkcol" do
+    it "returns a Response" do
+      dav.stub(:request, created_response) do
+        result = dav.mkcol('/new_folder/')
+        _(result).must_be_kind_of WebDAV::Response
+        _(result.code).must_equal 201
+      end
+    end
+  end
+
+  # Namespace
+
+  describe "#copy" do
+    it "returns a Response" do
+      dav.stub(:request, created_response) do
+        result = dav.copy('/doc.txt', to: '/archive/doc.txt')
+        _(result).must_be_kind_of WebDAV::Response
+      end
+    end
+  end
+
+  describe "#move" do
+    it "returns a Response" do
+      dav.stub(:request, created_response) do
+        result = dav.move('/draft.txt', to: '/final.txt')
+        _(result).must_be_kind_of WebDAV::Response
+      end
+    end
+  end
+
+  # Locking
+
+  describe "#lock" do
+    it "returns a Response" do
+      dav.stub(:request, ok_response) do
+        result = dav.lock('/doc.txt', body: '<d:lockinfo/>')
+        _(result).must_be_kind_of WebDAV::Response
+      end
+    end
+  end
+
+  describe "#unlock" do
+    it "returns a Response" do
+      dav.stub(:request, no_content_response) do
+        result = dav.unlock('/doc.txt', token: 'urn:uuid:abc123')
+        _(result).must_be_kind_of WebDAV::Response
+        _(result.code).must_equal 204
+      end
+    end
+  end
+
+  # Standard HTTP
+
+  describe "#get" do
+    it "returns a Response with the body" do
+      dav.stub(:request, ok_response) do
+        result = dav.get('/doc.txt')
+        _(result).must_be_kind_of WebDAV::Response
+        _(result.body).must_equal 'Hello'
+      end
+    end
+  end
+
+  describe "#head" do
+    it "returns a Response" do
+      dav.stub(:request, ok_response) do
+        result = dav.head('/doc.txt')
+        _(result).must_be_kind_of WebDAV::Response
+      end
+    end
+  end
+
+  describe "#post" do
+    it "returns a Response" do
+      dav.stub(:request, ok_response) do
+        result = dav.post('/endpoint', body: '<data/>')
+        _(result).must_be_kind_of WebDAV::Response
+      end
+    end
+  end
+
+  describe "#put" do
+    it "returns a Response" do
+      dav.stub(:request, created_response) do
+        result = dav.put('/doc.txt', body: 'New content', content_type: 'text/plain')
+        _(result).must_be_kind_of WebDAV::Response
+        _(result.code).must_equal 201
+      end
+    end
+  end
+
+  describe "#patch" do
+    it "returns a Response" do
+      dav.stub(:request, ok_response) do
+        result = dav.patch('/doc.txt', body: '<patch/>')
+        _(result).must_be_kind_of WebDAV::Response
+      end
+    end
+  end
+
+  describe "#delete" do
+    it "returns a Response" do
+      dav.stub(:request, no_content_response) do
+        result = dav.delete('/doc.txt')
+        _(result).must_be_kind_of WebDAV::Response
+        _(result.code).must_equal 204
+      end
+    end
+  end
+
+  describe "#options" do
+    it "returns a Response" do
+      dav.stub(:request, ok_response) do
+        result = dav.options('/')
+        _(result).must_be_kind_of WebDAV::Response
+      end
+    end
+  end
+
+  describe "#trace" do
+    it "returns a Response" do
+      dav.stub(:request, ok_response) do
+        result = dav.trace('/')
+        _(result).must_be_kind_of WebDAV::Response
+      end
+    end
+  end
+
+  # Error handling
+
+  describe "error responses" do
+    it "raises WebDAV::Error for 404" do
+      dav.stub(:request, not_found_response) do
+        assert_raises(WebDAV::Error) do
+          dav.get('/missing.txt')
+        end
+      end
+    end
+
+    it "includes the status code in the error" do
+      dav.stub(:request, not_found_response) do
+        error = assert_raises(WebDAV::Error){dav.get('/missing.txt')}
+        _(error.code).must_equal 404
+      end
+    end
+
+    it "includes the message in the error" do
+      dav.stub(:request, not_found_response) do
+        error = assert_raises(WebDAV::Error){dav.get('/missing.txt')}
+        _(error.message).must_equal 'Not Found'
+      end
+    end
+  end
+end

data/webdav.gemspec

@@ -0,0 +1,29 @@
+require_relative './lib/WebDAV/VERSION'
+
+Gem::Specification.new do |spec|
+  spec.name = 'webdav'
+  spec.version = WebDAV::VERSION
+
+  spec.summary = "A Ruby WebDAV client library."
+  spec.description = "A Ruby WebDAV client library."
+
+  spec.author = 'thoran'
+  spec.email = 'code@thoran.com'
+  spec.homepage = 'https://github.com/thoran/webdav'
+  spec.license = 'MIT'
+
+  spec.required_ruby_version = '>= 2.7'
+
+  spec.add_dependency('http.rb')
+
+  spec.files = [
+    'webdav.gemspec',
+    'Gemfile',
+    Dir['lib/**/*.rb'],
+    'LICENSE',
+    'README.md',
+    Dir['test/**/*.rb']
+  ].flatten
+
+  spec.require_paths = ['lib']
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: webdav
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- thoran
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: http.rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Ruby WebDAV client library.
+email: code@thoran.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- lib/Net/HTTP/Report.rb
+- lib/String/to_const.rb
+- lib/Thoran/Array/AllButFirst/all_but_first.rb
+- lib/Thoran/Array/FirstX/firstX.rb
+- lib/Thoran/String/ToConst/to_const.rb
+- lib/WebDAV/Error.rb
+- lib/WebDAV/MultiStatus.rb
+- lib/WebDAV/Response.rb
+- lib/WebDAV/VERSION.rb
+- lib/webdav.rb
+- test/WebDAV/Error_test.rb
+- test/WebDAV/MultiStatus_test.rb
+- test/WebDAV/Response_test.rb
+- test/helper.rb
+- test/webdav_test.rb
+- webdav.gemspec
+homepage: https://github.com/thoran/webdav
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.8
+specification_version: 4
+summary: A Ruby WebDAV client library.
+test_files: []