valise 0.3

data/doc/coverage/print.css

@@ -0,0 +1,12 @@
+/* Hide controls */
+
+  body {
+    color: #000000;
+    background-color: #ffffff;
+  }
+
+/* Hide controls */
+
+  div.filters {
+    display: none;
+  }

data/doc/coverage/rcov.js

@@ -0,0 +1,42 @@
+function toggleCode( id ) {
+  if ( document.getElementById ) {
+    elem = document.getElementById( id );
+  } else if ( document.all ) {
+    elem = eval( "document.all." + id );
+  } else {
+    return false;
+  }
+  
+  elemStyle = elem.style;
+
+  if ( elemStyle.display != "block" ) {
+    elemStyle.display = "block";
+  } else {
+    elemStyle.display = "none";
+  }
+
+  return true;
+}
+
+function restripe() {
+  i = 0;
+  $('table#report_table tbody tr').each(function(){
+    if (this.style.display != "none") {
+      i += 1;
+      classes = this.className.split(" ");
+      if ($.inArray("even",classes) != -1) {
+        classes.splice($.inArray("even",classes),1);
+      } else if ($.inArray("odd",classes) != -1) {
+        classes.splice($.inArray("odd",classes),1);
+      }
+      if (i % 2 === 0) {
+        this.className = classes.join(" ") + " odd";
+      } else {
+        this.className = classes.join(" ") + " even";
+      }
+    }
+  });
+}
+
+// Fix IE's lack of support for indexOf (!)
+if (!Array.indexOf) { Array.prototype.indexOf = function(obj){ for(var i=0; i<this.length; i++){ if(this[i]==obj){return i;} } return -1; }}

data/doc/coverage/screen.css

@@ -0,0 +1,270 @@
+/* @group General */
+
+  body {
+    font-family: Verdana, Helvetica, Arial, Sans-Serif;
+    font-size: 12px;
+    color: #4C4C4C;
+    background-color: #F4F2ED;
+    padding: 1em;
+  }
+  
+  a:link {
+    color: #191919;
+  }
+  
+  a:visited {
+    color: #191919;
+  }
+
+  pre, code {
+    color: #000000;
+    font-family: "Bitstream Vera Sans Mono","Monaco","Courier New",monospace;
+    font-size: 95%;
+    line-height: 1.3em;
+    margin-top: 0;
+    margin-bottom: 0;
+    padding: 0;
+    word-wrap: break-word;
+  }
+
+  h1, h2, h3, h4, h5, h6 {
+    margin: 0em 0em 1em 0em;
+    color: #666666;
+  }
+  
+  h1 { 
+    display: block;
+    font-size: 2em;
+    letter-spacing: -1px;
+  }
+  
+  h2 {
+    margin-top: -1em;	
+  }
+  
+  fieldset {
+    display: inline;
+    border: 0px;
+    padding: 0px;
+    margin-right: 1em;
+  }
+  
+  div.filters {
+    margin-bottom: 1em;	
+  }
+  
+  .hidden {
+    display: none;
+  }
+  
+/* @end */
+
+/* @group Cross-References */
+
+  span.cross-ref-title {
+    font-size: 140%;
+  }
+  
+  span.cross-ref a {
+    text-decoration: none;
+  }
+  
+  span.cross-ref {
+    background-color:#f3f7fa;
+    border: 1px dashed #333;
+    margin: 1em;
+    padding: 0.5em;
+    overflow: hidden;
+  }
+  
+  a.crossref-toggle {
+    text-decoration: none;
+  }
+
+/* @end */
+
+/* @group Report Table */
+
+  div.report_table_wrapper {
+    min-width: 900px;
+  }
+
+  table.report {
+    border-collapse: collapse;
+    border: 1px solid #666666;
+    width: 100%;
+    margin-bottom: 1em;
+  }
+  
+  table.report tr {
+    line-height: 1.75em;
+  }
+  
+  table.report th {
+    background: #666666;
+    color: #ffffff;
+    text-align: right;
+    text-transform: uppercase;
+    font-size: .8em;
+    font-weight: bold;
+    padding: 0em .5em;
+    border: 1px solid #666666;
+  }
+
+  table.report tfoot tr {
+    background: #dddddd;
+    font-weight: bold;
+    padding: .5em;
+    border: 1px solid #666666;
+  }
+  
+  th.left_align, td.left_align {
+    text-align: left !important;
+  }
+  
+  th.right_align, td.right_align {
+    text-align: right;
+    padding-right: 2em !important;
+  }
+  
+  table.report th.header:hover {
+    cursor:	pointer;
+    text-decoration: underline; 
+  }
+
+  table.report th.headerSortUp:after{
+    content: "\25BC";
+    margin-left: 1em;
+  }
+
+  table.report th.headerSortDown:after {
+    content: "\25B2";
+    margin-left: 1em;
+  }
+
+  table.report tr.summary_row {
+    background: #cccccc;
+    border: 1px solid #cccccc;
+  }
+
+  table.report tr.summary_row td {
+    padding-left: .2em !important;
+    color: #333333;
+    font-weight: bold;
+  }
+  
+  table.report td {
+    padding: .2em .5em .2em .5em;
+  }
+
+  table.report td a {
+    text-decoration: none;
+  }
+  
+  table.report tbody tr:hover {
+    background: #cccccc !important;
+  }
+  
+  table.report tr.summary_row td {
+    border-bottom: 1px solid #aaaaaa;
+  }
+
+  table.report tr {
+    background-color: #eeeeee;
+  }
+
+  table.report tr.odd {
+    background-color: #dddddd;
+  }
+
+/* @end */
+
+/* @group Percentage Graphs */
+
+  div.percent_graph_legend {
+    width: 5.5em;
+    float: left;
+    margin: .5em 1em .5em 0em;
+    height: 1em;
+    line-height: 1em;
+  }
+  
+  div.percent_graph {
+    height: 1em;
+    border: #333333 1px solid;
+    empty-cells: show;
+    padding: 0px;
+    border-collapse: collapse;
+    width: 100px !important;
+    float: left;
+    margin: .5em 1em .5em 0em;
+  }
+
+  div.percent_graph div {
+  	float: left;
+    height: 1em;
+    padding: 0px !important;
+  }  
+
+  div.percent_graph div.covered {
+    background: #649632;
+  }
+  
+  div.percent_graph div.uncovered {
+    background: #a92730;
+  }
+  
+  div.percent_graph div.NA {
+    background: #eaeaea;
+  }
+  
+/* @end */
+
+/* @group Details page */
+
+  table.details {
+    margin-top: 1em;
+    border-collapse: collapse;
+    width: 100%;
+    border: 1px solid #666666;
+  }
+  
+  table.details tr {
+  	line-height: 1.75em;
+	}
+
+  table.details td {
+  	padding: .25em;
+	}
+
+  span.inferred, span.inferred1, span.marked, span.marked1, span.uncovered, span.uncovered1 {
+    display: block;
+    padding: .25em;
+  }
+  
+  tr.inferred td, span.inferred {
+    background-color: #e0dedb;
+  }
+  
+  tr.inferred1 td, span.inferred1 {
+    background-color: #e0dedb;
+  }
+  
+  tr.marked td, span.marked, span.marked1 {
+    background-color: #bed2be;
+  }
+  
+  tr.uncovered td, span.uncovered {
+    background-color: #ce8b8c;
+  }
+  
+  tr.uncovered1 td, span.uncovered1 {
+    background-color: #ce8b8c;
+  }
+
+  div.key {
+    border: 1px solid #666666;
+    margin: 1em 0em;
+  }
+
+/* @end */

data/lib/valise/errors.rb

@@ -0,0 +1,30 @@
+module Valise
+  class Error < ::Exception; end
+
+  class PathOutsideOfRoot < Error; end
+  class PathNotInRoot < Error; end
+  class PathNotFound < Error; end
+  class ReadOnly < Error; end
+  class VirtualSearchPath < Error; end
+  class MalformedTree < Error; end
+  class RootNotInSet < Error; end
+
+  class WouldClobber < Error
+    def initialize(item)
+      @item = item
+      super("Would clobber #{item.segments.inspect}")
+    end
+
+    attr_reader :item
+  end
+
+  class CantPopulate < Error
+    def initialize(item, cause)
+      @item = item
+      @original_exception = cause
+      super("Couldn't populate #{item.segments.inspect}: #{cause.class}: #{cause.message}")
+    end
+
+    attr_reader :item, :original_exception
+  end
+end

data/lib/valise/item.rb

@@ -0,0 +1,105 @@
+require 'valise/utils'
+
+module Valise
+  class Serialization
+    @@classes = {}
+
+    class << self
+      def [](index)
+        @@classes[index]
+      end
+
+      def register(index)
+        @@classes[index] = self
+      end
+    end
+
+    class Raw < Serialization
+      register :raw
+
+      def self.dump(value)
+        value
+      end
+
+      def self.load(raw)
+        raw
+      end
+    end
+
+    class YAML < Serialization
+      register :yaml
+
+      def self.dump(value)
+        ::YAML::dump(value)
+      end
+
+      def self.load(raw)
+        ::YAML::load(raw)
+      end
+    end
+  end
+
+  class Item
+    include Unpath
+
+    def initialize(stack, root, dump_load)
+      @stack = stack
+      @root = root
+      @dump_load = dump_load || Serialization::Raw
+      @contents = nil
+    end
+
+    attr_reader :stack, :root
+    attr_accessor :contents
+
+    def inspect
+      "#{@root.inspect}//#{@stack.inspect}"
+    end
+
+    def segments
+      @stack.segments
+    end
+
+    def full_path
+      @root.full_path(segments)
+    end
+
+    def writable?
+      @root.writable?(segments)
+    end
+
+    def present?
+      @root.present?(segments)
+    end
+
+    def raw_file
+      File::open(full_path)
+    end
+
+    def open(&block)
+      File::open(full_path, "r", &block)
+    end
+
+    def save
+      root.write(self)
+    end
+
+    def contents
+      return @stack.merged(self)
+    end
+
+    def contents=(value)
+      @contents = @stack.diffed(self, value)
+      save
+      @contents
+    end
+
+    def dump_contents
+      @dump_load.dump(load_contents) #@contents?
+    end
+
+    def load_contents
+      @contents ||= @dump_load.load(@root.get_from(self))
+    end
+  end
+end

data/lib/valise/path-matcher.rb

@@ -0,0 +1,113 @@
+require 'valise/utils'
+
+module Valise
+  class PathMatcher
+    include Unpath
+
+    def initialize(segment = nil)
+      @children = []
+      @segment = segment
+      @value = nil
+    end
+
+    attr_reader :segment
+
+    def each_pair(prefix = [])
+      segments = prefix.dup
+      segments << @segment if @segment
+      @children.each do |child|
+        child.each_pair(segments) do |segments, value|
+          yield(segments, value)
+        end
+      end
+      yield(segments, @value) if @value
+    end
+
+    def merge!(other)
+      other.each_pair do |path, value|
+        self[path] = value
+      end
+    end
+
+    def [](path)
+      retreive(unpath(path))
+    end
+
+    def retreive(segments)
+      if segments.empty?
+        return @value
+      else
+        @children.each do |child|
+          val = child.access(segments)
+          return val unless val.nil?
+        end
+      end
+      return nil
+    end
+
+    def access(segments)
+      return retreive(segments.drop(1)) if match?(segments.first)
+      return nil
+    end
+
+    def match?(segment)
+      @segment == segment
+    end
+
+    def []=(pattern, result)
+      store(unpath(pattern), result)
+    end
+
+    def store(segments, result)
+      if segments.empty?
+        @value = result
+      else
+        index = segments.shift
+        target = @children.find {|child| child.segment == index } ||
+          case index
+          when "**"; DirGlob.new.tap{|m| @children << m}
+          when /^[*].*/; FileGlob.new(index).tap{|m| @children << m}
+          else; PathMatcher.new(index).tap{|m| @children << m}
+          end
+        target.store(segments, result)
+      end
+    end
+  end
+
+  class DirGlob < PathMatcher
+    def initialize
+      super('**')
+    end
+
+    def match?(segment)
+      true
+    end
+
+    def access(segments)
+      if segments.empty?
+        return nil
+      else
+        super || access(segments.drop(1))
+      end
+    end
+  end
+
+  class FileGlob < PathMatcher
+    def initialize(segment)
+      super
+      @regex = %r{.*#{segment.sub(/^[*]/,"")}$}
+    end
+
+    def match?(segment)
+      @regex =~ segment
+    end
+
+    def store(segments, result)
+      if segments.empty?
+        @value = result
+      else
+        raise "File globs can only be used as suffixes"
+      end
+    end
+  end
+end