redwood 0.0.1 → 0.1.0

data/README.md

@@ -1,17 +1,90 @@
-= redwood
+# redwood
 
-Not quite baked yet.
+Simple Ruby trees. Redwood is a simple implementation of a tree data structure in pure Ruby. It provides a few things:
 
-== Note on Patches/Pull Requests
- 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
++ The `redwood` command-line tool: like the Unix [`tree`](http://mama.indstate.edu/users/ice/tree/) tool, but in Ruby!
++ The Redwood module for basic tree-esqueness.
++ Redwood::Node class for basic tree-nodiness
++ Redwood::FileNode class for representing Directories and Files in a tree-like way.
 
-== Copyright
+[RDoc](http://rdoc.info/projects/mwunsch/redwood) | [Gem](http://rubygems.org/gems/redwood)
 
-Copyright (c) 2010 Mark Wunsch. See LICENSE for details.
+## Installation
+
+	gem install redwood
+
+## `redwood`
+
+The `redwood` command-line tool attempts a pure Ruby implementation of [tree](http://man.cx/tree).
+
+	USAGE: redwood [ OPTIONS ] [ DIRECTORY ]
+	
+Looks a bit like this:
+
+	Redwood
+	|-- bin
+	|   `-- redwood
+	|-- Gemfile
+	|-- lib
+	|   |-- redwood
+	|   |   |-- filenode.rb
+	|   |   `-- node.rb
+	|   `-- redwood.rb
+	|-- LICENSE
+	|-- pkg
+	|   `-- redwood-0.0.1.gem
+	|-- Rakefile
+	|-- README.md
+	|-- redwood.gemspec
+	`-- test
+	    |-- helper.rb
+	    `-- test_redwood.rb
+
+	5 directories, 12 files
+	
+Help is a `redwood --help` away. See also: [redwood(1)](http://mwunsch.github.com/redwood/)
+
+## `Redwood`
+
+The Redwood module is a module for including/extending tree-like features on your objects. It stores nodes in an Array. The only requirement for children is that they too include/extend tree-like features.
+
+Methods include:
+
+	root?	 		## Is this a root node? Meaning, it has no parent.
+	leaf? 			## Is this a leaf node? Meaning, is it without children?
+	root  			## Get the root node in this tree.
+	children 		## Get the children of this node.
+	siblings		## Get this nodes siblings.
+	only_child? 	## Is this node without siblings?
+	has_children? 	## Does this node have children?
+	ancestors 		## All of the parent nodes of this node.
+	descendants 	## All of the descendant nodes of this node.
+	depth 			## Integer representing how deep this node is in the tree.
+					## A root node has a depth of 1, its children: 2, etc.
+	unlink			## Detach this node from its parent.
+	prune			## Unlink all of this node's chidren.
+	walk			## Recursively yield every node in this tree to a block
+	view			## Make a fancy string representation of the tree
+					## as seen in the command-line tool
+					
+### Redwood::Node
+
+The Redwood::Node class is a simple implementation of the Redwood module. It is a good starting point for other trees. It adds new methods:
+
+	add_child(name)		## Add a child node. Nodes can have a #name.
+	[](name)			## Lookup children node by their #name.
+	<<(node)			## Add a node to this node's children.
+	
+#### Redwood::FileNode
+	
+The Redwood::FileNode class is an example use-case for Redwood, and it powers the `redwood` CLI. It stores a directory tree in a Redwood-backed structure. It has one primary method that does the magic:
+
+	dir = Redwood::FileNode.scandir '~/Projects/Redwood'
+	
+That will go through the directory and build a Redwood tree. Redwood::FileNode objects have methods that correspond to the `File` class. So you can do things like `dir.directory?` or `dir.chmod`.
+
+Now go forth and grow some Ruby-flavored trees.
+
+## Copyright
+
+Redwood is Copyright (c) 2010 Mark Wunsch and is licensed under the [MIT License](http://creativecommons.org/licenses/MIT/).

data/Rakefile

@@ -46,3 +46,13 @@ desc "Open an irb session preloaded with this library"
 task :console do
   sh "irb -rubygems -I lib -r redwood"
 end
+
+desc "Build the manual"
+task :build_man do
+  sh "ronn -br5 --organization='Mark Wunsch' --manual='Redwood Manual' man/*.ronn"
+end
+ 
+desc "Show the manual"
+task :man => :build_man do
+  exec "man man/redwood.1"
+end

data/bin/redwood

@@ -0,0 +1,120 @@
+#!/usr/bin/env ruby
+## Redwood is an implementation of `tree` in Ruby
+##
+## Usage: redwood [ OPTIONS ] [ DIRECTORY ]
+## 
+## Learn more about the original at:
+## http://mama.indstate.edu/users/ice/tree/
+##
+##
+
+require 'optparse'
+
+def usage
+  File.readlines(__FILE__).
+  grep(/^##.*/).
+  map { |line| line.chomp[3..-1] }.
+  join("\n")
+end
+
+begin
+  require 'redwood'
+rescue LoadError
+  raise if $!.to_s !~ /redwood/
+  libdir = File.expand_path("../../lib", __FILE__).sub(/^#{Dir.pwd}/, '.')
+  if !$:.include?(libdir)
+    $:.unshift libdir
+    retry
+  end
+  raise
+end
+
+options = {
+  :follow_symlinks => false,
+  :show_hidden_files => false
+}
+ARGV.options do |option|
+  option.banner = usage
+  option.separator "Options"
+  option.on('-a','All files are listed.') { options[:show_hidden_files] = true }
+  option.on('-d','List directories only.') { options[:only_directories] = true }
+  option.on('-l','Follow symbolic links like directories.') { options[:follow_symlinks] = true }
+  option.on('-f','Print the full path prefix for each file.') { options[:full_path] = true }
+  option.on('-s','Print the size in bytes of each file.') { options[:size] = true }
+  option.on('-D','Print the date of last modification.') { options[:date] = :mtime }
+  option.on('-F',"Appends '/', '@', '=', '*', or '|' as per ls -F.") { options[:ftype] = true }
+  option.on('-L level','Descend only level directories deep.') { |depth| options[:depth] = depth.to_i + 1}
+  option.separator ""  
+  option.on_tail('--version','Prints version and exits.') { puts Redwood::VERSION ; exit }
+  option.on_tail('--help','Prints this help screen.') { puts option ; exit }
+  option.parse!
+end
+
+def statement(tree)
+  directories = 0
+  files = 0
+  tree.descendants.each do |f|
+    if f.directory?
+      directories += 1
+    else
+      files += 1
+    end
+  end
+  d = directories.eql?(1) ? 'directory' : 'directories'
+  f = files.eql?(1) ? 'file' : 'files'
+  "#{directories} #{d}, #{files} #{f}"
+end
+
+def setup_tree(tree, options)
+  if options[:depth]
+    abort 'Invalid level, must be greater than 0' if options[:depth] <= 1
+    tree.descendants.each {|f| f.unlink if f.depth > options[:depth] }
+  end
+  if !options[:follow_symlinks]
+    tree.descendants.each do |f|
+      if f.symlink?        
+        f.value << " -> #{f.readlink}"
+      end
+      f.unlink if f.parent.symlink?
+    end
+  end
+  if options[:only_directories]
+    tree.descendants.each {|f| f.unlink if !f.directory? }
+  end
+  if !options[:show_hidden_files]
+    tree.descendants.each do |f| 
+        f.unlink if f.basename.index('.').eql?(0)
+    end
+  end
+  tree.walk {|f| f.value = f.path } if options[:full_path]
+  
+  if options[:date]
+    tree.descendants.each {|f| f.value.insert(0,"[#{f.send(options[:date]).strftime('%b %d %H:%M')}] ") }
+  end
+  if options[:size]
+    tree.descendants.each {|f| f.value.insert(0,"[#{f.size}] ") if f.size? }
+  end
+  if options[:ftype]
+    tree.descendants.each do |f|
+      f.value << "|" if f.ftype == 'fifo'
+      if f.symlink?
+        f.value << "@"
+      elsif f.directory?
+        f.value << "/"
+      end
+      f.value << "*" if f.executable? && f.file?
+      f.value << "=" if f.socket?
+    end
+  end
+  tree
+end
+
+dir = ARGV.empty? ? '.' : ARGV.first
+abort %Q{"#{dir}" is not a directory.} if !File.directory?(dir)
+
+tree = setup_tree Redwood::FileNode.scandir(dir), options
+puts tree.view(:value)
+puts "\n"
+puts statement(tree)
+exit
+  

data/lib/redwood.rb

@@ -1,29 +1,27 @@
-# The Redood module can be mixed in to give tree-like methods to an object.
+# The Redwood module can be mixed in to give tree-like methods to an object.
 # Its primary implementation is the Redwood::Node class. Its only requirement
 # is that the tree-infused-object's children and parent is an object that 
-# also mixes in Redwood. See Redwood::Node for the canononical representation.
+# also mixes in tree-like methods. See Redwood::Node for the canononical representation.
 
 module Redwood
-  VERSION = "0.0.1" 
+  VERSION = "0.1.0" 
   
+  # This node's parent.
   def parent
     @parent
   end
   
-  def name
-  end
-  
-  def value
-  end
-  
+  # Is this node the root of the tree?
   def root?
     parent.nil?
   end
   
+  # Is this node a leaf node? Is this node childless?
   def leaf?
-    children.empty?
+    children.nil? || children.empty?
   end
   
+  # Get the root node in this tree.
   def root
     if root?
       self
@@ -31,56 +29,84 @@ module Redwood
       parent.root
     end
   end
-
+  
+  # Get the children of this node.
   def children
     @children ||= []
   end
   
+  # Get the siblings of this node. The other children belonging to this node's parent.
   def siblings
     if parent
       parent.children.reject {|child| child == self }
     end
   end
   
+  # Is this node the only child of its parent. Does it have any siblings?
   def only_child?
     if parent
       siblings.empty?
     end
   end
   
-  def childless?
-    children.nil? || children.empty?
-  end
-  
+  # Does this node have children? Is it not a leaf node?
   def has_children?
-    !childless?
+    !leaf?
   end
-
+  
+  # Get all of the ancestors for this node.
   def ancestors
-    return @ancestors if @ancestors
-    @ancestors = []
+    ancestors = []
     if parent
-      @ancestors << parent
-      parent.ancestors.each {|ancestor| @ancestors << ancestor }
+      ancestors << parent
+      parent.ancestors.each {|ancestor| ancestors << ancestor }
     end
-    @ancestors
+    ancestors
   end
-
+  
+  # Get all of the descendants of this node.
+  # All of its children, and its childrens' children, and its childrens' childrens' children...
   def descendants
-    return @descendants if @descendants
-    @descendants = []
+    descendants = []
     if !children.empty?
-      (@descendants << children).flatten!
-      children.each {|descendant| @descendants << descendant.descendants }
-      @descendants.flatten!   
+      (descendants << children).flatten!
+      children.each {|descendant| descendants << descendant.descendants }
+      descendants.flatten!   
     end
-    @descendants
+    descendants
   end
-
+  
+  # An integer representation of how deep in the tree this node is.
+  # The root node has a depth of 1, its children have a depth of 2, etc.
   def depth
     ancestors.size + 1
   end
   
+  # Orphan this node. Remove it from its parent node.
+  def unlink
+    if parent
+      parent.children.delete(self)
+      self.instance_variable_set(:@parent, nil)
+      return self
+    end
+  end
+  
+  # Abandon all of this node's children.
+  def prune
+    if children
+      children.each {|child| child.unlink }
+    end
+  end
+  
+  # Recursively yield every node in the tree.
+  def walk(&block)
+    if block_given?
+      yield self
+      children.each {|child| child.walk(&block) }
+    end
+  end
+  
+  # Makes a pretty string representation of the tree.
   def view(content = :name)
     treeview = ''
     if parent
@@ -88,7 +114,7 @@ module Redwood
       treeview << "--\s"
     end
     treeview << "#{self.send(content)}"
-    if !children.empty?
+    if has_children?
       treeview << "\n"
       children.each do |child|
         if parent
@@ -109,6 +135,6 @@ module Redwood
     treeview
   end
   
-end
-
-require 'redwood/node'
+  autoload :FileNode, 'redwood/filenode'
+  autoload :Node, 'redwood/node'
+end

data/lib/redwood/filenode.rb

@@ -0,0 +1,46 @@
+# Redwood::FileNode stores a Directory tree in a Redwood structure. 
+# FileNodes respond to methods of the File class.
+# eg. FileNode#chmod, FileNode#stat, etc.
+
+module Redwood
+  class FileNode < Node
+    
+    # Takes a path and scans the directory, creating a Redwood tree.
+    def self.scandir(dir = Dir.pwd, tree=nil)
+      node = tree ? tree : self.new(dir)
+      if File.directory?(dir)
+        Dir.foreach(dir) do |d|
+          if File.directory?("#{dir}/#{d}")
+            node << scandir("#{dir}/#{d}",tree) unless (d.eql?('..') || d.eql?('.'))
+          else
+            node.add_child("#{dir}/#{d}")
+          end
+        end
+      else
+        node.add_child(dir)
+      end
+      node
+    end
+    
+    attr_reader :path
+    
+    def initialize(name, parent=nil)
+      super
+      @path = File.expand_path(name)
+    end
+    
+    # Some information to store in the node. Defaults to the basename of the file/directory
+    def value
+      @value ||= basename
+    end
+    
+    def method_missing(method, *args, &block)
+      if File.respond_to?(method)
+        File.send method, path
+      else
+        super
+      end
+    end
+    
+  end
+end

data/lib/redwood/node.rb

@@ -1,8 +1,11 @@
+# A basic representation of a Redwood tree.
+
 module Redwood
   class Node
     include Redwood
     
     attr_reader :name
+    attr_accessor :value
     
     def initialize(name=nil, parent=nil)
       @name = name
@@ -12,10 +15,19 @@ module Redwood
     # Creates a child, adds it to children, and returns the child
     def add_child(name)
       child = self.class.new(name, self)
+      yield child if block_given?
       children << child
       child
     end
     
+    # Add a node to this nodes children, and return the child
+    def <<(child)
+      child.instance_variable_set(:@parent, self)
+      children << child
+      child
+    end
+    
+    # Lookup a child node by its name
     def [](key)
       selected_child = children.select {|child| child.name == key }
       selected_child.size.eql?(1) ? selected_child.first : selected_child

data/man/redwood.1

@@ -0,0 +1,86 @@
+.\" generated with Ronn/v0.5
+.\" http://github.com/rtomayko/ronn/
+.
+.TH "REDWOOD" "1" "April 2010" "Mark Wunsch" "Redwood Manual"
+.
+.SH "NAME"
+\fBredwood\fR \-\- Ruby\-flavored tree
+.
+.SH "SYNOPSIS"
+\fBredwood\fR [\fIOPTIONS\fR] \fIDIRECTORY\fR
+.
+.SH "DESCRIPTION"
+\fBredwood\fR is an implementation of \fBtree\fR in Ruby. Like the original \fBTree\fR, \fBRedwood\fR is a recursive directory listing program, producing a pretty\-looking depth indented listing of directory contents. Without arguments, \fBredwood\fR lists the files in the current directory. Like \fBtree\fR, after listing, \fBredwood\fR prints a summary of the total number of files and/or directories listed.
+.
+.P
+And, again like the original \fBtree\fR, symbolic links are not followed and hidden files (those beginning with a '.') remain unseen by default. You can reveal them with options. File system constructs, the current directory as '.' and the parent directory as '..', are never printed.
+.
+.P
+Learn more about the original \fBtree\fR with tree(1) and at http://mama.indstate.edu/users/ice/tree/
+.
+.P
+This is a proof\-of\-concept. It's written in Ruby. It does half of what \fBtree\fR does pretty well. You should probably just use \fBtree\fR.
+.
+.SH "OPTIONS"
+.
+.TP
+\fB\-a\fR
+  Print all files, even hidden ones (that begin with a '.').
+.
+.TP
+\fB\-d\fR
+  Only list directories.
+.
+.TP
+\fB\-l\fR
+  Follow symbolic links (that point to directories), as though they were directories. There is no protection from recursion, so don't do that.
+.
+.TP
+\fB\-f\fR
+  Print the full path prefix for each file.
+.
+.TP
+\fB\-s\fR
+  Print the size of each file in bytes.
+.
+.TP
+\fB\-D\fR
+  Print the date of last modification for the file, in the format like: 'Aug 25 14:92'
+.
+.TP
+\fB\-F\fR
+  Appends '/' to directories, '@' to symlinks, '=' to sockets, '*' to executables, and '|' to FIFO's, as per ls \-F.
+.
+.TP
+\fB\-L\fR \fIlevel\fR
+  Max display depth of the directory tree. Has got to be greater than 0.
+.
+.P
+Other:
+.
+.TP
+\fB\-\-help\fR
+  Print the help message and quit.
+.
+.TP
+\fB\-\-version\fR
+  Print the \fBredwood\fR version and quit.
+.
+.SH "INSTALLATION"
+If you have RubyGems installed:
+.
+.IP "" 4
+.
+.nf
+
+gem install redwood
+.
+.fi
+.
+.IP "" 0
+.
+.SH "COPYRIGHT"
+Redwood is Copyright (C) 2010 Mark Wunsch
+.
+.SH "SEE ALSO"
+tree(1), ls(1)

data/man/redwood.1.html

@@ -0,0 +1,128 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv='content-type' value='text/html;charset=utf8'>
+  <meta name='generator' value='Ronn/v0.5'>
+  <title>redwood(1) -- Ruby-flavored tree</title>
+  <style type='text/css'>
+    body {margin:0}
+    #man, #man code, #man pre, #man tt, #man kbd, #man samp {
+      font-family:consolas,monospace;
+      font-size:16px;
+      line-height:1.3;
+      color:#343331;
+      background:#fff; }
+    #man { max-width:89ex; text-align:justify; margin:0 25px 25px 25px }
+    #man h1, #man h2, #man h3 { color:#232221;clear:left }
+    #man h1 { font-size:28px; margin:15px 0 30px 0; text-align:center }
+    #man h2 { font-size:18px; margin-bottom:0; margin-top:10px; line-height:1.3; }
+    #man h3 { font-size:16px; margin:0 0 0 4ex; }
+    #man p, #man ul, #man ol, #man dl, #man pre { margin:0 0 18px 0; }
+    #man pre {
+      color:#333231;
+      background:#edeceb;
+      padding:5px 7px;
+      margin:0px 0 20px 0;
+      border-left:2ex solid #ddd}
+    #man pre + h2, #man pre + h3 {
+      margin-top:22px;
+    }
+    #man h2 + pre, #man h3 + pre {
+      margin-top:5px;
+    }
+    #man > p, #man > ul, #man > ol, #man > dl, #man > pre { margin-left:8ex; }
+    #man dt { margin:0; clear:left }
+    #man dt.flush { float:left; width:8ex }
+    #man dd { margin:0 0 0 9ex }
+    #man code, #man strong, #man b { font-weight:bold; color:#131211; }
+    #man pre code { font-weight:normal; color:#232221; background:inherit }
+    #man em, var, u {
+      font-style:normal; color:#333231; border-bottom:1px solid #999; }
+    #man h1.man-title { display:none; }
+    #man ol.man, #man ol.man li { margin:2px 0 10px 0; padding:0;
+      float:left; width:33%; list-style-type:none;
+      text-transform:uppercase; font-size:18px; color:#999;
+      letter-spacing:1px;}
+    #man ol.man { width:100%; }
+    #man ol.man li.tl { text-align:left }
+    #man ol.man li.tc { text-align:center;letter-spacing:4px }
+    #man ol.man li.tr { text-align:right }
+    #man ol.man a { color:#999 }
+    #man ol.man a:hover { color:#333231 }
+  </style>
+</head>
+<body>
+<div id='man'>
+
+<h1 class='man-title'>redwood(1)</h1>
+
+<ol class='head man'>
+  <li class='tl'>redwood(1)</li>
+  <li class='tc'>Redwood Manual</li>
+  <li class='tr'>redwood(1)</li>
+</ol>
+
+<h2 id='NAME'>NAME</h2>
+<p><code>redwood</code> -- Ruby-flavored tree</p>
+
+<h2>SYNOPSIS</h2>
+
+<p><code>redwood</code> [<var>OPTIONS</var>] <var>DIRECTORY</var></p>
+
+<h2>DESCRIPTION</h2>
+
+<p><code>redwood</code> is an implementation of <code>tree</code> in Ruby. Like the original <code>Tree</code>, <code>Redwood</code> is a recursive directory listing program, producing a pretty-looking depth indented listing of directory contents. Without arguments, <code>redwood</code> lists the files in the current directory. Like <code>tree</code>, after listing, <code>redwood</code> prints a summary of the total number of files and/or directories listed.</p>
+
+<p>And, again like the original <code>tree</code>, symbolic links are not followed and hidden files (those beginning with a '.') remain unseen by default. You can reveal them with options. File system constructs, the current directory as '.' and the parent directory as '..', are never printed.</p>
+
+<p>Learn more about the original <code>tree</code> with tree(1) and at http://mama.indstate.edu/users/ice/tree/</p>
+
+<p>This is a proof-of-concept. It's written in Ruby. It does half of what <code>tree</code> does pretty well. You should probably just use <code>tree</code>.</p>
+
+<h2>OPTIONS</h2>
+
+<dl>
+<dt class="flush"><code>-a</code></dt><dd><p>  Print all files, even hidden ones (that begin with a '.').</p></dd>
+<dt class="flush"><code>-d</code></dt><dd><p>  Only list directories.</p></dd>
+<dt class="flush"><code>-l</code></dt><dd><p>  Follow symbolic links (that point to directories), as though they were directories. There is no protection from recursion, so don't do that.</p></dd>
+<dt class="flush"><code>-f</code></dt><dd><p>  Print the full path prefix for each file.</p></dd>
+<dt class="flush"><code>-s</code></dt><dd><p>  Print the size of each file in bytes.</p></dd>
+<dt class="flush"><code>-D</code></dt><dd><p>  Print the date of last modification for the file, in the format like: 'Aug 25 14:92'</p></dd>
+<dt class="flush"><code>-F</code></dt><dd><p>  Appends '/' to directories, '@' to symlinks, '=' to sockets, '*' to executables, and '|' to FIFO's, as per ls -F.</p></dd>
+<dt><code>-L</code> <em>level</em></dt><dd><p>  Max display depth of the directory tree. Has got to be greater than 0.</p></dd>
+</dl>
+
+
+<p>Other:</p>
+
+<dl>
+<dt class="flush"><code>--help</code></dt><dd><p>  Print the help message and quit.</p></dd>
+<dt><code>--version</code></dt><dd><p>  Print the <code>redwood</code> version and quit.</p></dd>
+</dl>
+
+
+<h2>INSTALLATION</h2>
+
+<p>If you have RubyGems installed:</p>
+
+<pre><code>gem install redwood
+</code></pre>
+
+<h2>COPYRIGHT</h2>
+
+<p>Redwood is Copyright (C) 2010 Mark Wunsch</p>
+
+<h2>SEE ALSO</h2>
+
+<p>tree(1), ls(1)</p>
+
+
+<ol class='foot man'>
+  <li class='tl'>Mark Wunsch</li>
+  <li class='tc'>April 2010</li>
+  <li class='tr'>redwood(1)</li>
+</ol>
+
+</div>
+</body>
+</html>

data/man/redwood.1.ronn

@@ -0,0 +1,64 @@
+redwood(1) -- Ruby-flavored tree
+===================================
+
+## SYNOPSIS
+
+`redwood` [<OPTIONS>] <DIRECTORY>
+
+## DESCRIPTION
+
+`redwood` is an implementation of `tree` in Ruby. Like the original `Tree`, `Redwood` is a recursive directory listing program, producing a pretty-looking depth indented listing of directory contents. Without arguments, `redwood` lists the files in the current directory. Like `tree`, after listing, `redwood` prints a summary of the total number of files and/or directories listed.
+
+And, again like the original `tree`, symbolic links are not followed and hidden files (those beginning with a '.') remain unseen by default. You can reveal them with options. File system constructs, the current directory as '.' and the parent directory as '..', are never printed.
+
+Learn more about the original `tree` with tree(1) and at http://mama.indstate.edu/users/ice/tree/
+
+This is a proof-of-concept. It's written in Ruby. It does half of what `tree` does pretty well. You should probably just use `tree`. 
+
+## OPTIONS
+
+* `-a`:
+	Print all files, even hidden ones (that begin with a '.').
+	
+* `-d`:
+	Only list directories.
+	
+* `-l`:
+	Follow symbolic links (that point to directories), as though they were directories. There is no protection from recursion, so don't do that.
+	
+* `-f`:
+	Print the full path prefix for each file.
+
+* `-s`:
+	Print the size of each file in bytes.
+	
+* `-D`:
+	Print the date of last modification for the file, in the format like: 'Aug 25 14:92'
+
+* `-F`:
+	Appends '/' to directories, '@' to symlinks, '=' to sockets, '*' to executables, and '|' to FIFO's, as per ls -F.	
+	
+* `-L` _level_:
+	Max display depth of the directory tree. Has got to be greater than 0.
+
+Other:
+
+* `--help`:
+	Print the help message and quit.
+	
+* `--version`:
+	Print the `redwood` version and quit.
+	
+## INSTALLATION
+
+If you have RubyGems installed:
+
+	gem install redwood
+
+## COPYRIGHT
+
+Redwood is Copyright (C) 2010 Mark Wunsch
+
+## SEE ALSO
+
+tree(1), ls(1)

data/redwood.gemspec

@@ -0,0 +1,62 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{redwood}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Mark Wunsch"]
+  s.date = %q{2010-04-10}
+  s.default_executable = %q{redwood}
+  s.description = %q{A simple library to create and manage basic tree-esque structures.}
+  s.email = ["mark@markwunsch.com"]
+  s.executables = ["redwood"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.md"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "Gemfile",
+     "LICENSE",
+     "README.md",
+     "Rakefile",
+     "bin/redwood",
+     "lib/redwood.rb",
+     "lib/redwood/filenode.rb",
+     "lib/redwood/node.rb",
+     "man/redwood.1",
+     "man/redwood.1.html",
+     "man/redwood.1.ronn",
+     "redwood.gemspec",
+     "test/helper.rb",
+     "test/test_redwood.rb"
+  ]
+  s.homepage = %q{http://github.com/mwunsch/redwood}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Ruby trees}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_redwood.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bundler>, [">= 0.9.7"])
+    else
+      s.add_dependency(%q<bundler>, [">= 0.9.7"])
+    end
+  else
+    s.add_dependency(%q<bundler>, [">= 0.9.7"])
+  end
+end
+

data/test/test_redwood.rb

@@ -7,12 +7,6 @@ class TestRedwood < Test::Unit::TestCase
       assert_equal :test, node.name
     end
     
-    test 'can be without children' do
-      node = Redwood::Node.new
-      assert node.childless?
-      assert !node.has_children?
-    end
-    
     test 'can be a root element' do
       node = Redwood::Node.new
       assert node.root?
@@ -126,6 +120,79 @@ class TestRedwood < Test::Unit::TestCase
       assert_respond_to node, :view
       assert_equal String, node.view.class
     end
-        
+    
+    test 'is a leaf node' do
+      node = Redwood::Node.new(:parent)
+      child = node.add_child(:child)
+      
+      assert !node.leaf?
+      assert child.leaf?
+    end
+    
+    test 'walks the tree' do
+      node = Redwood::Node.new(:parent)
+      dog = node.add_child(:dog)
+      puppy = dog.add_child(:puppy)
+      son = node.add_child(:son)      
+      daughter = node.add_child(:daughter)
+      grandson = son.add_child(:grandson)
+      counter = 0
+      node.walk {|n| counter += 1 }
+      assert_equal 6, counter
+    end
+    
+    test 'add a child with the << method' do
+      node = Redwood::Node.new(:parent)
+      dog = Redwood::Node.new(:dog)
+      
+      node << dog
+      assert_equal node, dog.parent
+      assert node.children.include?(dog)
+      assert !dog.root?
+      assert !node.leaf?
+    end
+    
+    test 'has an optional arbitrary value' do
+      node = Redwood::Node.new(:parent)
+      node.value = "hello world"
+      assert_equal "hello world", node.value
+    end
+    
+    test 'unlinks a node from its parent' do
+      node = Redwood::Node.new(:parent)
+      dog = node.add_child :dog
+      
+      dog.unlink
+      assert node.leaf?
+      assert !node.children.include?(dog)
+      assert dog.root?
+    end
+    
+    test 'prunes its children' do
+      node = Redwood::Node.new(:parent)
+      dog = node.add_child :dog
+      
+      node.prune
+      assert node.children.empty?
+      assert node.leaf?
+      assert !dog.parent
+    end          
+  end
+
+  describe 'FileNode' do
+    test 'scan a directory' do
+      dir = Redwood::FileNode.scandir
+      assert_equal Dir.pwd, dir.name
+    end
+    
+    test 'implements File methods on the Node' do
+      dir = Redwood::FileNode.scandir
+      assert dir.directory?
+    end
+    
+    test 'has a full path' do
+      dir = Redwood::FileNode.scandir('.')
+      assert_equal File.expand_path('.'), dir.path
+    end
   end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 0
   - 1
-  version: 0.0.1
+  - 0
+  version: 0.1.0
 platform: ruby
 authors: 
 - Mark Wunsch
@@ -14,8 +14,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-09 00:00:00 -04:00
-default_executable: 
+date: 2010-04-10 00:00:00 -04:00
+default_executable: redwood
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: bundler
@@ -34,8 +34,8 @@ dependencies:
 description: A simple library to create and manage basic tree-esque structures.
 email: 
 - mark@markwunsch.com
-executables: []
-
+executables: 
+- redwood
 extensions: []
 
 extra_rdoc_files: 
@@ -48,8 +48,14 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- bin/redwood
 - lib/redwood.rb
+- lib/redwood/filenode.rb
 - lib/redwood/node.rb
+- man/redwood.1
+- man/redwood.1.html
+- man/redwood.1.ronn
+- redwood.gemspec
 - test/helper.rb
 - test/test_redwood.rb
 has_rdoc: true