open-uri-and-write 0.0.1 → 0.1.0

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2012 Thomas Flemming
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -3,9 +3,10 @@ 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
+Examples
+--------
 
-It is possible to open an http, https URL and write to it as though it were a file:
+It is possible to open an http/https URL and write to it as though it were a local file:
 
 ```ruby
   open("http://www.ruby-lang.org/open_uri_and_write.html","w") {|f|
@@ -13,7 +14,7 @@ It is possible to open an http, https URL and write to it as though it were a fi
   }
 ```
 
-A more compact way would be:
+With method chaining it gets more compact:
 
 ```ruby
   open("http://www.ruby-lang.org/open_uri_and_write.html","w").puts "<h1>OpenUriAndWrite</h1>"
@@ -25,46 +26,31 @@ Files can be deleted as local files:
   File.delete("http://www.ruby-lang.org/open_uri_and_write.html")
 ```
 
-Directories are created the same way as local files.
+Directories are created the same way as local files:
 
 ```ruby
   Dir.mkdir("http://www.ruby-lang.org/open_uri_and_write")
 ```
 
-# Proppatch and Propfind
+Authentication
+--------------
+By default the scripts prompts the user for username and password. The username and hostname are stored in the file ~/.open-uri-and-write-usernames, so the next time only the password has to be typed in. On OSX the password is stored encrypted in the keychain.
 
-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().
+Credentials can also supplied as environment variables or options.
 
-```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.
+Default behaviour if no username or password is set:
 
 ```
   $ ruby webdav_test.rb
   Username for www.example.com: scott
   Password for 'scott@www.example.com: *****
+  Username and hostname stored in /Users/thomasf/.open-uri-and-write-usernames
+
+  $ ruby webdav_test.rb
+  Password for 'scott@www.example.com: *****
 ```
 
-Credentials can be supplied with the DAVUSER and DAVPASS environment variables.
+Supplying credentials with the DAVUSER and DAVPASS environment variables:
 
 ```
   $ export DAVUSER=scott
@@ -72,19 +58,20 @@ Credentials can be supplied with the DAVUSER and DAVPASS environment variables.
   $ ruby webdav_test.rb
 ```
 
+Setting username and password in ruby:
+
 ```ruby
   ENV['DAVUSER'] = 'scott'
   ENV['DAVPASS'] = 'tiger'
 ```
 
-
-Another option is to supply username and password as arguments to open():
+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.
+On OS X passwords typed in by the user will be stored encrypted in the Keychain and reused later.
 
 ```
   $ export DAVUSER=scott
@@ -93,24 +80,93 @@ On OS X passwords typed in by user will be stored encrypted in the Keychain and
   Password for 'scott@www.example.com' stored on OS X KeyChain.
 ```
 
-The next time this script is executed, it will not prompt for password.
+The next time this script is executed, it will not prompt for username and password.
+
+Proppatch and Propfind
+----------------------
 
-# Install
+In difference to files and directories on local filesystems, files and directories on WebDAV servers can have many custom properties. Properties can be read with til propfindare set as a xml snippet with proppatch() and accessed with propfind().
 
-This is work in progress, and not pushed as a gem yet.
+```ruby
+    file = File.open('http://www.ruby-lang.org/open_uri_and_write.html','w')
+    file.proppatch('<D:Author>Thomas Flemming</D:Author>')
+    properties_as_xml = Dir.propfind("http://www.ruby-lang.org")
+```
+
+Interoperability with OpenURI
+-----------------------------
 
-# Testing
+If no filemode is specified when using open on url, standard 'open-uri' will be used.
+
+```ruby
+  puts open("http://www.ruby-lang.org").read()  # Use 'open-uri'
+  open('http://www.ruby-lang.org/my_page.html','w').puts("<h1>HTML</h1>") # Use 'open-uri-and-write'
+```
 
+To not interfer with the 'open-uri' standard library, the 'open-uri-and-write' gem is only active in file modes 'w','a','w+','a+' and 'r+'.
+
+Supported file access modes
+===========================
+
+Unspported file access 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.
+
+
+
+Install
+-------
+
+```
+  $ gem install open-uri-and-write
+```
+
+For OSX users this will store password on the keychain.
+
+```
+  $ gem install keychain_services
+```
+
+Note that if you have stored a misspelled password on the OSX Keychain, then you will have to delete it manually with Keychain Access application.
+
+Testing
+-------
 To run all tests:
 
 ```
   $ rake spec
 ```
 
-The tests will start a webserver at startup, and close it down before finishing.
+The tests will start a webserver with webdav at startup, and close it down before finishing.
+
+Future work
+-----------
+This is work in progress. You can write files and crate directories, but there's still work to do on reading directories and at the time one filemodes "r", "w" and "a" is supported.
+
+More protocols like FTP, SCP and Amazon S3 would be useful.
+
+Credits
+-------
+
+  * Tanaka Akira for the inspirational ['open-uri'](https://github.com/ruby/ruby/blob/trunk/lib/open-uri.rb) standard ruby library.
+  * Miron Cuperman for the ['net/dav'](https://github.com/devrandom/net_dav) gem used to access webdav servers.
+  * Chris Roberts and the rest of the DAV4Rack for the WebDAV implementation in ruby used for testing this gem.
 
-# Credits
+Author
+------
 
-  * Tanaka Akira for the inspiration taken from 'open-uri' standard library.
-  * Miron Cuperman for the 'net/dav' gem used to access webdav servers.
+Thomas Flemming
 
+  * [@thomasfl](https://twitter.com/#!/thomasfl)
+  * [http://github.com/thomasfl/](http://github.com/thomasfl/)

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

@@ -4,237 +4,9 @@ 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
+require 'open-uri-and-write/handle'
+require 'open-uri-and-write/usernames'
+require 'open-uri-and-write/credentials_store'
+require 'open-uri-and-write/file_extensions'
+require 'open-uri-and-write/dir_extensions'
+require 'open-uri-and-write/kernel_extensions'

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

@@ -0,0 +1,23 @@
+# Store credentials for later use in sesssion.
+
+module OpenUriAndWrite
+
+  class CredentialsStore
+
+    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 = OpenUriAndWrite::Handle.new(url, ['w'])
+        $_webdav_credentials_pool[hostname] = agent.dav
+        return agent.dav
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,46 @@
+# Extensions and modifications (monkeypatching) to the Dir class:
+
+class Dir
+
+  class << self
+    alias original_mkdir mkdir
+    alias original_rmddir rmdir
+  end
+
+  def self.mkdir(name, *args)
+    if name.respond_to?(:to_s) and name[/^(https?):\/\//]
+      dav = OpenUriAndWrite::CredentialsStore.get_connection_for_url(name)
+      dav.mkdir(name)
+    else
+      self.original_mkdir(name, *args)
+    end
+  end
+
+  def self.rmdir(name)
+    if name.respond_to?(:to_s) and name[/^(https?):\/\//]
+      dav = OpenUriAndWrite::CredentialsStore.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 = OpenUriAndWrite::CredentialsStore.get_connection_for_url(name)
+      dav.propfind(name)
+    else
+      raise IOError.new(true), "Illegal action: Can't do propfind #{name}"
+    end
+  end
+
+  def self.proppatch(name,xml_snippet)
+    if name.respond_to?(:to_s) and name[/^(https?):\/\//]
+      dav = OpenUriAndWrite::CredentialsStore.get_connection_for_url(name)
+      dav.propfind(name, xml_snippet)
+    else
+      raise IOError.new(true), "Illegal action: Can't do proppatch on #{name}"
+    end
+  end
+
+end

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

@@ -0,0 +1,52 @@
+# Extensions and modifications (monkeypatching) to the File class:
+
+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 = OpenUriAndWrite::CredentialsStore.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 = OpenUriAndWrite::CredentialsStore.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 = OpenUriAndWrite::Handle.new(name, rest)
+      if(block)
+        yield webdav_agent
+      else
+        return webdav_agent
+      end
+    else
+      self.original_open(name, *rest, &block)
+    end
+  end
+
+end

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

@@ -0,0 +1,106 @@
+# OpenUriAndWrite file handler. Does authentication upon initialize
+
+module OpenUriAndWrite
+
+  class Handle < StringIO
+
+    alias_method :original_puts, :puts
+    attr_accessor :dav, :filemode
+
+    def initialize(url, rest)
+      super("")
+      @url = url
+      @uri = URI.parse(url)
+      if(rest.size > 0)
+        @filemode = rest.first.to_s
+        if(@filemode[/^[rwa]/])
+          @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(@filemode[/^a/])
+          write(@dav.get(@url)) # Write to StringIO
+        end
+
+      end
+    end
+
+    def set_credentials
+      if(ENV['DAVUSER'])
+        username = ENV['DAVUSER']
+      else
+        usernames = OpenUriAndWrite::Usernames.new()
+        username = usernames.username_for_host(@uri.host)
+        if(not(username))
+          username = ask("Username for #{@uri.host}: ")
+          usernames.save_username_and_host(username,@uri.host)
+          STDOUT.puts "Username and hostname stored in #{usernames.usernamesfile}"
+        end
+      end
+
+      password = nil
+      if(ENV['DAVPASS'])
+        password = ENV['DAVPASS']
+      else
+        osx = (RUBY_PLATFORM =~ /darwin/)
+        osx_keychain = false
+        if(osx)
+          begin
+            require 'keychain'
+            osx_keychain = true
+          rescue LoadError
+          end
+        end
+        if(osx_keychain)then
+          item = Keychain.items.find { |item| item.label =~ /#{@uri.host}/ }
+          if(item)
+            password = item.password
+          end
+
+          if(!password)
+            password = ask("Password for '#{username}@#{@uri.host}: ") {|q| q.echo = "*"}
+            Keychain.add_internet_password(@uri.host, '', username, '', password)
+            STDOUT.puts "Password for '#{username}@#{@uri.host}' stored on OSX KeyChain."
+          end
+
+        else
+          password = ask("Password for '#{username}@#{@uri.host}: ") {|q| q.echo = "*"}
+        end
+      end
+      @dav.credentials(username, password)
+    end
+
+    def puts(string)
+      if(@filemode[/^r/])
+        raise IOError.new(true), "not opened for writing"
+      end
+
+      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
+
+end
+

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

@@ -0,0 +1,28 @@
+# 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]/]
+      webdav_agent = OpenUriAndWrite::Handle.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
+
+

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

@@ -0,0 +1,51 @@
+# For storing usernames and hostnames in ~/.open-uri-and-write-usernames
+
+module OpenUriAndWrite
+
+  class Usernames
+
+    def homedir
+      if(Dir.respond_to?("home"))
+        Dir.home
+      else
+        File.expand_path("~")
+      end
+    end
+
+    def usernamesfile
+      homedir + "/.open-uri-and-write-usernames"
+    end
+
+    def read_usernames_and_hosts
+      usernames = {}
+      if(File.exist?(usernamesfile))
+        open(usernamesfile).readlines.each do |line|
+          username, host = line.split(':')
+          usernames[host.strip] = username.strip
+        end
+      end
+      return usernames
+    end
+
+    def save_username_and_host(username,host)
+      usernames = read_usernames_and_hosts
+      usernames[host] = username
+      store_username_and_host(usernames)
+    end
+
+    def store_username_and_host(usernames)
+      file = open(usernamesfile, "w")
+      usernames.keys.each do |key|
+        file.puts "#{usernames[key]}:#{key}"
+      end
+      file.close
+    end
+
+    def username_for_host(host)
+      usernames = read_usernames_and_hosts
+      return usernames[host]
+    end
+
+  end
+end
+

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

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

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

@@ -128,11 +128,34 @@ describe "OpenUriAndWrite" do
     end
   end
 
+  it "should not use 'open-uri' to read file in 'r' filemode" do
+    timestamp = Time.now.to_s
+    webdav_url = @base_uri + 'webdav_r_filemode_test.txt'
+    file = open(webdav_url,'w')
+    file.puts timestamp
+    file.class.should == OpenUriAndWrite::Handle
+    file.close
+
+    file = open(webdav_url)
+    file.class.should == StringIO # StringIO means 'open-uri' gem is beeing used
+    file.read.strip.should == timestamp
+
+    file = open(webdav_url,'r')
+    file.class.should == OpenUriAndWrite::Handle
+    file.read.strip.should == timestamp
+    begin
+      file.puts("this should not be written")
+      fail
+    rescue IOError => ioError
+    end
+    file.close
+  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.
+# OK 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.
@@ -162,6 +185,8 @@ describe "OpenUriAndWrite" do
 # 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: Store username and hostname in .open-uri-and-write-hosts
+
 #   # TODO test authentication
 
   after(:each) do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: open-uri-and-write
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-23 00:00:00.000000000 Z
+date: 2012-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: highline
-  requirement: &70101881835880 !ruby/object:Gem::Requirement
+  requirement: &70128528057900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 1.6.9
   type: :runtime
   prerelease: false
-  version_requirements: *70101881835880
+  version_requirements: *70128528057900
 - !ruby/object:Gem::Dependency
   name: net_dav
-  requirement: &70101881835200 !ruby/object:Gem::Requirement
+  requirement: &70128537727960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 0.5.0
   type: :runtime
   prerelease: false
-  version_requirements: *70101881835200
+  version_requirements: *70128537727960
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70101881834480 !ruby/object:Gem::Requirement
+  requirement: &70128537727120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 2.5.0
   type: :development
   prerelease: false
-  version_requirements: *70101881834480
+  version_requirements: *70128537727120
 - !ruby/object:Gem::Dependency
   name: pry
-  requirement: &70101881833800 !ruby/object:Gem::Requirement
+  requirement: &70128537726640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 0.9.8.4
   type: :development
   prerelease: false
-  version_requirements: *70101881833800
+  version_requirements: *70128537726640
 - !ruby/object:Gem::Dependency
   name: dav4rack
-  requirement: &70101881833060 !ruby/object:Gem::Requirement
+  requirement: &70128537726080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,7 +65,7 @@ dependencies:
         version: 0.2.10
   type: :development
   prerelease: false
-  version_requirements: *70101881833060
+  version_requirements: *70128537726080
 description: Use normal file operations to write files to WebDAV enabled web servers.
 email:
 - thomas.flemming@gmail.com
@@ -74,10 +74,17 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- LICENSE
 - README.md
 - Rakefile
 - autotest.rb
 - lib/open-uri-and-write.rb
+- lib/open-uri-and-write/credentials_store.rb
+- lib/open-uri-and-write/dir_extensions.rb
+- lib/open-uri-and-write/file_extensions.rb
+- lib/open-uri-and-write/handle.rb
+- lib/open-uri-and-write/kernel_extensions.rb
+- lib/open-uri-and-write/usernames.rb
 - lib/open-uri-and-write/version.rb
 - open-uri-and-write.gemspec
 - spec/integration/dav4rack_testserver.rb