bcms_webdav 1.0.0

data/COPYRIGHT.txt

@@ -0,0 +1,23 @@
+All BrowserCMS code is Copyright (C) 1998-2010 by BrowserMedia, LLC.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+BrowserCMS is a registered trademark of BrowserMedia, LLC.
+
+BrowserCMS includes works under other copyright notices and distributed
+according to the terms of the GNU Lesser Public License or a compatible
+license, including:
+
+- jQuery - Copyright (C) 2009 John Resig
+- CKEditor - Copyright (C) 2003-2009 Frederico Caldeira Knabben

data/LICENSE.txt

@@ -0,0 +1,165 @@
+		   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions. 
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version. 
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/README.rdoc

@@ -0,0 +1,107 @@
+== WebDAV
+
+Allow access to a BrowserCMS site via WebDAV. The primary intent of this module currently is to allow bulk upload of files using an FTP client.
+Clients which support WebDAV in addition to FTP may be used to review and upload/download Files. This module is implemented as
+as Rack Middleware.
+
+For more information on WebDAV see: http://en.wikipedia.org/wiki/WebDAV
+
+=== Features
+
+* Authorized users can list pages, sections and files that exist in the content library.
+* Authorized users can download files via WebDAV.
+* Authorized users can upload files via WebDAV.
+* Users must have 'Administer CMS' permissions in order to access resources via WebDAV.
+* Users can use their normal cms username and password.
+
+=== Clients
+
+In order to take advantage of this module, users will need a WebDAV client. Many FTP clients will support this, including:
+
+* Transmit (Mac OS) -  http://panic.com/transmit/
+* CrossFTP Pro (Windows, etc) - http://www.crossftp.com/
+
+This module has been tested with both of the above client. In addition, operating systems support accessing WebDAV
+servers via mounted drives. See: http://en.wikipedia.org/wiki/WebDAV for more discussion.
+
+=== Installation
+
+Due to the dependancy on rack 1.1.0 or later, this gem only works with a Rails 2.3.11 project, so you may need to upgrade older rails projects before using.
+
+    gem install bcms_webdav
+
+Add the gem to your project.
+
+    # config/environment.rb
+    config.gem 'dav4rack'
+    config.gem 'bcms_webdav'
+
+Add the following file to your project.
+
+    # config/initializers/bcms_webdav.rb
+    Rails.configuration.middleware.use Bcms::WebDavMiddleware, :port=>3001
+
+This configures the WebDAV server to listen on port 3001 for WeDAV requests in development. To access the WebDAV API,
+you will need to start another rails server instance like so:
+
+    script/server --port=3001
+
+In production, a subdomain should be used rather than a port. You will need to configure another subdomain on your webserver, much like the cms.
+subdomain is used for the admin interface. The default subdomain is 'webdav'. Here's an example apache config file, with a new subdomain configured:
+
+     <VirtualHost *:80>
+      ServerName webdav.mysite.com
+      DocumentRoot "/var/sites/mysite/public"
+      RailsEnv production
+      <directory "/var/sites/mysite/public">
+        Order allow,deny
+        Allow from all
+      </directory>
+    </VirtualHost>
+
+This means there should be a total of three domains in place for a site in production:
+* www - Main site accessed by the public
+* cms - Site access for administrators
+* webdav - Site access via WebDAV
+
+==== Alternate Subdomains
+
+You can change the subdomain that this module listens for requests on via:
+
+    # config/initializers/bcms_webdav.rb
+    Rails.configuration.middleware.use Bcms::WebDavMiddleware, :port=>3001, :subdomain=>"dav"
+
+This would change the subdomain from 'webdav' to 'dav'. This webserver config file would also need to be changed as well.
+
+==== Subdomains in Development
+
+Rather than run two server instances locally, you can take advantage of subdomains. Start by modifying your 'hosts' file to
+make 'webdav.localhost' map to your local development environment, like so:
+
+    127.0.0.1 webdav.localhost
+
+Then configure the module so its no longer listening on port 3001, like so:
+
+    # config/initializers/bcms_webdav.rb
+    Rails.configuration.middleware.use Bcms::WebDavMiddleware
+
+Now you can make web requests to localhost:3000 and WebDAV requests to webdav.localhost:3000
+
+== Notes
+
+This is an incomplete implementation of WebDAV, so many operations are not explicitly supported, such as:
+
+* Moving - Users cannot move files or pages.
+* Get/Put Pages/sections - Users can't download or upload pages or sections.
+* Edit/Create Pages/section - Users can't edit/rename or create new sections.
+
+== Known Issues
+
+* All files are uploaded as 'FileBlocks', regardless of whether they are images or not.
+* All content_types are set to 'application/octet-stream' regardless of their actual type.
+* This m
+
+=== Performance
+
+This module almost certainly needs performance testing when dealing with larger sites. Certain FTP clients will make more requests for
+resources than others. (CrossFTP seems 'chattier' than Transmit for instance).

data/Rakefile

@@ -0,0 +1,10 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require(File.join(File.dirname(__FILE__), 'config', 'boot'))
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+require 'tasks/rails'

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/doc/README_FOR_APP

@@ -0,0 +1,2 @@
+Use this README file to introduce your application and point to useful places in the API for learning more.
+Run "rake doc:app" to generate API documentation for your models, controllers, helpers, and libraries.

data/lib/bcms_webdav.rb

@@ -0,0 +1,5 @@
+require 'bcms_webdav/routes'
+require 'bcms_webdav/web_dav_middleware'
+require 'bcms_webdav/file'
+require 'bcms_webdav/bcms_attachment_extensions'
+require 'bcms_webdav/resource'

data/lib/bcms_webdav/bcms_attachment_extensions.rb

@@ -0,0 +1,7 @@
+Attachment.class_eval do
+
+  # Exist to ensure compliance with Resource API for WebDAV (like Section and Pages).
+  def path
+    file_path
+  end
+end

data/lib/bcms_webdav/file.rb

@@ -0,0 +1,30 @@
+module Bcms
+  module WebDAV
+
+    # Inherits from Rack File in order to change where paths are looked up from, since the
+    # public path of CMS files is different that actual file path.
+    class File < Rack::File
+
+      # This should be an absolute file path
+      def initialize(absolute_file_path)
+        @path = absolute_file_path
+      end
+
+      # Don't look up from PATH, look up from passed in variable
+      def _call(env)
+        Rails.logger.debug "Starting to serve file @ path #{@path}"
+
+        # From here down is a copy&paste of Rack::File#_call
+        begin
+          if F.file?(@path) && F.readable?(@path)
+            serving
+          else
+            raise Errno::EPERM
+          end
+        rescue SystemCallError
+          not_found
+        end
+      end
+    end
+  end
+end

data/lib/bcms_webdav/resource.rb

@@ -0,0 +1,235 @@
+module Bcms
+  module WebDAV
+
+    # A virtual resource representing a CMS
+    #   * Section
+    #   * File
+    #   * Image
+    class Resource < DAV4Rack::Resource
+
+      include DAV4Rack::HTTPStatus
+
+      # Converts WebDAV paths into CMS paths. Both have slightly different rules.
+      def self.normalize_path(webdav_path)
+        path = webdav_path
+        if path.end_with?("/")
+          path.gsub!(/\/$/, '')
+        end
+        unless path.start_with?("/")
+          path = path.insert(0, "/")
+        end
+        path = "/" if path == ''
+        path
+
+      end
+
+
+      def authenticate(username, password)
+        log "Authenticating user '#{username}'"
+        user = User.authenticate(username, password)
+
+        unless user
+          Rails.logger.error "Failed authentication attempt by user '#{username}'"
+          return false
+        end
+        user.able_to?(:administrate)
+      end
+
+      def have_section
+        @section != nil
+      end
+
+      def have_page
+        @page != nil
+      end
+
+      def have_file
+        @file != nil
+      end
+
+
+
+      # This should always be called by DAV4Rack controller before any other primary operation (get, put) on a resource.
+      def exist?
+        path_to_find = Resource.normalize_path(path)
+        @section = Section.with_path(path_to_find).first
+
+        if have_section
+          log_exists('section', path_to_find)
+          @resource = @section if have_section
+        end
+
+        @page = Page.with_path(path_to_find).first
+        if have_page
+          log_exists('page', path_to_find)
+          @resource = @page
+        end
+
+        @file = Attachment.find_by_file_path(path)
+        if have_file
+          log_exists('file', path_to_find)
+          @resource = @file
+        end
+
+        have_section || have_page || have_file
+      end
+
+      def children
+        if exist?
+          child_nodes = @section.child_nodes
+          child_resources = []
+          child_nodes.each do |node|
+            child_resources << child_node(node)
+          end
+          return child_resources
+        else
+          []
+        end
+      end
+
+      def creation_date
+        @resource.created_at
+      end
+
+      def last_modified
+        @resource.created_at if exist?
+      end
+
+      def collection?
+        have_section ? true : false
+      end
+
+      def etag
+        sprintf('%x-%x-%x', @resource.id, creation_date.to_i, last_modified.to_i) if exist?
+      end
+
+      def content_type
+        have_file ? @resource.file_type : "text/html"
+      end
+
+      def content_length
+        have_file ? @resource.file_size : 0
+      end
+
+      def get(request, response)
+        log "GET request for #{request.path}"
+        if have_file
+          file_location = @resource.full_file_location
+          log "For attachment '#{@resource}' file location is '#{file_location}"
+          file = Bcms::WebDAV::File.new(file_location)
+          log "Sending file '#{file.path}'"
+          response.body = file
+        end
+      end
+
+      # Handle uploading file.
+      def put(request, response)
+
+        temp_file = request.body
+        add_rails_like_methods(temp_file)
+
+        section = find_section_for(path)
+
+        file_block = FileBlock.new(:name=>path, :attachment_file=>request.body, :attachment_section => section, :attachment_file_path=>path, :publish_on_save=>true)
+        unless file_block.save
+          log "Couldn't save file."
+          file_block.errors.each do |error|
+            log error
+          end
+          return
+        end
+        OK
+      end
+
+      def find_section_for(path)
+        log "Looking up section for path '#{path}"
+        path_obj = Path.new(path)
+        section_path = path_obj.path_without_filename
+        path_to_find = Resource.normalize_path(section_path)
+
+        log "Section.path = #{path_to_find}"
+        Section.with_path(path_to_find).first
+      end
+
+      private
+
+      def log_exists(type, path)
+        log "Resource of type '#{type}' with path '#{path}' exists."
+      end
+
+      # Make this TempFile object act like a RailsTempFile
+      def add_rails_like_methods(temp_file)
+        # For the purposes of Rails 2, this will have to do. Rails 3 make this much easier by providing additional
+        # Rack processors for ActionDispatch::Http::UploadedFile which makes this unncessary.
+
+        def temp_file.content_type
+          'application/octet-stream'
+        end
+
+        def temp_file.original_filename
+          path
+        end
+
+        def temp_file.local_path
+          self.path
+        end
+      end
+
+      def child_node(section_node)
+        child_node = self.class.new(section_node.node.path, section_node.node.path, request, response, options.merge(:user => @user))
+        child_node.exist? # Force lookup of info from DB.
+        child_node
+      end
+
+      def self.log(m)
+        Rails.logger.warn m
+      end
+
+      def log(m)
+        Rails.logger.warn m
+      end
+    end
+
+
+    class Path
+      include Cms::Behaviors::Attaching::InstanceMethods
+
+      # Based on http://stackoverflow.com/questions/27745/getting-parts-of-a-url-regex
+      # Tested in http://rubular.com/
+      #
+      # This will also convert paths with spaces, etc, into CMS style sanatized paths.
+      def initialize(path_as_string)
+
+        @string_path = sanitize_file_path(CGI::unescape(path_as_string))
+        Rails.logger.warn "Sanitized path is: " + @string_path
+        @regex = /^((http[s]?|ftp):\/)?\/?([^:\/\s]+)((\/\w+)*\/)([\w\-\.]+[^#?\s]+)(.*)?(#[\w\-]+)?$/
+        scanned = @string_path.scan(@regex)
+        @parts = scanned[0]
+      end
+
+      def parts
+        @parts
+      end
+
+      def file_name
+        return @parts[5] if @parts # Most longer URLs
+
+        # i.e. /somefilename.jpg
+        if @parts == nil
+          if @string_path.starts_with?("/") && @string_path.count("/") == 1
+            return @string_path.gsub("/", '')
+          end
+
+          # i.e. somefilename.jpg
+          return @string_path
+        end
+      end
+
+      def path_without_filename
+        @string_path.gsub(file_name, '')
+      end
+
+    end
+  end
+end
+

data/lib/bcms_webdav/routes.rb

@@ -0,0 +1,7 @@
+module Cms::Routes
+  def routes_for_bcms_webdav
+    namespace(:cms) do |cms|
+      #cms.content_blocks :webdavs
+    end  
+  end
+end

data/lib/bcms_webdav/web_dav_middleware.rb

@@ -0,0 +1,40 @@
+require 'dav4rack'
+require 'dav4rack/file_resource'
+
+module Bcms
+  class WebDavMiddleware
+
+    def initialize(app, options={})
+      @app = app
+      @dav4rack = DAV4Rack::Handler.new(:root => Rails.root.to_s, :root_uri_path => '/', :log_to => [STDERR, Logger::DEBUG], :resource_class=>Bcms::WebDAV::Resource)
+      @options = options
+
+      unless @options[:subdomain]
+        @options[:subdomain] = 'webdav'
+      end
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+      if is_webdav?(request)
+        return @dav4rack.call(env)
+      else
+        @app.call(env)
+      end
+    end
+
+    private
+
+    # A request is WebDAV if it matches either the port or subdomain (exactly).
+    def is_webdav?(request)
+      return true if @options[:port] && request.port == @options[:port]
+      return true if request.host.starts_with?("#{@options[:subdomain]}.")
+      false
+    end
+
+
+    def log(message)
+      Rails.logger.warn message
+    end
+  end
+end

data/lib/tasks/jeweler.rake

@@ -0,0 +1,34 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "bcms_webdav"
+    gemspec.rubyforge_project = "browsercms"
+    gemspec.summary = "A BrowserCMS module for WebDAV"
+    gemspec.email = "github@browsermedia.com"
+    gemspec.homepage = "https://github.com/browsermedia/bcms_webdav"
+    gemspec.description = "Turns a BrowserCMS site into a WebDAV server, allowing access for bulk uploading files."
+    gemspec.authors = ["BrowserMedia"]
+    gemspec.files = []
+    gemspec.files += Dir["app/**/*"]
+    gemspec.files -= Dir["app/views/layouts/templates/*"]
+    gemspec.files -= Dir["app/controllers/application_controller.rb"]
+    gemspec.files -= Dir["app/helpers/application_helper.rb"]
+    gemspec.files += Dir["doc/**/*"]
+    gemspec.files += Dir["db/migrate/[0-9]*.rb"].reject {|f| f =~ /_browsercms|_load_seed/ }
+    gemspec.files += Dir["lib/**/*"]
+    gemspec.files -= Dir["lib/task/jeweler.rake"]
+    gemspec.files += Dir["rails/init.rb"]
+    gemspec.files += Dir["public/bcms/webdav/**/*"]
+    gemspec.files += Dir["README.rdoc"]
+    gemspec.files += Dir["Rakefile"]
+    gemspec.files += Dir["LICENSE.txt"]
+    gemspec.files += Dir["COPYRIGHT.txt"]
+    gemspec.files += Dir["VERSION"]
+    gemspec.add_dependency('browsercms', '>=3.1')
+    gemspec.add_dependency('dav4rack', '>=0.2.1')
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+
+Jeweler::GemcutterTasks.new

data/public/bcms/webdav/README

@@ -0,0 +1 @@
+Use this directory to add public files that should copied from the gem into the project.

data/rails/init.rb

@@ -0,0 +1,4 @@
+gem_root = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+Cms.add_to_rails_paths gem_root
+Cms.add_generator_paths gem_root, "db/migrate/[0-9]*_*.rb"
+Cms.add_generator_paths gem_root, "public/bcms/webdav/**/*"

data/test/performance/browsing_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+require 'performance_test_help'
+
+# Profiling results for each test method are written to tmp/performance.
+class BrowsingTest < ActionController::PerformanceTest
+  def test_homepage
+    get '/'
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,46 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
+require 'test_help'
+
+class ActiveSupport::TestCase
+  # Transactional fixtures accelerate your tests by wrapping each test method
+  # in a transaction that's rolled back on completion.  This ensures that the
+  # test database remains unchanged so your fixtures don't have to be reloaded
+  # between every test method.  Fewer database queries means faster tests.
+  #
+  # Read Mike Clark's excellent walkthrough at
+  #   http://clarkware.com/cgi/blosxom/2005/10/24#Rails10FastTesting
+  #
+  # Every Active Record database supports transactions except MyISAM tables
+  # in MySQL.  Turn off transactional fixtures in this case; however, if you
+  # don't care one way or the other, switching from MyISAM to InnoDB tables
+  # is recommended.
+  #
+  # The only drawback to using transactional fixtures is when you actually 
+  # need to test transactions.  Since your test is bracketed by a transaction,
+  # any transactions started in your code will be automatically rolled back.
+  self.use_transactional_fixtures = true
+
+  # Instantiated fixtures are slow, but give you @david where otherwise you
+  # would need people(:david).  If you don't want to migrate your existing
+  # test cases which use the @david style and don't mind the speed hit (each
+  # instantiated fixtures translates to a database query per test method),
+  # then set this back to true.
+  self.use_instantiated_fixtures = false
+
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end
+
+def file_upload_object(options)
+  file = ActionController::UploadedTempfile.new(options[:original_filename])
+  open(file.path, 'w') { |f| f << options[:read] }
+  file.original_path = options[:original_filename]
+  file.content_type = options[:content_type]
+  file
+end

data/test/unit/attachment_test.rb

@@ -0,0 +1,17 @@
+require "test_helper"
+
+class AttachmentTest < ActiveSupport::TestCase
+
+  def setup
+
+  end
+
+  def teardown
+
+  end
+
+  test "Attachment should respond to 'path' just like pages and sections." do
+    a = Attachment.new(:file_path=>"/test.jpg")
+    assert_equal "/test.jpg", a.path
+  end
+end

data/test/unit/web_dav_middleware_test.rb

@@ -0,0 +1,50 @@
+require "test_helper"
+require 'mocha'
+
+class WebDavMiddlewareTest < ActiveSupport::TestCase
+
+
+  def setup
+    @webdav = Bcms::WebDavMiddleware.new(nil)
+    @request = mock()
+    @path = '/public'
+  end
+
+  def teardown
+
+  end
+
+  test "subdomain is_webdav too" do
+    @request.expects(:host).returns("webdav.example.com")
+    assert_equal true, @webdav.send(:is_webdav?, @request)
+
+    @request.expects(:host).returns("webdav.localhost")
+    assert_equal true, @webdav.send(:is_webdav?, @request)
+
+  end
+
+  test "non-subdomain is_webdav too" do
+    @request.expects(:host).returns("localhost")
+    assert_equal false, @webdav.send(:is_webdav?, @request)
+
+    @request.expects(:host).returns("www.webdav.example.com")
+    assert_equal false, @webdav.send(:is_webdav?, @request)
+
+  end
+
+  test "can configure different subdomain for webdav" do
+    webdav = Bcms::WebDavMiddleware.new(nil, {:subdomain=>"dav"})
+
+    @request.expects(:host).returns("dav.example.com")
+    assert_equal true, webdav.send(:is_webdav?, @request)
+
+    @request.expects(:host).returns("webdav.example.com")
+    assert_equal false, webdav.send(:is_webdav?, @request)
+  end
+
+  test "Setting up to use a port for detection for webdav requests" do
+    webdav = Bcms::WebDavMiddleware.new(nil, {:port=>3000})
+    @request.expects(:port).returns(3000)
+    assert_equal true, webdav.send(:is_webdav?, @request)
+  end
+end

data/test/unit/web_dav_resource_test.rb

@@ -0,0 +1,283 @@
+require "test_helper"
+require 'mocha'
+
+class WebDavSectionResourceTest < ActiveSupport::TestCase
+
+  def setup
+    @request = stub()
+    @request.expects(:ip).returns('').at_least_once
+    @about_us = Section.create!(:name=>"About Us", :path=>"/about-us", :parent=>Section.root.first)
+    @resource = resource_for("/about-us")
+    @resource.exist?
+  end
+
+  def teardown
+
+  end
+
+  test 'users with administrate permissions can access resources' do
+    mock_user = mock()
+    User.expects(:authenticate).with("abc", "123").returns(mock_user)
+    mock_user.expects(:able_to?).with(:administrate).returns(true)
+
+    assert_equal true, @resource.authenticate("abc", "123")
+  end
+
+  test "users without administrate can't access resources" do
+    mock_user = mock()
+    User.expects(:authenticate).with("abc", "123").returns(mock_user)
+    mock_user.expects(:able_to?).with(:administrate).returns(false)
+
+    assert_equal false, @resource.authenticate("abc", "123")
+
+  end
+
+  test "need a user account to access resource" do
+    mock_user = mock()
+    User.expects(:authenticate).with("abc", "123").returns(nil)
+
+    assert_equal false, @resource.authenticate("abc", "123")
+  end
+
+  test "convert webdav paths to cms paths" do
+    assert_equal "/", Bcms::WebDAV::Resource.normalize_path("/")
+    assert_equal "/", Bcms::WebDAV::Resource.normalize_path("")
+    assert_equal "/about-us", Bcms::WebDAV::Resource.normalize_path("/about-us/"), "Remove trailing slashes, which CMS paths don't have"
+    assert_equal "/about-us", Bcms::WebDAV::Resource.normalize_path("about-us/"), "Add starting slashes, which all CMS paths do have."
+  end
+
+  test "root path exists" do
+    root_section = Section.create!(:name=>"My Site", :path=>"/", :root=>true)
+
+    assert_not_nil Section.root.first, "Ensure the root section exists in the database"
+    assert_equal true, resource_for("/").exist?
+    assert_equal true, resource_for("").exist?, "WebDAV treats paths of '/' and '' as the root"
+
+  end
+
+  test "find subsection" do
+    contact_us = Section.create!(:name=>"Contact us", :path=>"/about-us/contact-us", :parent=>@about_us)
+    cu = resource_for("/about-us/contact-us")
+    assert_equal true, cu.exist?
+  end
+
+  test "find section with no leading slash" do
+    assert_equal true, resource_for("about-us/").exist?, "WebDAV seems to request subpaths (to collections) with no leading slash, plus a trailing slash"
+  end
+
+  test "exist?" do
+    resource = resource_for("/about-us")
+    assert_equal true, resource.exist?
+  end
+
+  test "exist? fails if section is missing" do
+    resource = resource_for("/not-about-us")
+    assert_equal false, resource.exist?
+  end
+
+  test "children returns all sections and pages" do
+    child_section = Section.create!(:name=>"Child 1", :path=>"/about-us/child1", :parent=>@about_us)
+    child_page = Page.create!(:name=>"Child 2", :path=>"/about-us/child2", :section=>@about_us)
+    resource = resource_for("/about-us")
+    children = resource.children
+    assert_equal 2, children.size
+    assert_equal "/about-us/child1", children[0].public_path
+    assert_equal "/about-us/child2", children[1].public_path
+  end
+
+
+  test "propfind ensures all resources are initialized when getting properties" do
+    child_section = Section.create!(:name=>"Child 1", :path=>"/about-us/child1", :parent=>@about_us)
+    child_page = Page.create!(:name=>"Child 2", :path=>"/about-us/child2", :section=>@about_us)
+    resource = resource_for("/about-us")
+    children = resource.children
+
+    assert_about_same_time child_section.created_at, children[0].creation_date
+    assert_about_same_time child_page.created_at, children[1].creation_date
+  end
+
+  def assert_about_same_time(expected, actual)
+    assert expected - actual <= 100, "Ensure the times are close"
+  end
+  test "creation_date" do
+    resource = resource_for("/about-us")
+    resource.exist?
+    assert @about_us.created_at - resource.creation_date <= 100, "Ensure the times are close"
+  end
+
+  test "last_modified" do
+    resource = resource_for("/about-us")
+    assert @about_us.updated_at - resource.last_modified <= 100, "Ensure the times are close"
+  end
+
+
+  test "etag is implemented in some vaguely terrible way" do
+
+    # Note: There is no particular logic to this etag, just trying to make it unique
+    assert_not_nil @resource.etag
+  end
+
+  test "sections are collections" do
+    assert(@resource.collection?)
+  end
+
+  test "sections are text/html" do
+    assert_equal "text/html", @resource.content_type
+  end
+
+  test "sections have 0 content_length" do
+    assert_equal 0, @resource.content_length
+  end
+
+
+  private
+
+  def resource_for(path)
+    Bcms::WebDAV::Resource.new(path, path, @request, Rack::MockResponse.new(200, {}, []), {})
+  end
+
+
+end
+
+class PageResourceTest < ActiveSupport::TestCase
+  def setup
+    @request = stub()
+    @request.expects(:ip).returns('').at_least_once
+    @about_us = Section.create!(:name=>"About Us", :path=>"/about-us", :parent=>Section.root.first)
+    @contact_us = Page.create!(:name=>"Contact Us", :path=>"/about-us/contact_us", :section=>@about_us)
+    @resource = resource_for("/about-us/contact_us")
+    @resource.exist?
+
+  end
+
+  test "exists" do
+    assert_equal true, @resource.exist?
+  end
+
+  test "creation_date" do
+    assert @contact_us.created_at - @resource.creation_date <= 100, "Ensure the times are close"
+  end
+
+  test "last_modified" do
+    assert @contact_us.updated_at - @resource.last_modified <= 100, "Ensure the times are close"
+  end
+
+  test "pages are not collections" do
+    assert_equal false, @resource.collection?
+  end
+
+
+  private
+  def resource_for(path)
+    Bcms::WebDAV::Resource.new(path, path, @request, Rack::MockResponse.new(200, {}, []), {})
+  end
+end
+
+class FileResourceTest < ActiveSupport::TestCase
+  def setup
+    @request = stub()
+    @request.expects(:ip).returns('').at_least_once
+
+    @response = Rack::MockResponse.new(200, {}, [])
+    @about_us = Section.create!(:name=>"About Us", :path=>"/about-us", :parent=>Section.root.first)
+
+    @file = file_upload_object(:original_filename => "test.jpg",
+                               :content_type => "image/jpeg", :rewind => true,
+                               :size => "99", :read => "01010010101010101")
+    @file_block = FileBlock.create!(:name=>"Testing", :attachment_file => @file, :attachment_section => @about_us, :attachment_file_path => "/about-us/test.jpg", :publish_on_save => true)
+
+    @resource = resource_for("/about-us/test.jpg")
+    @resource.exist?
+
+  end
+
+  test "exists" do
+    assert_equal true, @resource.exist?
+  end
+
+  test "creation_date" do
+    assert @file_block.created_at - @resource.creation_date <= 100, "Ensure the times are close"
+  end
+
+  test "last_modified" do
+    assert @file_block.updated_at - @resource.last_modified <= 100, "Ensure the times are close"
+  end
+
+  test "pages are not collections" do
+    assert_equal false, @resource.collection?
+  end
+
+  test "file size is correct" do
+    assert_equal @file.size, @resource.content_length
+  end
+
+  test "content_type matches underlying file type" do
+    assert_equal @file.content_type, @resource.content_type
+  end
+
+  test "Getting a file" do
+    mock_rack_file = mock()
+    mock_rack_file.expects(:path).returns("").at_least_once
+    Bcms::WebDAV::File.expects(:new).with(@file_block.attachment.full_file_location).returns(mock_rack_file)
+
+    @request.expects(:path).returns("/about-us/test.jpg").at_least_once
+    @response.expects(:body=).with(mock_rack_file)
+
+    @resource.get(@request, @response)
+
+  end
+
+  test "Finding a section includes child files as resources" do
+    @section = resource_for("/about-us")
+    assert_equal 1, @section.children.size
+    assert_equal "/about-us/test.jpg", @section.children.first.path
+  end
+
+
+  test "determine target_section" do
+    path = Bcms::WebDAV::Path.new('/about-us/test.jpg')
+    assert_equal "test.jpg", path.file_name
+    assert_equal '/about-us/', path.path_without_filename
+
+    assert_equal @about_us, @resource.find_section_for("/about-us/test.jpg")
+  end
+
+  test "Uploading files with spaces or special characters" do
+    path = Bcms::WebDAV::Path.new('/about-us/test with spaces.jpg')
+    assert_equal "test_with_spaces.jpg", path.file_name
+    assert_equal '/about-us/', path.path_without_filename
+
+    assert_equal @about_us, @resource.find_section_for("/about-us/test with spaces.jpg")
+  end
+  test "Uploading files with encoded spaces" do
+    path = Bcms::WebDAV::Path.new('/about-us/test%20with%20spaces.jpg')
+    assert_equal "test_with_spaces.jpg", path.file_name
+    assert_equal '/about-us/', path.path_without_filename
+
+    assert_equal @about_us, @resource.find_section_for("/about-us/test with spaces.jpg")
+  end
+
+  test "uploading files to root section" do
+    assert_equal Section.root.first, @resource.find_section_for("/test.jpg")
+  end
+
+  test "parse empty section" do
+    path = Bcms::WebDAV::Path.new('/test.jpg')
+    assert_equal "test.jpg", path.file_name
+
+
+  end
+
+  test "parse missing slash section" do
+    path = Bcms::WebDAV::Path.new('test.jpg')
+    assert_equal "test.jpg", path.file_name
+
+
+  end
+  private
+  def resource_for(path)
+    Bcms::WebDAV::Resource.new(path, path, @request, @response, {})
+  end
+end
+
+

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification 
+name: bcms_webdav
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- BrowserMedia
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-01 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: browsercms
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 3
+        - 1
+        version: "3.1"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: dav4rack
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 0
+        - 2
+        - 1
+        version: 0.2.1
+  type: :runtime
+  version_requirements: *id002
+description: Turns a BrowserCMS site into a WebDAV server, allowing access for bulk uploading files.
+email: github@browsermedia.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- COPYRIGHT.txt
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- doc/README_FOR_APP
+- lib/bcms_webdav.rb
+- lib/bcms_webdav/bcms_attachment_extensions.rb
+- lib/bcms_webdav/file.rb
+- lib/bcms_webdav/resource.rb
+- lib/bcms_webdav/routes.rb
+- lib/bcms_webdav/web_dav_middleware.rb
+- lib/tasks/jeweler.rake
+- public/bcms/webdav/README
+- rails/init.rb
+- test/performance/browsing_test.rb
+- test/test_helper.rb
+- test/unit/attachment_test.rb
+- test/unit/web_dav_middleware_test.rb
+- test/unit/web_dav_resource_test.rb
+has_rdoc: true
+homepage: https://github.com/browsermedia/bcms_webdav
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: browsercms
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A BrowserCMS module for WebDAV
+test_files: 
+- test/performance/browsing_test.rb
+- test/test_helper.rb
+- test/unit/attachment_test.rb
+- test/unit/web_dav_middleware_test.rb
+- test/unit/web_dav_resource_test.rb