valise 0.3

data/spec/dump_load.rb

@@ -0,0 +1,32 @@
+require 'valise'
+require 'file-sandbox'
+
+describe Valise do
+  include FileSandbox
+
+  let :valise do
+    sandbox.new :directory => "base/test"
+    Valise::Set.define do
+      handle "test/yaml-file", :yaml
+      rw "base"
+    end
+  end
+
+  let :item do
+    valise.get("test/yaml-file").first
+  end
+
+  it "should store data as YAML" do
+    item.contents = { :a => "test hash" }
+    item.save
+    YAML::load( File::read(item.full_path)).should == { :a => "test hash" }
+  end
+
+  it "should load data from YAML" do
+    File::open(item.full_path, "w") do |file|
+      file.write(YAML::dump( :another => "test hash" ))
+    end
+    item.contents.should == {:another => "test hash"}
+  end
+end
+

data/spec/error_handling.rb

@@ -0,0 +1,9 @@
+require 'valise'
+
+describe Valise, "error conditions" do
+  describe "HandlerCollision is raised" do
+    it "when a file handler collides from the same path"
+    it "when a file handler collides with a glob path"
+    it "when two Valises are added with a handler for the same path"
+  end
+end

data/spec/fileset.rb

@@ -0,0 +1,170 @@
+require 'valise'
+require 'file-sandbox'
+
+describe Valise, "error cases" do
+end
+
+describe Valise do
+  include FileSandbox
+
+  before do
+    sandbox.new :directory => "etc/conductor"
+    sandbox.new :directory => "home/.conductor"
+    sandbox.new :directory => ".conductor"
+    sandbox.new :directory => "spec"
+    sandbox.new :file => "home/.conductor/existed", :with_contents => "TEST"
+    @valise = Valise::Set.define do
+      rw ".conductor"
+      rw "home/.conductor"
+      rw "etc/conductor"
+      defaults do
+        file :text, align(<<-EOT)
+        <<<
+        Some text
+        EOT
+
+        dir "nest" do
+          file "egg", "yolk"
+        end
+      end
+    end
+  end
+
+  it "should be a Valise::Set" do
+    @valise.should be_an_instance_of(Valise::Set)
+  end
+
+  describe "retrieving files" do
+    it "should get default text files" do
+      @valise.find("text").contents.should == "Some text"
+      @valise.find(:text).contents.should == "Some text"
+    end
+
+    it "should get text files from library files" do
+      @valise.find("existed").contents.should == "TEST"
+    end
+
+    it "should get default nested files" do
+      @valise.find(%w{nest egg}).contents.should == "yolk"
+    end
+
+    it "should get text files from filesystem" do
+      sandbox.new :file => "home/.conductor/text", :with_contents => "Other text"
+      @valise.find(:text).contents.should == "Other text"
+      @valise.find("text").contents.should == "Other text"
+    end
+
+#    it "should get yaml files named with strings" do
+#      @valise.find(:yaml).contents.should == {:one => 1}
+#      @valise.find("yaml").contents.should == {:one => 1}
+#    end
+
+#    it "should get yaml files from the filesystem" do
+#      sandbox.new :file => "home/.conductor/yaml", :with_contents => "--- \n- Coo\n"
+#      @valise.find(:yaml).contents.should == ["Coo"]
+#      @valise.find("yaml").contents.should == ["Coo"]
+#    end
+
+#    it "should get yaml files named with symbols" do
+#      @valise.find(:other).contents.should == [3,4,5]
+#      @valise.find("other").contents.should == [3,4,5]
+#    end
+  end
+
+  share_examples_for "a populating Valise" do
+    it "should create files on populate" do
+      pending
+
+      @valise.populate
+
+      sandbox["etc/conductor/tool_configs"].should exist
+      sandbox["home/.conductor/tool_configs"].should exist
+      sandbox[".conductor/tool_configs"].should exist
+      sandbox[".conductor/tool_configs/test"].should exist
+      sandbox[".conductor/tool_configs/test"].contents.should == "TEST"
+      sandbox["etc/conductor/tool_configs/test"].should_not exist
+      sandbox["home/.conductor/tool_configs/test"].should_not exist
+    end
+
+    it "should not clobber existing files in populate" do
+      pending
+      sandbox.new :file => ".conductor/tool_configs/test", :with_contents => "not test"
+
+      @valise.populate
+
+      sandbox["etc/conductor/tool_configs"].should exist
+      sandbox["home/.conductor/tool_configs"].should exist
+      sandbox[".conductor/tool_configs"].should exist
+      sandbox[".conductor/tool_configs/test"].should exist
+      sandbox[".conductor/tool_configs/test"].contents.should == "not test"
+      sandbox["etc/conductor/tool_configs/test"].should_not exist
+      sandbox["home/.conductor/tool_configs/test"].should_not exist
+
+    end
+
+    it "should allow empty directory definition" do
+      pending
+      @valise.populate
+
+      sandbox["etc/conductor/empty"].should exist
+      sandbox[".conductor/empty"].should exist
+      sandbox["home/.conductor/empty"].should exist
+    end
+
+    it "should get files once populated" do
+      pending
+      @valise.populate
+
+      file = @valise.get_file(%w{tool_configs test})
+
+      file.contents.should == "TEST"
+      file.contents = "not test"
+      file.store
+
+      file2 = @valise.get_file(%w{tool_configs test})
+      file2.contents.should == "not test"
+    end
+  end
+
+  if false
+    describe "defined with the DSL" do
+      #it_should_behave_like "a populating Valise"
+
+      before do
+        @valise.define do
+          dir "tool_configs" do
+            file "test", "TEST"
+          end
+          dir "empty"
+        end
+      end
+    end
+
+    describe "defined programmatically" do
+      it_should_behave_like "a populating Valise"
+
+      before do
+        @valise.add_file(%w{tool_configs test}, "TEST")
+        @valise.add_dir(%w{empty})
+      end
+    end
+  end
+end
+
+describe Valise, " - the unpath method: " do
+  before do
+    @search_root = Valise::SearchRoot.new("")
+  end
+
+  it 'state => ["state"]' do
+    @search_root.unpath("state").should == %w{state}
+  end
+
+  it 'a File => #path' do
+    @file = File.new(__FILE__)
+    @path = __FILE__.split("/")
+    @search_root.unpath(@file)
+  end
+end
+
+

data/spec/glob_handling.rb

@@ -0,0 +1,28 @@
+require 'valise'
+require 'file-sandbox'
+
+describe Valise, "glob handling" do
+  include FileSandbox
+
+  let :valise do
+    sandbox.new :directory => "base/test"
+    Valise::Set.define do
+      handle "test/full", :yaml
+      handle "**/*.file", :yaml
+      handle "path/*.path", :yaml
+      rw "base"
+    end
+  end
+
+  it "should recognize based on a full path" do
+    valise.serialization("test/full").should == Valise::Serialization::YAML
+  end
+
+  it "should recognize base on a file glob" do
+    valise.serialization("test/by.file").should == Valise::Serialization::YAML
+  end
+
+  it "should recognize based on a path glob" do
+    valise.serialization("path/by.path").should == Valise::Serialization::YAML
+  end
+end

data/spec/item.rb

@@ -0,0 +1,35 @@
+require 'valise'
+require 'file-sandbox'
+
+describe "Invidual items in the set" do
+  include FileSandbox
+  let (:root_path) do
+    sandbox.new :directory => "root"
+    sandbox.new :file => "root/item", :with_contents => "testing"
+    "root"
+  end
+  let (:set) do
+    path = root_path
+    Valise::Set.define do
+      rw path
+    end
+  end
+
+  subject { set.find("item") }
+
+  its (:full_path) { should == "root/item" }
+
+  describe "#contents=" do
+    its (:contents) { should == "testing" }
+
+    it "raw_file" do
+      subject.raw_file.path.should == "root/item"
+    end
+
+    it "should make contents available" do
+      subject.open do |file|
+        file.read.should == "testing"
+      end
+    end
+  end
+end

data/spec/merge_diff.rb

@@ -0,0 +1,93 @@
+require 'valise'
+require 'file-sandbox'
+
+describe Valise do
+  include FileSandbox
+
+  let :bottom_hash do
+    {}
+  end
+
+  let :middle_hash do
+    {}
+  end
+
+  let :top_hash do
+    {}
+  end
+
+
+  let :valise do
+    sandbox.new :directory => "base/test"
+    sandbox.new :directory => "layer2/test"
+    sandbox.new :directory => "layer3/test"
+    sandbox.new :file => "base/test/file", :with_contents => YAML::dump(bottom_hash)
+    sandbox.new :file => "layer2/test/file", :with_contents => YAML::dump(middle_hash)
+    sandbox.new :file => "layer3/test/file", :with_contents => YAML::dump(top_hash)
+
+    Valise::Set.define do
+      handle "test/file", :yaml, :hash_merge
+      rw "layer3"
+      rw "layer2"
+      rw "base"
+    end
+  end
+
+  let :item do
+    valise.get("test/file").first
+  end
+
+  describe "merge" do
+    it "should merge values from the bottom" do
+      bottom_hash[:a] = 3
+      item.contents.should == {:a => 3}
+    end
+
+    it "should obscure values from lower down" do
+      bottom_hash[:a] = 3
+      middle_hash[:a] = 1
+      item.contents.should == {:a => 1}
+    end
+
+    it "should prefer topmost value" do
+      bottom_hash[:a] = 3
+      middle_hash[:a] = 2
+      top_hash[:a] = 1
+
+      item.contents.should == {:a => 1}
+      item.stack.map{|stack| stack.contents[:a]}.should == [1,2,3]
+    end
+
+    it "should prefer top nil to bottom value" do
+      bottom_hash[:a] = 3
+      top_hash[:a] = nil
+      item.contents[:a].should == nil
+    end
+
+    it "should do a deep merge" do
+      bottom_hash[:a] = {:a => {:a => 3}}
+      middle_hash[:a] = {:a => {:a => 2}}
+      top_hash[:a] = {:a => {:a => 1}}
+
+      item.stack.map{|stack| stack.contents[:a][:a][:a]}.should == [1,2,3]
+    end
+  end
+
+  describe "diff" do
+    before :each do
+      bottom_hash.merge!(:a => 1, :b => 2, :c => "bad")
+      top_hash.merge!(:a => 2, :b => 7)
+      item.contents = {:a => 1, :b => 3}
+    end
+
+    it "should reduce actual contents of an item to minimal" do
+      item.contents[:a].should == 1
+      item.load_contents[:a].should be_nil
+    end
+
+    it "should mask missing keys" do
+      item.contents[:c].should be_nil
+    end
+  end
+end
+

data/spec/population.rb

@@ -0,0 +1,51 @@
+require 'valise'
+require 'file-sandbox'
+
+describe Valise do
+  include FileSandbox
+
+  before do
+    sandbox.new :directory => "etc/conductor"
+    sandbox.new :directory => "home/.conductor"
+    sandbox.new :directory => ".conductor"
+    sandbox.new :directory => "spec"
+    sandbox.new :file => "home/.conductor/existed", :with_contents => "TEST"
+
+    @from = Valise::Set.define do
+      ro "home/.conductor"
+
+      defaults do
+        file :egg, "yolk"
+      end
+    end
+
+    @to = Valise::Set.define do
+      rw ".conductor"
+      rw "etc/conductor"
+    end
+  end
+
+  describe "population" do
+    before do
+      @from.populate(@to)
+    end
+
+    it "should populate successfully" do
+      @to.find("egg").contents.should == "yolk"
+      @to.find("existed").contents.should == "TEST"
+    end
+  end
+
+  describe "reverse population" do
+    before do
+      @from.populate(@to) do |stack|
+        stack.reverse
+      end
+    end
+
+    it "should populate successfully" do
+      @to.find("egg").contents.should == "yolk"
+      @to.find("existed").contents.should == "TEST"
+    end
+  end
+end

data/spec/search_root.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'file-sandbox'
+require 'valise/search-root'
+
+describe Valise::SearchRoot do
+  include FileSandbox
+
+  before do
+    sandbox.new :directory => "test"
+    sandbox.new :file => "test/file", :with_contents => "TEST"
+  end
+
+  let :search_root do
+    Valise::SearchRoot.new("test")
+  end
+
+  it "should find a file in the root" do
+    search_root.present?(%w{file}).should be_true
+  end
+
+  it "should raise PathNotInRoot if path isn't in root" do
+    search_root.present?(%w{nothere}).should be_false
+  end
+end

data/spec/stemming.rb

@@ -0,0 +1,33 @@
+require 'valise'
+require 'file-sandbox'
+
+describe Valise, "with stemming" do
+  include FileSandbox
+
+  before do
+    sandbox.new :directory => "conductor"
+    sandbox.new :directory => "other_dir"
+    sandbox.new :file => "conductor/top", :with_contents => "conductor/exists"
+    sandbox.new :file => "other_dir/middle", :with_contents => "other_dir/exists"
+
+    @valise = Valise::Set.define do
+      stemmed("stem").rw("conductor")
+      stemmed("stem") do
+        rw "other_dir"
+      end
+      rw "conductor"
+    end
+  end
+
+  it "should find a file in a stemed dir" do
+    @valise.find("stem/top").contents.should == "conductor/exists"
+  end
+
+  it "should find a file in a stemed dir defined in a block" do
+    @valise.find("stem/middle").contents.should == "other_dir/exists"
+  end
+
+  it "should find a file in a normal dir behind stemming" do
+    @valise.find("top").contents.should == "conductor/exists"
+  end
+end

data/spec_help/file-sandbox.rb

@@ -0,0 +1,164 @@
+#require 'ftools'
+require 'fileutils'
+
+module FileSandbox
+  def self.included(spec)
+    return unless spec.respond_to? :before
+
+    spec.before do
+      setup_sandbox
+    end
+
+    spec.after do
+      teardown_sandbox
+    end
+  end
+
+  class HaveContents
+    def initialize(contents)
+      @contents = contents
+    end
+
+    def matches?(target)
+      case @contents
+      when Regexp
+	@contents =~ target.contents
+      when String
+	@contents == target.contents
+      end
+    end
+  end
+
+  def have_contents(expected)
+    HaveContents.new(expected)
+  end
+
+  attr_reader :sandbox
+
+  def in_sandbox(&block)
+    raise "I expected to create a sandbox as you passed in a block to me" if !block_given?
+
+    setup_sandbox
+    original_error = nil
+
+    begin
+      yield @sandbox
+    rescue => e
+      original_error = e
+      raise
+    ensure
+      begin
+        teardown_sandbox
+      rescue
+        if original_error
+          STDERR.puts "ALERT: a test raised an error and failed to release some lock(s) in the sandbox directory"
+          raise(original_error)
+        else
+          raise
+        end
+      end
+    end
+  end
+
+  def setup_sandbox(path = '__sandbox')
+    unless @sandbox
+      @sandbox = Sandbox.new(path)
+      @__old_path_for_sandbox = Dir.pwd
+      Dir.chdir(@sandbox.root)
+    end
+  end
+
+  def teardown_sandbox
+    if @sandbox
+      Dir.chdir(@__old_path_for_sandbox)
+      @sandbox.clean_up
+      @sandbox = nil
+    end
+  end
+
+  class Sandbox
+    attr_reader :root
+
+    def initialize(path = '__sandbox')
+      @root = File.expand_path(path)
+      clean_up
+      FileUtils.mkdir_p @root
+    end
+
+    def [](name)
+      SandboxFile.new(File.join(@root, name), name)
+    end
+
+    # usage new :file=>'my file.rb', :with_contents=>'some stuff'
+    def new(options)
+      if options.has_key? :directory
+        dir = self[options.delete(:directory)]
+        FileUtils.mkdir_p dir.path
+      else
+        file = self[options.delete(:file)]
+        if (binary_content = options.delete(:with_binary_content) || options.delete(:with_binary_contents))
+          file.binary_content = binary_content
+        else
+          file.content = (options.delete(:with_content) || options.delete(:with_contents) || '')
+        end
+      end
+
+      raise "unexpected keys '#{options.keys.join(', ')}'" unless options.empty?
+
+      dir || file
+    end
+
+    def remove(options)
+      name = File.join(@root, options[:file])
+      FileUtils.remove_file name
+    end
+
+    def clean_up
+      FileUtils.rm_rf @root
+      if File.exists? @root
+        raise "Could not remove directory #{@root.inspect}, something is probably still holding a lock on it"
+      end
+    end
+  end
+
+
+  class SandboxFile
+    attr_reader :path
+
+    def initialize(path, sandbox_path)
+      @path = path
+      @sandbox_path = sandbox_path
+    end
+
+    def inspect
+      "SandboxFile: #@sandbox_path"
+    end
+
+    def exist?
+      File.exist? path
+    end
+
+    def content
+      File.read path
+    end
+
+    def content=(content)
+      FileUtils.mkdir_p File.dirname(@path)
+      File.open(@path, "w") {|f| f << content}
+    end
+
+    def binary_content=(content)
+      FileUtils.mkdir_p File.dirname(@path)
+      File.open(@path, "wb") {|f| f << content}
+    end
+
+    def create
+      self.content = ''
+    end
+
+    alias exists? exist?
+    alias contents content
+    alias contents= content=
+    alias binary_contents= binary_content=
+  end
+end

data/spec_help/gem_test_suite.rb

@@ -0,0 +1,17 @@
+puts Dir::pwd
+require 'test/unit'
+begin
+  require 'spec'
+rescue LoadError
+  false
+end
+
+class RSpecTest < Test::Unit::TestCase
+  def test_that_rspec_is_available
+    assert_nothing_raised("\n\n *  RSpec isn't available - please run: gem install rspec  *\n\n"){ ::Spec }
+  end
+
+  def test_that_specs_pass
+    assert(system(*%w{spec -f e -p **/*.rb spec}),"\n\n *  Specs failed  *\n\n")
+  end
+end

data/spec_help/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rspec'
+
+#Ungemmer::ungem_gemspec

data/spec_help/ungemmer.rb

@@ -0,0 +1,37 @@
+class Ungemmer
+  def self.ungem(*names)
+    return
+    deps = names.map do |name|
+      Gem::Dependency.new(name, nil)
+    end
+
+    deps.each do |dep|
+      Gem.source_index.search(dep).each do |gemspec|
+	puts " ** Ungemming #{gemspec.full_name}  **"
+	Gem.source_index.remove_spec(gemspec.full_name)
+      end
+    end
+
+    Gem.instance_eval do
+      if defined? Gem::MUTEX
+      Gem::MUTEX.synchronize do
+          @searcher = nil
+        end
+      else
+	@searcher = nil
+      end
+    end
+  end
+
+  def self.ungem_gemspec
+    Dir[File::expand_path(__FILE__ + "../../../*.gemspec")].each do |gemspec_path|
+      puts "Ungemming based on #{gemspec_path}"
+      begin
+        spec = Gem::Specification::load(gemspec_path)
+        Ungemmer::ungem(spec)
+      rescue LoadError
+        puts "Couldn't load #{gemspec_path}"
+      end
+    end
+  end
+end