dropsite 0.2

data/LICENSE

@@ -0,0 +1,21 @@
+(The MIT License)
+
+Copyright (c) 2010 Aaron Royer
+
+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

@@ -0,0 +1,25 @@
+dropsite
+    gem install dropsite
+
+Dropsite creates a site of interlinked file index pages in the Public directory
+of your Dropbox. The site created is minimally invasive to your Public
+directory by only creating one top-level HTML page and one folder, leaving your
+directories unjunked.
+
+BE WARNED: while this seems to work fine, it is presently considered
+experimental.
+
+To create the site:
+    $ dropsite
+
+This deletes "index.html" and the directory "dropsite" in your Dropbox Public
+directory if they exist, creates "index.html" as the top-level index, and puts
+the rest of the index pages and assets in the "dropsite" directory.
+
+To specify a different Dropbox directory:
+    $ dropsite --dropbox-home ~/Somewhere/Else
+
+You can also use this if you just want to test this elsewhere before turning
+it loose on your precious files.
+
+MIT licensed - see LICENSE

data/Rakefile

@@ -0,0 +1,33 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/test_*.rb'
+end
+
+task :default => [:test]
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |t|
+    t.libs << 'test'
+    t.test_files = FileList['test/**/test_*.rb']
+    t.verbose = true
+  end
+rescue LoadError
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'dropsite'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc "Build gem package"
+task :package => 'dropsite.gemspec' do
+  sh "gem build dropsite.gemspec"
+end

data/bin/dropsite

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+
+# TODO: take this out later
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'dropsite'
+include Dropsite
+
+options = {
+  :quiet => false
+}
+
+OptionParser.new do |opts|
+  opts.on('-d', '--dropbox-home [PATH]', 'Specify Dropbox directory') {|path| options[:dropbox_home] = path }
+  opts.on('-q', '--quiet', 'Suppress site processing output') {|| options[:quiet] = true }
+  opts.on_tail('-h', '--help', 'Show this message') do
+    puts opts
+    exit
+  end
+  opts.on_tail('--version', 'Show version') do
+    puts "Dropsite version: #{Dropsite::VERSION}"
+    exit
+  end
+end.parse!
+
+options[:dropbox_home] = Dropsite.find_dropbox_dir if not options[:dropbox_home]
+
+if !options[:dropbox_home] || !File.exist?(options[:dropbox_home])
+  $stderr.puts 'Dropbox home directory cannot be found or does not exist'
+  $stderr.puts 'Set valid directory with --dropbox-home DIRECTORY'
+  exit 1
+end
+
+options[:public_dir] = File.join(options[:dropbox_home], 'Public')
+
+site = Dropsite::Site.new(options)
+site.process

data/dropsite.gemspec

@@ -0,0 +1,28 @@
+Gem::Specification.new do |s|
+  s.name = 'dropsite'
+  s.version = '0.2'
+  s.platform = Gem::Platform::RUBY
+
+  s.description = "creates index pages in your Dropbox public directory"
+  s.summary = "Dropsite creates a site of interlinked file index pages in " +
+    "the Public directory of your Dropbox. The site created is minimally " +
+    "invasive to your Public directory by only creating one top-level " +
+    "HTML page and one folder, leaving your directories unjunked." +
+    "\nBE WARNED: while I _think_ this probably works fine, it is " +
+    "presently considered experimental." 
+
+  s.authors     = ["Aaron Royer"]
+  s.email       = "aaronroyer@gmail.com"
+
+  s.files           = Dir['{bin/*,lib/**/*,test/**/*}'] +
+                          %w(README LICENSE dropsite.gemspec Rakefile)
+
+  s.executables << 'dropsite'
+
+  s.test_files = s.files.select {|path| path =~ /^test\/test_.*\.rb/}
+
+  s.has_rdoc = true
+  s.homepage = "https://rubygems.org/gems/dropsite"
+  s.rdoc_options = ["--line-numbers", "--inline-source"]
+  s.require_paths = %w[lib]
+end

data/lib/dropsite/dir_renderer.rb

@@ -0,0 +1,56 @@
+require 'erb'
+
+module Dropsite
+  class DirRenderer
+    TEMPLATE_EXTENSIONS = ['.erb']
+    
+    @@renderers = []
+    
+    def self.inherited(subclass)
+      renderer = subclass.new
+      
+      plugin_dir = File.dirname(caller[0].split(':')[0])
+      template_file = Dir.entries(plugin_dir).find {|e| TEMPLATE_EXTENSIONS.include? File.extname(e)}
+      renderer.template_path = template_file ? File.join(plugin_dir, template_file) : nil
+      renderer.assets_dir = File.join(plugin_dir, 'assets')
+      @@renderers << renderer
+    end
+    
+    def DirRenderer.renderers
+      @@renderers
+    end
+    
+    # Find the first renderer that can render the given SiteDir. Non-default (user) plugins
+    # are searched first.
+    def DirRenderer.find_renderer(site_dir)
+      @@renderers.partition {|r| !r.is_default? }.flatten.find {|r| r.can_render?(site_dir)}
+    end
+    
+    def DirRenderer.find_renderer_and_render(site_dir)
+      DirRenderer.find_renderer(site_dir).render(site_dir)
+    end
+    
+    attr_accessor :template_path, :assets_dir
+    
+    # Overridden in subclass if you don't want to just find and use a template
+    def render(site_dir)
+      site_dir.rendered_by = self.class
+      
+      if File.extname(template_path) == '.erb'
+        @template = @template || ERB.new(IO.read(template_path))
+        @template.result(site_dir.get_binding)
+      else
+        raise "Don't know how to render: #{template_path}"
+      end
+    end
+    
+    # Overriden in subclass or this won't do jack
+    def can_render?(site_dir)
+      is_default?
+    end
+    
+    def is_default?
+      false
+    end
+  end
+end

data/lib/dropsite/plugins/simple_index/assets/css/reset.css

@@ -0,0 +1,30 @@
+body,div,dl,dt,dd,ul,ol,li,h1,h2,h3,h4,h5,h6,pre,form,fieldset,input,textarea,p,blockquote,th,td { 
+	margin:0;
+	padding:0;
+}
+table {
+	border-collapse:collapse;
+	border-spacing:0;
+}
+fieldset,img { 
+	border:0;
+}
+address,caption,cite,code,dfn,em,strong,th,var {
+	font-style:normal;
+	font-weight:normal;
+}
+ol,ul {
+	list-style:none;
+}
+caption,th {
+	text-align:left;
+}
+h1,h2,h3,h4,h5,h6 {
+	font-size:100%;
+	font-weight:normal;
+}
+q:before,q:after {
+	content:'';
+}
+abbr,acronym { border:0;
+}

data/lib/dropsite/plugins/simple_index/assets/css/simple_index.css

@@ -0,0 +1,98 @@
+body {
+	background-color: white;
+	color: #484848;
+	font: 13.34px Helvetica, Arial, freesans, clean, sans-serif;
+	font-size: 90%;
+	text-align: center;
+}
+
+#content {
+	width: 920px;
+	margin-left: auto;
+	margin-right: auto;
+	text-align: left;
+}
+
+#breadcrumbs {
+	margin-top: 20px;
+	font-size: 140%;
+}
+
+#breadcrumbs .sep {
+	margin-left: 5px;
+	margin-right: 10px;
+}
+
+#breadcrumbs .root-link, #breadcrumbs .parent-dir-link {
+	text-decoration: none;
+}
+
+#breadcrumbs .root-link:hover, .parent-dir-link:hover {
+	text-decoration: underline;
+}
+
+#breadcrumbs .root-link {
+	color: #4183C4;
+	font-weight: bold;
+}
+
+#breadcrumbs .parent-dir-link {
+	color: #4183C4;
+}
+
+#breadcrumbs .current-dir {
+	color: #000000;
+}
+
+#file-list {
+	margin-top: 10px;
+	width: 100%;
+}
+
+#file-list .header {
+	background-color: #eaeaea;
+	border: 1px solid #e1e1e1;
+	color: #999999;
+	height: 28px;
+}
+
+.entry {
+	height: 28px;
+	border: 1px solid #e1e1e1;
+	border-top: none;
+	background-image: url(../images/row-bg.png);
+	font-family: Monaco, 'Courier New', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace;	
+}
+
+.entry td {
+	vertical-align: middle;
+}
+
+.entry td a {
+	color: #4183C4;
+	text-decoration: none;
+}
+
+.entry td a:hover {
+	text-decoration: underline;
+}
+
+.entry .icon {
+	width: 28px;
+	padding-left: 12px;
+	padding-top: 4px;
+}
+
+.entry .link {
+	min-width: 300px;
+}
+
+.entry .type {
+	padding-right: 10px;
+	min-width: 120px;
+}
+
+.entry .size {
+	padding-right: 10px;
+	min-width: 70px;
+}

data/lib/dropsite/plugins/simple_index/assets/simple_index.js

@@ -0,0 +1,3 @@
+if (console && console.log) {
+	console.log("included...");
+}

data/lib/dropsite/plugins/simple_index/simple_index.erb

@@ -0,0 +1,37 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+	"http://www.w3.org/TR/html4/strict.dtd">
+<html>
+	<head>
+		<meta http-equiv="Content-type" content="text/html; charset=utf-8">
+		<title>My Dropbox Files<%= " - #{name}" if !root? %></title>
+		<%= stylesheet_link_tag 'reset' %>
+		<%= stylesheet_link_tag 'simple_index' %>
+		<%= javascript_include_tag 'simple_index' %>
+	</head>
+	<body>
+		<div id="content">
+			<div id="breadcrumbs">
+				<a class="root-link" href="<%= back_link('root') %>">my files</a>
+				<% each_parent_directory_link_tag(false, {:class => 'parent-dir-link'}) do |tag| %>
+					<span class="sep">/</span><%= tag %>
+				<% end %>
+				<% if !root? %>
+					<span class="sep">/</span><span class="current-dir"><%= name %></span>
+				<% end %>
+			</div>
+			<table id="file-list">
+				<tr class="header">
+					<th>&nbsp;</th><th>name</th><th>type</th><th>size</th>
+				</tr>
+				<% @entries.sort.each do |entry| %>
+				<tr class="entry">
+					<td class="icon"><%= image_tag "icons/#{entry.file_type}.png" %></td>
+					<td class="link"><a href="<%= entry.link %>"><%= entry.name %></a></td>
+					<td class="type"><%= entry.file_type %></td>
+					<td class="size"><%= entry.size %></td>
+				</tr>
+				<% end %>
+			</table>
+		</div>
+	</body>
+</html>

data/lib/dropsite/plugins/simple_index/simple_index.rb

@@ -0,0 +1,5 @@
+class SimpleIndex < Dropsite::DirRenderer
+  def is_default?
+    true
+  end
+end

data/lib/dropsite/plugins.rb

@@ -0,0 +1,5 @@
+PLUGINS_DIR = File.join(File.dirname(__FILE__), 'plugins')
+
+Dir.entries(PLUGINS_DIR).reject {|e| e =~ /^\./}.each do |e|
+  require File.join(PLUGINS_DIR, e, e)
+end

data/lib/dropsite/render_helper.rb

@@ -0,0 +1,97 @@
+module Dropsite
+  
+  # Helper methods, accessible in templates, to be included in renderable items
+  module RenderHelper
+    attr_accessor :rendered_by
+    
+    def link
+      # TODO: URL escape links
+      if top_level? && (!is_a? SiteDir)
+        name
+      else
+        if is_a? SiteDir # TODO: do a dynamic renderable test?
+          top_level? ? "dropsite/#{@path}.html" : "#{@path}.html".sub(/^\//, '')
+        else
+          # Builds a link back up to the file in Public root since the pages
+          # are built in a parallel directory structure
+          dirs_up = @path.split(File::SEPARATOR).size - 1
+          (['..'] * dirs_up).join('/') + "/#{@path}"
+        end
+      end
+    end
+    
+    def stylesheet_link_tag(stylesheet_name)
+      stylesheet_name = "#{stylesheet_name}.css" if not stylesheet_name =~ /\.css$/
+      %{<link rel="stylesheet" href="#{assets_link_base}css/#{stylesheet_name}" type="text/css" media="screen">}
+    end
+    
+    def javascript_include_tag(javascript_file_name)
+      javascript_file_name = "#{javascript_file_name}.js" if not javascript_file_name =~ /\.js$/
+      %{<script type="text/javascript" src="#{assets_link_base}js/#{javascript_file_name}"></script>}
+    end
+    
+    def image_tag(image_file_name)
+      %{<img src="#{assets_link_base}images/#{image_file_name}" />}
+    end
+    
+    def parent_directory_link_tag(levels_up=1, options={})
+      %{<a href="#{back_link(levels_up)}"#{tag_attributes(options)}>#{parent_dir_name(levels_up)}</a>}
+    end
+    
+    def each_parent_directory_link_tag(*args)
+      include_root = true
+      include_root = args[0] if args.size > 0 && (!args[0].is_a? Hash)
+      options = args.find {|arg| arg.is_a? Hash}
+      options = {} if !options
+      
+      levels_up = path.split('/').size
+      levels_up = levels_up - 1 if !include_root
+      levels_up.downto(1).each do |level_up|
+        yield parent_directory_link_tag(level_up, options)
+      end
+    end
+    
+    def assets_link_base
+      if root?
+        "dropsite/dropsite-assets/#{Dropsite.underscorize(rendered_by)}/"
+      else
+        # Work our way BACK up the path - crazy, right? Gotta do it though.
+        dirs_up = path.split(File::SEPARATOR).size - 1
+        (['..'] * dirs_up).join('/') + "#{'/' if dirs_up > 0}dropsite-assets/#{Dropsite.underscorize(rendered_by)}/"
+      end
+    end
+    
+    # Get a link to a parent page
+    def back_link(levels_up=1)
+      # TODO: factor this out a bit between parent_dir_name
+      if levels_up.is_a?(Integer) && levels_up > 0 && levels_up < path.split('/').size
+        dir_name = path.split('/')[(levels_up + 1) * -1]
+        dir_name = 'index' if dir_name.empty?
+        (['..'] * (levels_up)).join('/') + "/#{dir_name}.html"
+      else
+        # Give the root index if we're confused
+        root? ? '' : (['..'] * (path.split('/').size)).join('/') + '/index.html'
+      end
+    end
+    
+    def parent_dir_name(levels_up=1)
+      if levels_up.is_a?(Integer) && levels_up > 0 && levels_up < path.split('/').size
+        dir_name = path.split('/')[(levels_up + 1) * -1]
+        dir_name.empty? ? 'index' : dir_name
+      else
+        # TODO: make this configurable
+        'my files'
+      end
+    end
+    
+    def get_binding
+      binding
+    end
+    
+    protected
+    
+    def tag_attributes(options)
+      options.empty? ? '' : ' ' + options.keys.map {|k| %{#{k.to_s}="#{options[k].to_s}"} }.join
+    end
+  end
+end

data/lib/dropsite/site.rb

@@ -0,0 +1,106 @@
+require 'fileutils'
+
+module Dropsite
+  VERSION = '0.2'
+  
+  # Main site builder class. Some inspiration here from Jekyll (github.com/mojombo/jekyll).
+  class Site
+    attr_reader :site_tree, :public_dir
+    
+    def initialize(config)
+      if config.is_a? String
+        @public_dir = config
+        @excludes = []
+        @quiet = false
+      else
+        @config = config.clone
+        @public_dir = config[:public_dir]
+        @excludes = config[:excludes] || []
+        @quiet = config[:quiet] || false
+      end
+      
+      @site_tree = nil
+      @site_files_dir = File.join(@public_dir, 'dropsite')
+    end
+    
+    def process
+      clean
+      read
+      render
+      write
+    end
+    
+    # Cleans up files previously generated by Dropsite (or at least ones)
+    # that look like they are. By default this will be an index.html
+    # file and dropsite directory in the Public directory root.
+    def clean
+      if File.exist?(@site_files_dir)
+        notice "Deleting existing site files dir at #{@site_files_dir}"
+        FileUtils.rm_rf(@site_files_dir)
+      end
+      
+      index_file = File.join(@public_dir, 'index.html')
+      if File.exist?(index_file)
+        notice "Deleting existing top-level index at #{index_file}"
+        File.delete(index_file)
+      end
+    end
+    
+    def read
+      @site_tree = read_directory
+    end
+    
+    def render
+      @site_tree.render
+    end
+    
+    def write
+      notice "Creating site files dir at #{@site_files_dir}"
+      Dir.mkdir(@site_files_dir)
+      @site_tree.write
+      
+      site_assets_dir = File.join(@site_files_dir, 'dropsite-assets')
+      Dir.mkdir(site_assets_dir)
+      DirRenderer.renderers.each do |r|
+        if File.exist? r.assets_dir
+          FileUtils.cp_r(r.assets_dir, File.join(site_assets_dir, Dropsite.underscorize(r.class.to_s)))
+        end
+      end
+    end
+    
+    def notice(message)
+      return if @quiet
+      warn "#{File.basename($0)}: #{message}"
+    end
+    
+    protected
+    
+    def read_directory(dir='')
+      base = File.join(@public_dir, dir)
+      entries = filter_entries(Dir.entries(base))
+      
+      dir_entries = []
+      
+      entries.each do |f|
+        f_abs = File.join(base, f)
+        f_rel = File.join(dir, f).sub(/^\//, '')
+        if File.directory?(f_abs)
+          dir_entries << read_directory(f_rel)
+        elsif !File.symlink?(f_abs)
+          # Ignore a top level Icon file, used for a custom directory icon on OS X
+          # TODO: find out how to do this specifically for the Icon file... there is a
+          #       weird character at the end of the folder icon file name
+          next if RUBY_PLATFORM =~ /darwin/ && f_rel =~ /^Icon/ && f_rel.size == 5 && dir == ''
+          dir_entries << SiteFile.new(f_rel, f_abs, self)
+        end
+      end
+      SiteDir.new(dir, dir_entries, self)
+    end
+    
+    def filter_entries(entries)
+      entries.reject do |e|
+        ['.', '_', '#'].include?(e[0..0]) || e[-1..-1] == '~' || @excludes.include?(e)
+      end
+    end
+  end
+end

data/lib/dropsite/site_dir.rb

@@ -0,0 +1,59 @@
+module Dropsite
+  class SiteDir < SiteItem
+    attr_accessor :entries
+    
+    def initialize(path, entries, site)
+      @path = path == '/' ? '' : path
+      @entries = entries
+      @site = site
+      @content = nil
+    end
+    
+    def render
+      @content = Dropsite::DirRenderer.find_renderer_and_render(self)
+      dirs.each {|dir| dir.render}
+    end
+    
+    def write
+      if root?
+        # The root site directory was created in Site
+        index_file = File.join(@site.public_dir, 'index.html')
+        notice "Writing top level index file at #{index_file}"
+        File.open(index_file, 'w') {|f| f.puts @content}
+      else
+        # Sub-directories all need to be created here
+        pieces = @path.sub(/^\//, '').split('/')
+        dir_name = File.join(@site.public_dir, 'dropsite', *pieces)
+        index_file = dir_name + '.html'
+        notice "Writing index file at #{index_file}"
+        File.open(index_file, 'w') {|f| f.puts @content}
+        Dir.mkdir(dir_name)
+      end
+      dirs.sort.each{|dir| dir.write}
+    end
+    
+    def files
+      @entries.find_all {|e| e.is_a? SiteFile}
+    end
+    
+    def dirs
+      @entries.find_all {|e| e.is_a? SiteDir}
+    end
+    
+    def root?
+      @path == ''
+    end
+    
+    def file_type
+      'directory'
+    end
+    
+    def size
+      ''
+    end
+    
+    def to_s
+      "SiteDir(#{is_root? ? 'root' : @path})"
+    end
+  end
+end

data/lib/dropsite/site_file.rb

@@ -0,0 +1,41 @@
+module Dropsite
+  class SiteFile < SiteItem
+    EXTENSIONS = {
+      'image' => %w[jpg jpeg gif png],
+      'text' => %w[txt],
+      'pdf' => %w[pdf]
+    }
+    
+    attr_accessor :size_in_bytes
+    
+    def initialize(rel_path, abs_path=nil, site=nil)
+      @path = rel_path
+      @size_in_bytes = File.size(abs_path) if abs_path
+      @site = site
+    end
+    
+    def file_type
+      if File.extname(name).empty?
+        'unknown'
+      else
+        ext = File.extname(name).sub(/^\./, '')
+        EXTENSIONS.each {|k, v| return k if v.include? ext}
+        return 'unknown'
+      end
+    end
+    
+    # Human readable file size
+    def size
+      return '' if !@size_in_bytes
+      return '0 B' if @size_in_bytes == 0
+      units = %w{B KB MB GB TB}
+      e = (Math.log(@size_in_bytes)/Math.log(1024)).floor
+      s = "%.1f" % (@size_in_bytes.to_f / 1024 ** e)
+      s.sub(/\.?0*$/, " #{units[e]}")
+    end
+    
+    def to_s
+      "SiteFile(#{@path})"
+    end
+  end
+end

data/lib/dropsite/site_item.rb

@@ -0,0 +1,25 @@
+module Dropsite
+  class SiteItem
+    include Enumerable, RenderHelper
+    
+    attr_accessor :path
+    
+    def name
+      File.basename @path
+    end
+    
+    def top_level?
+      @path.sub(/^\//, '') == name
+    end
+    
+    def <=>(other)
+      name <=> other.name
+    end
+    
+    protected
+    
+    def notice(message)
+      @site.notice(message) if @site
+    end
+  end
+end

data/lib/dropsite.rb

@@ -0,0 +1,30 @@
+
+module Dropsite
+  
+  # Attempts to find the Dropbox directory (not the Public directory, the Dropbox base
+  # directory) on this box. Returns nil if an existing directory could not be found.
+  def find_dropbox_dir
+    return ENV['DROPBOX_HOME'] if ENV['DROPBOX_HOME']
+    
+    path = case RUBY_PLATFORM
+    when /darwin/, /linux/, /freebsd/
+      File.join(ENV['HOME'], 'Dropbox')
+    when /win32/, /mingw/
+      File.join(ENV['USERPROFILE'], 'My Documents', 'My Dropbox')
+    end
+    
+    File.exist?(path) ? path : nil
+  end
+  
+  # Convert a camel-cased string into a lowercase, underscore separated string
+  def underscorize(camel_cased_word)
+    camel_cased_word.to_s.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").downcase
+  end
+end
+
+%w[dir_renderer render_helper plugins site site_item site_dir site_file].each do |lib|
+  require File.join('dropsite', lib)
+end

data/test/fixtures/simple_public/file1.txt

@@ -0,0 +1 @@
+here is some content

data/test/fixtures/simple_public/file2.txt

@@ -0,0 +1 @@
+here is some content

data/test/helper.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+require 'rubygems'
+
+begin
+  require 'redgreen' unless ENV['TM_MODE']
+rescue LoadError
+end
+
+FILE_DIR = File.dirname(__FILE__)
+
+require File.join(FILE_DIR, *%w[.. lib dropsite])
+include Dropsite
+
+FIXTURES_DIR = File.join(FILE_DIR, 'fixtures')

data/test/test_render_helper.rb

@@ -0,0 +1,97 @@
+require File.join(File.dirname(__FILE__), 'helper')
+require 'nokogiri'
+
+# Tests for RenderHelper mixin using SiteItem, which mixes it in
+class TestRenderHelper < Test::Unit::TestCase
+  def test_back_link
+    assert_equal '../index.html', SiteDir.new('pics', [], '/tmp').back_link(1)
+    assert_equal '../index.html', SiteDir.new('pics', [], '/tmp').back_link
+    assert_equal '../pics.html', SiteDir.new('pics/people', [], '/tmp').back_link(1)
+    assert_equal '../../index.html', SiteDir.new('pics/people', [], '/tmp').back_link(2)
+    assert_equal '../people.html', SiteDir.new('pics/people/friends', [], '/tmp').back_link(1)
+    assert_equal '../../pics.html', SiteDir.new('pics/people/friends', [], '/tmp').back_link(2)
+    assert_equal '../../../index.html', SiteDir.new('pics/people/friends', [], '/tmp').back_link(3)
+    
+    # Test too many levels up and non-Integer arg
+    assert_equal '../index.html', SiteDir.new('pics', [], '/tmp').back_link(2)
+    assert_equal '../index.html', SiteDir.new('pics', [], '/tmp').back_link(3)
+    assert_equal '../index.html', SiteDir.new('pics', [], '/tmp').back_link(nil)
+    assert_equal '', SiteDir.new('', [], '/tmp').back_link(1)
+    assert_equal '', SiteDir.new('', [], '/tmp').back_link(nil)
+  end
+  
+  def test_parent_directory_link_tag
+    sd = SiteDir.new('pics/people/friends', [], '/tmp')
+    
+    basic_link_doc = Nokogiri::HTML(sd.parent_directory_link_tag(1))
+    links = basic_link_doc.css('a')
+    assert_equal 1, links.size
+    assert_equal '../people.html', links[0].attribute('href').value
+    assert_equal 'people', links[0].content
+    
+    basic_link_doc = Nokogiri::HTML(sd.parent_directory_link_tag(2))
+    links = basic_link_doc.css('a')
+    assert_equal 1, links.size
+    assert_equal '../../pics.html', links[0].attribute('href').value
+    assert_equal 'pics', links[0].content
+    
+    basic_link_doc = Nokogiri::HTML(sd.parent_directory_link_tag(3))
+    links = basic_link_doc.css('a')
+    assert_equal 1, links.size
+    assert_equal '../../../index.html', links[0].attribute('href').value
+    assert_equal 'my files', links[0].content
+  end
+  
+  def test_parent_directory_link_tag_with_additional_attributes
+    sd = SiteDir.new('pics/people/friends', [], '/tmp')
+    id = 'the-id'
+    css_class = 'the-css-class'
+    
+    link_doc = Nokogiri::HTML(sd.parent_directory_link_tag(1, :class => css_class))
+    links = link_doc.css('a')
+    assert_equal 1, links.size
+    link = links[0]
+    assert_equal '../people.html', link.attribute('href').value
+    assert_equal 'people', link.content
+    assert_equal css_class, link.attribute('class').value
+    
+    link_doc = Nokogiri::HTML(sd.parent_directory_link_tag(1, :id => id, :class => css_class))
+    links = link_doc.css('a')
+    assert_equal 1, links.size
+    link = links[0]
+    assert_equal '../people.html', link.attribute('href').value
+    assert_equal 'people', link.content
+    assert_equal id, link.attribute('id').value
+    assert_equal css_class, link.attribute('class').value
+  end
+  
+  def test_each_parent_directory_link_tag_with_root
+    links = ''
+    sd = SiteDir.new('pics/people/friends', [], '/tmp')
+    sd.each_parent_directory_link_tag {|link| links << link}
+    links_doc = Nokogiri::HTML(links)
+    links = links_doc.css('a')
+    assert_equal 3, links.size
+    
+    root_link = links_doc.css('a').find {|a| a.content == 'my files'}
+    assert_equal '../../../index.html', root_link.attribute('href').value
+    pics_link = links_doc.css('a').find {|a| a.content == 'pics'}
+    assert_equal '../../pics.html', pics_link.attribute('href').value
+    people_link = links_doc.css('a').find {|a| a.content == 'people'}
+    assert_equal '../people.html', people_link.attribute('href').value
+  end
+  
+  def test_each_parent_directory_link_tag_without_root
+    links = ''
+    sd = SiteDir.new('pics/people/friends', [], '/tmp')
+    sd.each_parent_directory_link_tag(false) {|link| links << link}
+    links_doc = Nokogiri::HTML(links)
+    links = links_doc.css('a')
+    assert_equal 2, links.size
+    
+    pics_link = links_doc.css('a').find {|a| a.content == 'pics'}
+    assert_equal '../../pics.html', pics_link.attribute('href').value
+    people_link = links_doc.css('a').find {|a| a.content == 'people'}
+    assert_equal '../people.html', people_link.attribute('href').value
+  end
+end

data/test/test_site.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TestSite < Test::Unit::TestCase
+  def test_create_site_tree_from_simple_public_dir
+    site = Site.new(File.join(FIXTURES_DIR, 'simple_public'))
+    root = site.read
+    
+    assert root.is_a? SiteDir
+    assert_equal '', root.path
+    assert_equal 2, root.files.size
+    assert root.files.find {|f| f.name == 'file1.txt'}
+    assert root.files.find {|f| f.name == 'file2.txt'}
+    assert_equal 1, root.dirs.size
+    
+    pics_dir = root.dirs[0]
+    assert_equal 'pics', pics_dir.path
+    assert_equal 2, pics_dir.files.size
+    
+    assert pics_dir.files.find {|f| f.name == 'leaves.jpg'}
+    assert pics_dir.files.find {|f| f.name == 'sculpture.jpg'}
+    assert_equal 1, pics_dir.dirs.size
+    
+    people_dir = pics_dir.dirs[0]
+    assert_equal 2, people_dir.files.size
+    assert people_dir.files.find {|f| f.name == 'concert.jpg'}
+    assert people_dir.files.find {|f| f.name == 'beach.jpg'}
+    assert people_dir.dirs.empty?
+  end
+  
+  def test_create_site_tree_from_simple_public_dir_with_exclusions
+    site = Site.new(
+      :public_dir => File.join(FIXTURES_DIR, 'simple_public'),
+      :excludes => ['pics', 'file1.txt']
+    )
+    root = site.read
+    
+    assert_equal 1, root.files.size
+    assert root.files.find {|f| f.name == 'file2.txt'}
+    assert root.dirs.empty?
+  end
+end

data/test/test_site_dir.rb

@@ -0,0 +1,20 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TestSiteDir < Test::Unit::TestCase
+  def test_name
+    assert_equal 'pic1.jpg', SiteDir.new('pic1.jpg', [], '/tmp').name
+    assert_equal 'pic1.jpg', SiteDir.new('/pics/pic1.jpg', [], '/tmp').name
+  end
+  
+  def test_root_name
+    assert_equal '', SiteDir.new('/', [], '/tmp').name
+    assert_equal '', SiteDir.new('', [], '/tmp').name
+  end
+  
+  def test_is_root
+    assert SiteDir.new('', [], '/tmp').root?
+    assert !SiteDir.new('/file.txt', [], '/tmp').root?
+    assert !SiteDir.new('/dir', [], '/tmp').root?
+    assert !SiteDir.new('/dir/file.txt', [], '/tmp').root?
+  end
+end

data/test/test_site_file.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+class TestSiteFile < Test::Unit::TestCase
+  def test_name
+    assert_equal 'pic1.jpg', SiteFile.new('pic1.jpg').name
+    assert_equal 'pic1.jpg', SiteFile.new('/pics/pic1.jpg').name
+  end
+  
+  def test_type
+    assert_equal 'image', SiteFile.new('/pics/pic1.jpg').file_type
+    assert_equal 'image', SiteFile.new('/pics/pic1.gif').file_type
+    assert_equal 'text', SiteFile.new('/pics/pic1.txt').file_type
+    assert_equal 'unknown', SiteFile.new('/pics/plainoldfile').file_type
+    assert_equal 'unknown', SiteFile.new('/pics/file.asdf').file_type
+  end
+  
+  def test_top_level
+    assert SiteFile.new('/pic1.jpg').top_level?
+    assert !SiteFile.new('/pics/pic1.jpg').top_level?
+  end
+  
+  def test_size
+    sf = SiteFile.new('/pic1.jpg')
+    sf.size_in_bytes = 100
+    assert_equal '100 B', sf.size
+    sf.size_in_bytes = 1024
+    assert_equal '1 KB', sf.size
+    sf.size_in_bytes = 1536
+    assert_equal '1.5 KB', sf.size
+    sf.size_in_bytes = 1792
+    assert_equal '1.8 KB', sf.size # rounded
+    sf.size_in_bytes = 1048576
+    assert_equal '1 MB', sf.size
+    sf.size_in_bytes = 3879731
+    assert_equal '3.7 MB', sf.size
+    sf.size_in_bytes = 1073741824
+    assert_equal '1 GB', sf.size
+    sf.size_in_bytes = 1099511627776
+    assert_equal '1 TB', sf.size
+  end
+end

data/test/test_write_site.rb

@@ -0,0 +1,102 @@
+require File.join(File.dirname(__FILE__), 'helper')
+require 'fileutils'
+require 'nokogiri'
+
+class TestWriteSite < Test::Unit::TestCase
+  TMP_DIR = File.join(FIXTURES_DIR, 'tmp')
+  
+  def setup
+    clean_tmp_dir
+  end
+  
+  def teardown
+    clean_tmp_dir
+  end
+  
+  def test_simple_process
+    FileUtils.cp_r(File.join(FIXTURES_DIR, 'simple_public'), File.join(TMP_DIR, 'simple_public'))
+    site = Site.new(:public_dir => File.join(TMP_DIR, 'simple_public'), :quiet => true)
+    site.process
+    
+    # Check that all the index pages are there
+    
+    index_file = File.join(site.public_dir, 'index.html')
+    assert File.exist?(index_file)
+    index_doc = Nokogiri::HTML(IO.read(index_file))
+    assert_equal 3, index_doc.css('.entry').size
+    
+    assert_equal 'dropsite/pics.html', index_doc.css('a').find {|a| a.content == 'pics'}.attribute('href').value
+    
+    site_dir = File.join(site.public_dir, 'dropsite')
+    assert File.exist?(site_dir)
+    assert File.directory?(site_dir)
+    
+    pics_file = File.join(site_dir, 'pics.html')
+    assert File.exist?(pics_file)
+    pics_doc = Nokogiri::HTML(IO.read(pics_file))
+    assert_equal 3, pics_doc.css('.entry').size
+    
+    # Make sure the the links are correct
+    
+    ['leaves.jpg', 'sculpture.jpg'].each do |pic|
+      assert_equal "../pics/#{pic}", pics_doc.css('a').find {|a| a.content == pic}.attribute('href').value
+    end
+    
+    assert_equal 'pics/people.html', pics_doc.css('a').find {|a| a.content == 'people'}.attribute('href').value
+    
+    people_file = File.join(site_dir, 'pics', 'people.html')
+    assert File.exist?(people_file)
+    people_doc = Nokogiri::HTML(IO.read(people_file))
+    assert_equal 2, people_doc.css('.entry').size
+    
+    ['beach.jpg', 'concert.jpg'].each do |pic|
+      assert_equal "../../pics/people/#{pic}", people_doc.css('a').find {|a| a.content == pic}.attribute('href').value
+    end
+    
+    # Check that the assets were copied in
+    
+    assets_dir = File.join(site.public_dir, 'dropsite', 'dropsite-assets')
+    assert File.exist?(assets_dir)
+    assert File.directory?(assets_dir)
+    simple_index_assets_dir = File.join(assets_dir, 'simple_index')
+    assert File.exist?(simple_index_assets_dir)
+    assert File.directory?(simple_index_assets_dir)
+    assert File.exist?(File.join(simple_index_assets_dir, 'css', 'simple_index.css'))
+    
+    # Check that the assets are included correctly
+    
+    assert_equal 1, index_doc.css('link').find_all {|l|
+      l.attribute('href').value == 'dropsite/dropsite-assets/simple_index/css/simple_index.css'
+    }.size
+    assert_equal 1, index_doc.css('script').find_all {|l|
+      l.attribute('src').value == 'dropsite/dropsite-assets/simple_index/js/simple_index.js'
+    }.size
+    
+    assert_equal 1, pics_doc.css('link').find_all {|l|
+      l.attribute('href').value == 'dropsite-assets/simple_index/css/simple_index.css'
+    }.size
+    assert_equal 1, pics_doc.css('script').find_all {|l|
+      l.attribute('src').value == 'dropsite-assets/simple_index/js/simple_index.js'
+    }.size
+    
+    assert_equal 1, people_doc.css('link').find_all {|l|
+      l.attribute('href').value == '../dropsite-assets/simple_index/css/simple_index.css'
+    }.size
+    assert_equal 1, people_doc.css('script').find_all {|l|
+      l.attribute('src').value == '../dropsite-assets/simple_index/js/simple_index.js'
+    }.size
+  end
+  
+  protected
+  
+  def clean_tmp_dir
+     Dir.entries(TMP_DIR).reject {|e| e =~ /^\./}.each do |entry|
+        file = File.join(TMP_DIR, entry)
+        if File.directory?(file)
+          FileUtils.rm_rf(file)
+        else
+          File.delete(file)
+        end
+      end
+  end
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification 
+name: dropsite
+version: !ruby/object:Gem::Version 
+  hash: 15
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  version: "0.2"
+platform: ruby
+authors: 
+- Aaron Royer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-11 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: creates index pages in your Dropbox public directory
+email: aaronroyer@gmail.com
+executables: 
+- dropsite
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/dropsite
+- lib/dropsite/dir_renderer.rb
+- lib/dropsite/plugins/simple_index/assets/css/reset.css
+- lib/dropsite/plugins/simple_index/assets/css/simple_index.css
+- lib/dropsite/plugins/simple_index/assets/images/icons/directory.png
+- lib/dropsite/plugins/simple_index/assets/images/icons/image.png
+- lib/dropsite/plugins/simple_index/assets/images/icons/pdf.png
+- lib/dropsite/plugins/simple_index/assets/images/icons/script.png
+- lib/dropsite/plugins/simple_index/assets/images/icons/text.png
+- lib/dropsite/plugins/simple_index/assets/images/icons/unknown.png
+- lib/dropsite/plugins/simple_index/assets/images/row-bg.png
+- lib/dropsite/plugins/simple_index/assets/simple_index.js
+- lib/dropsite/plugins/simple_index/simple_index.erb
+- lib/dropsite/plugins/simple_index/simple_index.rb
+- lib/dropsite/plugins.rb
+- lib/dropsite/render_helper.rb
+- lib/dropsite/site.rb
+- lib/dropsite/site_dir.rb
+- lib/dropsite/site_file.rb
+- lib/dropsite/site_item.rb
+- lib/dropsite.rb
+- test/fixtures/simple_public/file1.txt
+- test/fixtures/simple_public/file2.txt
+- test/fixtures/simple_public/pics/leaves.jpg
+- test/fixtures/simple_public/pics/people/beach.jpg
+- test/fixtures/simple_public/pics/people/concert.jpg
+- test/fixtures/simple_public/pics/sculpture.jpg
+- test/helper.rb
+- test/test_render_helper.rb
+- test/test_site.rb
+- test/test_site_dir.rb
+- test/test_site_file.rb
+- test/test_write_site.rb
+- README
+- LICENSE
+- dropsite.gemspec
+- Rakefile
+has_rdoc: true
+homepage: https://rubygems.org/gems/dropsite
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+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: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: "Dropsite creates a site of interlinked file index pages in the Public directory of your Dropbox. The site created is minimally invasive to your Public directory by only creating one top-level HTML page and one folder, leaving your directories unjunked. BE WARNED: while I _think_ this probably works fine, it is presently considered experimental."
+test_files: 
+- test/test_render_helper.rb
+- test/test_site.rb
+- test/test_site_dir.rb
+- test/test_site_file.rb
+- test/test_write_site.rb