open-uri-and-write 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+*~
+*#
+.#*

data/README.md

@@ -0,0 +1,116 @@
+OpenUriAndWrite
+===============
+
+OpenUriAndWrite is an easy to use wrapper for Net::Dav, making it as easy to write to WebDAV enabled webservers as local files.
+
+# Examples
+
+It is possible to open an http, https URL and write to it as though it were a file:
+
+```ruby
+  open("http://www.ruby-lang.org/open_uri_and_write.html","w") {|f|
+    f.puts "<h1>OpenUriAndWrite</h1>"
+  }
+```
+
+A more compact way would be:
+
+```ruby
+  open("http://www.ruby-lang.org/open_uri_and_write.html","w").puts "<h1>OpenUriAndWrite</h1>"
+```
+
+Files can be deleted as local files:
+
+```ruby
+  File.delete("http://www.ruby-lang.org/open_uri_and_write.html")
+```
+
+Directories are created the same way as local files.
+
+```ruby
+  Dir.mkdir("http://www.ruby-lang.org/open_uri_and_write")
+```
+
+# Proppatch and Propfind
+
+The only difference between local files and directories and remote files and directories on webdav servers, is that they both can have an infinite amount of properties. Properties are set as a xml snippet with proppatch() and accessed with propfind().
+
+```ruby
+    File.open("http://www.ruby-lang.org/open_uri_and_write.html","w").proppatch('<o:Author>Douglas Groncki</o:Author>')
+    props = Dir.propfind("http://www.ruby-lang.org") # Returns XML
+```
+
+# Interoperability with OpenURI
+
+To not interfer with the 'open-uri' standard library, the 'open-uri-and-write' gem is only active in file modes 'w','a','w+' and 'a+':
+
+```ruby
+  open("http://www.ruby-lang.org/open_uri_and_write.html","w").puts("<h1>HTML</h1>") # open-uri-and-write
+```
+
+If not any filemode is supplied, 'open-uri' is used:
+
+```ruby
+  puts open("http://www.ruby-lang.org").read()  # open-uri
+```
+
+# Authentication
+
+By default 'open-uri-and-write' will prompt for username and password.
+
+```
+  $ ruby webdav_test.rb
+  Username for www.example.com: scott
+  Password for 'scott@www.example.com: *****
+```
+
+Credentials can be supplied with the DAVUSER and DAVPASS environment variables.
+
+```
+  $ export DAVUSER=scott
+  $ export DAVPASS=tiger
+  $ ruby webdav_test.rb
+```
+
+```ruby
+  ENV['DAVUSER'] = 'scott'
+  ENV['DAVPASS'] = 'tiger'
+```
+
+
+Another option is to supply username and password as arguments to open():
+
+```ruby
+   file = open('https://www.example.com/', 'w', :username => 'scott', :password => 'tiger')
+```
+
+On OS X passwords typed in by user will be stored encrypted in the Keychain and reused later.
+
+```
+  $ export DAVUSER=scott
+  $ ruby webdav_test.rb
+  Password for 'scott@www.example.com': *****
+  Password for 'scott@www.example.com' stored on OS X KeyChain.
+```
+
+The next time this script is executed, it will not prompt for password.
+
+# Install
+
+This is work in progress, and not pushed as a gem yet.
+
+# Testing
+
+To run all tests:
+
+```
+  $ rake spec
+```
+
+The tests will start a webserver at startup, and close it down before finishing.
+
+# Credits
+
+  * Tanaka Akira for the inspiration taken from 'open-uri' standard library.
+  * Miron Cuperman for the 'net/dav' gem used to access webdav servers.
+

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'rake'
+require 'rspec/core/rake_task'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*spec.rb'
+end
+
+task :default => :spec

data/autotest.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'filewatcher'
+require 'paint'
+
+def run_tests
+  puts Paint['Testing', :yellow]
+  output = %x[ruby test/test-open-uri-and-write.rb]
+  if(output[/Failure:/])
+    puts output
+    puts Paint['Failure', :red, :bright]
+  else
+    puts output
+    puts Paint['Ok', :green, :bright]
+  end
+end
+
+run_tests
+files = ["lib/open-uri-and-write.rb", "test/test-open-uri-and-write.rb"]
+FileWatcher.new(files).watch(0.5) do |filename|
+  run_tests
+end

data/lib/open-uri-and-write/version.rb

@@ -0,0 +1,4 @@
+module OpenUriAndWrite
+  VERSION = "0.0.1"
+end
+

data/lib/open-uri-and-write.rb

@@ -0,0 +1,240 @@
+require 'stringio'
+require 'uri'
+require 'open-uri'
+require 'net/dav'
+require 'highline/import'
+
+
+# A wrapper for Net::Dav that acts as a replacement for the File class
+class WebDavAgent < StringIO
+
+  alias_method :original_puts, :puts
+  attr_accessor :dav
+
+  def initialize(url, rest)
+    super("")
+    @url = url
+    @uri = URI.parse(url)
+    if(rest.size > 0)
+      if(rest.first.to_s[/^[wa]/])
+        @dav = Net::DAV.new(@url)
+        options = rest[1]
+        if(options && options[:username] && options[:password])
+          @dav.credentials(options[:username], options[:password])
+        else
+          set_credentials
+        end
+      end
+
+      if(rest.first.to_s[/^a/])
+        write(@dav.get(@url)) # write to stringIO
+      end
+
+    end
+  end
+
+  def set_credentials
+    if(ENV['DAVUSER'])
+      username = ENV['DAVUSER']
+    # elsif(ENV['USER'])
+    #  username = ENV['USER']
+    else
+      username = ask("Username for #{@uri.host}: ")
+    end
+
+    if(ENV['DAVPASS'])
+      password = ENV['DAVPASS']
+    else
+      osx = (RUBY_PLATFORM =~ /darwin/)
+      osx_keychain = false
+      if(osx)
+        begin
+          require 'osx_keychain'
+          osx_keychain = true
+        rescue LoadError
+        end
+      end
+      if(osx_keychain)then
+          keychain = OSXKeychain.new
+          password = keychain[@uri.host, username ]
+          if(!password)
+            password = ask("Password for '#{username}@#{@uri.host}: ") {|q| q.echo = "*"}
+            keychain[@uri.host, username] = password
+            puts "Password for '#{username}@#{@uri.host}' stored on OS X KeyChain."
+          end
+
+      else
+        password = ask("Password for '#{username}@#{@uri.host}: ") {|q| q.echo = "*"}
+      end
+    end
+    @dav.credentials(username, password)
+  end
+
+  def puts(string)
+    super(string)
+    @dav.put_string(@url, string)
+  end
+
+  def read
+    @dav.get(@url)
+  end
+
+  def proppatch(xml_snippet)
+    @dav.proppatch(@uri, xml_snippet)
+  end
+
+  def propfind
+    @dav.propfind(@url)
+  end
+
+  def close
+    @dav.put_string(@url, string)
+  end
+
+end
+
+# Kernel extensions
+# Careful monkeypatching
+module Kernel
+  private
+  alias open_uri_and_write_original open # :nodoc:
+
+  def open(name, *rest, &block) # :doc:
+    if name.respond_to?(:open)
+      name.open(*rest, &block)
+    elsif name.respond_to?(:to_s) and
+          name[/^(https?):\/\//] and
+          rest.size > 0 and
+          rest.first.to_s[/^[rwa]/] and
+          not (rest.first.to_s == 'r' or rest.first.to_s == 'rb')
+          webdav_agent = WebDavAgent.new(name, rest)
+      if(block)
+        yield webdav_agent
+      else
+        return webdav_agent
+      end
+    else
+      open_uri_and_write_original(name, *rest, &block)
+    end
+  end
+
+  module_function :open
+end
+
+# Store credentials for later use in sesssion.
+class WebDavCredentialsPool
+
+  def self.get_connection_for_url(url)
+    hostname = URI.parse(url).host.to_s
+    if(!$_webdav_credentials_pool)
+      $_webdav_credentials_pool = { }
+    end
+    if($_webdav_credentials_pool[hostname])
+      return $_webdav_credentials_pool[hostname]
+    else(!$_webdav_credentials_pool[hostname])
+      agent = WebDavAgent.new(url, ['w'])
+      $_webdav_credentials_pool[hostname] = agent.dav
+      return agent.dav
+    end
+  end
+
+end
+
+
+# More monkeypatching
+class Dir
+
+  class << self
+    alias original_mkdir mkdir
+    alias original_rmddir rmdir
+  end
+
+  def self.mkdir(name)
+    if name.respond_to?(:to_s) and name[/^(https?):\/\//]
+      dav = WebDavCredentialsPool.get_connection_for_url(name)
+      dav.mkdir(name)
+    else
+      self.original_mkdir(name)
+    end
+  end
+
+  def self.rmdir(name)
+    if name.respond_to?(:to_s) and name[/^(https?):\/\//]
+      dav = WebDavCredentialsPool.get_connection_for_url(name)
+      dav.delete(name)
+    else
+      self.original_rmdir(name)
+    end
+  end
+
+  def self.propfind(name)
+    if name.respond_to?(:to_s) and name[/^(https?):\/\//]
+      dav = WebDavCredentialsPool.get_connection_for_url(name)
+      dav.propfind(name)
+    else
+      # TODO Throw illegal action exception
+    end
+  end
+
+  def self.proppatch(name,xml_snippet)
+    if name.respond_to?(:to_s) and name[/^(https?):\/\//]
+      dav = WebDavCredentialsPool.get_connection_for_url(name)
+      dav.propfind(name, xml_snippet)
+    else
+      # TODO Throw illegal action exception
+    end
+  end
+
+end
+
+# Even more monkeypatching
+class File
+
+  class << self
+    alias original_delete delete
+    alias original_open open
+    alias original_exists? exists?
+  end
+
+  def self.exists?(name)
+    if(name[/https?:\/\//])
+      dav = WebDavCredentialsPool.get_connection_for_url(name)
+      dav.exists?(name)
+    else
+      self.original_exists?(name)
+    end
+  end
+
+  def self.delete(names)
+    filenames = []
+    if(names.class == String)
+      filenames << names
+    elsif(names.class = Array)
+      filenames = names
+    end
+    filenames.each do |filename|
+      if(filename[/^(https?):\/\//])
+        dav = WebDavCredentialsPool.get_connection_for_url(filename)
+        dav.delete(filename)
+      else
+        self.original_delete(filename)
+      end
+    end
+  end
+
+  def self.open(name, *rest, &block)
+    if name.respond_to?(:open)
+      name.open(*rest, &block)
+    elsif name.respond_to?(:to_s) and name[/^(https?):\/\//] and rest.size > 0 and rest.first.to_s[/^w/]
+      webdav_agent = WebDavAgent.new(name, rest)
+      if(block)
+        yield webdav_agent
+      else
+        return webdav_agent
+      end
+    else
+      self.original_open(name, *rest, &block)
+    end
+  end
+
+end

data/open-uri-and-write.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "open-uri-and-write/version"
+
+Gem::Specification.new do |s|
+  s.name        = "open-uri-and-write"
+  s.version     = OpenUriAndWrite::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Thomas Flemming"]
+  s.email       = ["thomas.flemming@gmail.com"]
+  s.homepage    = "https://github.com/thomasfl/open-uri-and-write"
+  s.summary     = %q{An easy to use wrapper for Net::Dav, for writing files to WebDAV enabled web servers.}
+  s.description = %q{Use normal file operations to write files to WebDAV enabled web servers.}
+
+  s.add_runtime_dependency "highline", "~>1.6.9"
+  s.add_runtime_dependency "net_dav", "~>0.5.0"
+  s.add_development_dependency "rspec", "~>2.5.0"
+  s.add_development_dependency "pry", "~>0.9.8.4"
+  s.add_development_dependency "dav4rack", "~>0.2.10" 
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/integration/dav4rack_testserver.rb

@@ -0,0 +1,104 @@
+require 'rubygems'
+require 'dav4rack'
+require 'dav4rack/file_resource'
+# require 'unicorn'
+require 'pathname'
+
+
+$publish_dates = { } # Global hashmap to hold publish-dates for all resources
+
+class DAV4Rack::Controller
+
+  alias_method :original_proppatch, :proppatch
+
+  # Monkeypatch the proppatch method, so we can proppatch custom properties
+  def proppatch
+    input = request.body.read
+
+    req = Nokogiri::XML(input)
+    # puts "PROPPATCH"
+    # puts input
+
+    publish_date = req.xpath("//publish-date","D" => "DAV").text
+    if(publish_date != "")
+      # puts request.path + " = " + publish_date
+      $publish_dates[request.path] = publish_date
+    end
+
+    request.body.rewind
+    original_proppatch
+  end
+
+end
+
+# Custom DAV4Rack resourceclass to handle PROPPATCH
+class MyResource < DAV4Rack::FileResource
+
+  def property_names
+    super << 'publish-date'
+  end
+
+  def get_property(name)
+    if(name == "publish-date")
+      if($publish_dates[path])
+        return $publish_dates[path]
+      else
+        return nil
+      end
+    else
+      super(name)
+    end
+  end
+
+  # TODO: Can't figure out why this method is never called.
+  def set_property(name, value)
+    puts "Debug 2: setting property #{name}:#{value}"
+    super(name)
+  end
+
+end
+
+
+# Starts a WebDAV server using dav4rack and unicorn
+def start_dav4rack(port, root)
+  options = {:resource_class => MyResource, :root => root }
+
+  app = Rack::Builder.new do
+    use Rack::ShowExceptions
+    # use Rack::CommonLogger  # Display all requests
+    use Rack::Reloader
+    use Rack::Lint
+    run DAV4Rack::Handler.new(options)
+  end.to_app
+
+  runners = []
+
+  runners << lambda do |x|
+    puts 'Starting WEBrick'
+    Rack::Handler::WEBrick.run(x, :Port => port)
+  end
+
+  begin
+    runner = runners.shift
+    runner.call(app)
+  rescue LoadError
+    puts 'FAILED'
+    retry unless runners.empty?
+  end
+
+end
+
+if __FILE__ == $0
+
+  port = "3003"
+  options = {}
+  # options[:username] = "davuser"
+  # options[:password] = "davpass"
+  path = '/tmp/webdav_server_root'
+  puts "Starting server in " + path
+  options[:root] = path
+
+  start_dav4rack(port, options)
+end
+
+# start_dav4rack(3003)

data/spec/integration/open-uri-and-write-spec.rb

@@ -0,0 +1,174 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/dav4rack_testserver')
+
+# To run:
+#  $ rake spec
+
+describe "OpenUriAndWrite" do
+
+  before(:all) do
+    start_webdav_server(:port => 3003)
+    @base_uri = "http://localhost:3003/"
+  end
+
+  after(:all) do
+    # Shut down webdav server:
+    stop_webdav_server
+  end
+
+  it "should write to local file normally" do
+    timestamp = Time.now.to_s
+    filename = '/tmp/local_test_file.txt'
+    file = open(filename,'w')
+    file.puts timestamp
+    file.close
+
+    open(filename).read.strip.should == timestamp
+  end
+
+  it "should write files to webdav server and standard lib open-uri" do
+    timestamp = Time.now.to_s
+    webdav_url = @base_uri + 'webdav_test_1.txt'
+    file = open(webdav_url,'w')
+    file.puts timestamp
+    file.close
+
+    file = open(webdav_url).read.strip.should == timestamp
+  end
+
+  it "should write to files with block syntax" do
+    timestamp = Time.now.to_s
+    webdav_url = @base_uri + 'webdav_test_2.txt'
+    open(webdav_url,'w') do |file|
+      file.puts timestamp
+    end
+
+    file = open(webdav_url).read.strip.should == timestamp
+  end
+
+  it "should open write to file with the file class and flush with close" do
+    timestamp = Time.now.to_s
+    webdav_url = @base_uri + 'webdav_test_3.txt'
+    file = File.open(webdav_url,'w')
+    file.puts(timestamp)
+    file.puts('XYZ')
+    file.close
+
+    open(webdav_url,'w').read.strip.should ==  timestamp + "\nXYZ"
+  end
+
+  it "should read properties of files" do
+    filename = 'webdav_test_4.txt'
+    webdav_url = @base_uri + filename
+    open(webdav_url,'w').puts(Time.now.to_s)
+
+    properties = open(webdav_url,'w').propfind
+    displayname = properties.xpath("//d:displayname", "d" => "DAV:").text
+    displayname.should == filename
+  end
+
+  it "should set properties on files" do
+    filename = 'webdav_test_5.txt'
+    webdav_url = @base_uri + filename
+    open(webdav_url,'w').puts(Time.now.to_s)
+
+    publish_date = Time.now.httpdate.to_s
+    open(webdav_url,'w').proppatch("<D:publish-date>#{publish_date}</D:publish-date>")
+    properties = open(webdav_url,'w').propfind
+    property = properties.to_s[/publish-date>([^<]*)/,1]
+    property.should == publish_date
+  end
+
+  it "should append to files" do
+    file = open(@base_uri + "append_file_test.txt", "w")
+    file.puts "Line 1"
+    file.puts "Line 2"
+    file.close
+
+    file = open(@base_uri + "append_file_test.txt", "a")
+    file.puts "Line 3"
+    file.puts "Line 4"
+    file.close
+
+    file = open(@base_uri + "append_file_test.txt")
+    lines = file.readlines
+    file.close
+    lines[3].should eql("Line 4\n")
+  end
+
+  it "should create and delete directory" do
+    # timestamp = Time.now.to_s
+    webdav_url = @base_uri + 'new_test_folder'
+    Dir.mkdir(webdav_url)
+    File.exists?(webdav_url).should == true
+
+    Dir.rmdir(webdav_url)
+    # There seems to be a bug in our testserver that prevent it from deleting files
+    # File.exists?(webdav_url).should == false
+  end
+
+  # TODO Test this in a separate script just to be sure
+  it "should not matter which order the rubygems 'open-uri' and 'open-uri-and-write' is loaded" do
+    # http://ruby-doc.org/core-1.9.3/Object.html
+    # http://stackoverflow.com/questions/335530/how-do-you-detect-that-monkey-patching-has-occurred-in-ruby
+    # http://blog.sidu.in/2007/12/rubys-methodadded.html
+  end
+
+  it "should handle username and password supplied as parameter to open" do
+    webdav_url = @base_uri + 'yet_another_testfile.txt'
+    file = open(webdav_url, 'w', :username => 'username', :password => 'secret')
+    file.puts "Content"
+    file.close
+
+    begin
+      file = open(webdav_url, 'w+', :username => 'username', :password => 'secret')
+      file.read
+      should fail
+    rescue Exception => e
+    end
+  end
+
+# TODO Test all modes:
+
+# r
+# Read-only mode. The file pointer is placed at the beginning of
+# the file. This is the default mode.
+#
+# r+
+# Read-write mode. The file pointer will be at the beginning of the file.
+#
+# w
+# Write-only mode.
+#   - Overwrites the file if the file exists.
+#   - If the file does not exist, creates a new file for writing.
+#
+# w+
+# Read-write mode.
+#   - Overwrites the existing file if the file exists.
+#   - If the file does not exist, creates a new file for reading and writing.
+#
+# a
+# Write-only mode.
+#    - The file pointer is at the end of the file if the file exists.
+#    - That is, the file is in the append mode.
+#    - If the file does not exist, it creates a new file for writing.
+#
+# a+
+# Read and write mode.
+#    - The file pointer is at the end of the file if the file exists.
+#    - The file opens in the append mode.
+#    - If the file does not exist, it creates a new file for reading and writing.
+#
+# r+, w+, and a+ all do read-write. w+ truncates the file. a+ appends.
+# w+ and a+ both create the file if it does not exist.)
+
+#   # TODO test authentication
+
+  after(:each) do
+    url = @base_uri + 'webdav_test.txt'
+    if(File.exists?(url))
+      File.delete(url)
+    end
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,62 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
+require 'open-uri-and-write'
+require 'rspec'
+require 'net/http'
+require 'uri'
+require 'pathname'
+require 'nokogiri'
+require 'pry'
+
+
+ENV['DAVUSER'] = 'dummy'
+ENV['DAVPASS'] = 'dummy'
+
+RSpec.configure do  |config|
+end
+
+def stop_webdav_server
+  Process.kill('SIGKILL', $pid) rescue nil
+end
+
+def start_webdav_server(*args)
+  port = args.first[:port].to_s
+  @base_uri = "http://localhost:#{port}/"
+
+  server_root = '/tmp/open_uri_and_write_test'
+  %x[rm -r #{server_root}]
+  %x[mkdir #{server_root}]
+
+  if(not(server_up?(@base_uri)))
+    options = {}
+
+    # Start webdav server in subprocess
+    $pid = fork do
+      start_dav4rack(port, server_root)
+    end
+
+    wait_for_server(@base_uri)
+  else
+    puts "Server is running."
+  end
+
+end
+
+def server_up?(address)
+  begin
+    return Net::HTTP.get_response(URI(address)).code == "200"
+  rescue Exception => e
+    puts e.to_s
+    return false
+  end
+end
+
+def wait_for_server(address)
+  puts "Waiting for WebDAV server to start#{address}"
+  sleep(0.5)
+  while(not(server_up?(address)))
+    puts "retrying"
+    sleep(0.5)
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: open-uri-and-write
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Thomas Flemming
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: &70101881835880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.9
+  type: :runtime
+  prerelease: false
+  version_requirements: *70101881835880
+- !ruby/object:Gem::Dependency
+  name: net_dav
+  requirement: &70101881835200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70101881835200
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70101881834480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+  type: :development
+  prerelease: false
+  version_requirements: *70101881834480
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: &70101881833800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.8.4
+  type: :development
+  prerelease: false
+  version_requirements: *70101881833800
+- !ruby/object:Gem::Dependency
+  name: dav4rack
+  requirement: &70101881833060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.10
+  type: :development
+  prerelease: false
+  version_requirements: *70101881833060
+description: Use normal file operations to write files to WebDAV enabled web servers.
+email:
+- thomas.flemming@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- README.md
+- Rakefile
+- autotest.rb
+- lib/open-uri-and-write.rb
+- lib/open-uri-and-write/version.rb
+- open-uri-and-write.gemspec
+- spec/integration/dav4rack_testserver.rb
+- spec/integration/open-uri-and-write-spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+homepage: https://github.com/thomasfl/open-uri-and-write
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: An easy to use wrapper for Net::Dav, for writing files to WebDAV enabled
+  web servers.
+test_files:
+- spec/integration/dav4rack_testserver.rb
+- spec/integration/open-uri-and-write-spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb