valise 0.3

data/lib/valise/search-root.rb

@@ -0,0 +1,166 @@
+require 'valise/errors'
+require 'valise/utils'
+require 'valise/item'
+require 'fileutils'
+#require 'enum'
+
+module Valise
+  class SearchRoot
+    include Unpath
+    include Enumerable
+
+    def initialize(path)
+      @segments = unpath(path)
+    end
+
+    attr_reader :segments
+
+    def each
+      paths = [[]]
+      until paths.empty?
+        rel = paths.shift
+        path = repath(@segments + rel)
+        #symlinks?
+        if(File::directory?(path))
+          Dir.entries(path).each do |entry|
+            next if entry == "."
+            next if entry == ".."
+            paths.push(rel + [entry])
+          end
+        elsif(File::file?(path))
+          yield(unpath(rel))
+        end
+      end
+    end
+
+    def inspect
+      "#{self.class.name.split(":").last}:#{[*@segments].join("/")}"
+    end
+
+    def full_path(segments)
+      repath(@segments + segments)
+    end
+
+    def write(item)
+      return if item.contents.nil?
+      FileUtils::mkdir_p(::File::dirname(item.full_path))
+      File::open(item.full_path, "w") do |file|
+        file.write(item.dump_contents)
+      end
+      item
+    end
+
+    def writable?(segments)
+      path = full_path(segments)
+      return (!File::exists?(path) or File::writable?(path))
+    end
+
+    def present?(segments)
+      return File::exists?(full_path(segments))
+    end
+
+    def insert(item)
+      if(File::exists?(item.full_path))
+        raise WouldClobber.new(Item.new(item.stack.segments, self, nil))
+      else
+        write(item)
+        return item
+      end
+    end
+
+    def get_from(item)
+      File::read(item.full_path)
+    end
+  end
+
+  class ReadOnlySearchRoot < SearchRoot
+    def writable?(segments)
+      false
+    end
+
+    def write(item)
+      raise ReadOnly
+    end
+
+    def insert(item)
+      raise ReadOnly
+    end
+  end
+
+  class DefinedDefaults < ReadOnlySearchRoot
+    def initialize
+      @files = {}
+    end
+
+    def segments
+      raise VirtualSearchPath, "does not have a real path"
+    end
+
+    def present?(segments)
+      @files.has_key?(segments)
+    end
+
+    def each
+      @files.each_key do |path|
+        yield(unpath(path))
+      end
+    end
+
+    def get_from(item)
+      return @files[item.segments]
+    end
+
+    def define(&block)
+      unless block.nil?
+        definer = DefinitionHelper.new(self)
+        definer.instance_eval &block
+      end
+      return self
+    end
+
+    def self.define(&block)
+      return self.new.define(&block)
+    end
+
+    def add_item(path, contents)
+      check_path = path[0..-2]
+      until check_path.empty?
+        if @files.has_key?(check_path)
+          raise MalformedTree, "Tried to add items below #{path[0..-2]} which is not a directory"
+        end
+        check_path.pop
+      end
+      @files[path] = contents
+    end
+
+    def add_dir(path)
+      #add_item(path, ValiseWorks::Directory.new(path))
+    end
+
+    def add_file(path, data = nil)
+      add_item(path, data)
+    end
+
+    class DefinitionHelper
+      def initialize(target)
+        @target = target
+        @prefix = []
+      end
+
+      def dir(name)
+        path = @prefix + [name]
+        @target.add_dir(path)
+        @prefix.push(name)
+        yield if block_given?
+        @prefix.pop
+      end
+
+      def file(name, data=nil)
+        path = @prefix + [name.to_s]
+        @target.add_file(path, data)
+      end
+
+      include StringTools
+    end
+  end
+end

data/lib/valise/stack.rb

@@ -0,0 +1,169 @@
+# New plan here: Stack is returned by "find" and responds to many of the
+# methods that Item current responds to.  It caches results, essentially, of
+# the find search - maybe at creation, with possiblity for reload/update.
+# Also, makes possible use cases like file promotion, merging, etc.
+#
+# Still need to resolve the interface for parsing and merging files.
+#
+# * something from the Valise definition - would have to be part of defaults,
+# which further is a problem if a file doesn't exist in the defaults
+#
+# * a filetype mapping
+#
+# * Is it a find-time user thing
+
+
+module Valise
+  module ItemEnum
+    include Enumerable
+
+    class Enumerator
+      include ItemEnum
+
+      def initialize(list, &filter)
+        @list = list
+        @filter = proc(&filter)
+      end
+
+      def each
+        @list.each do |item|
+          next unless @filter[item]
+          yield(item)
+        end
+      end
+    end
+
+    def writable
+      Enumerator.new(self) do |item|
+        item.writable?
+      end
+    end
+
+    def absent
+      Enumerator.new(self) do |item|
+        not item.present?
+      end
+    end
+
+    def present
+      Enumerator.new(self) do |item|
+        item.present?
+      end
+    end
+  end
+
+  class MergeDiff
+    @@classes = {}
+    def self.[](index)
+      @@classes[index]
+    end
+
+    def self.register(index)
+      @@classes[index] = self
+    end
+
+    def initialize(stack)
+      @stack = stack
+    end
+
+    class TopMost < MergeDiff
+      register :topmost
+
+      def merge(item)
+        item.load_contents
+      end
+
+      def diff(item, value)
+        value
+      end
+    end
+
+    class HashMerge < MergeDiff
+      register :hash_merge
+
+      def merge(item)
+        merge_stack(@stack.not_above(item).reverse)
+      end
+
+      def merge_stack(stack)
+        stack.inject({}) do |hash, item|
+          deep_merge(hash, item.load_contents)
+        end
+      end
+
+      def deep_merge(collect, item)
+        item.each_pair do |key, value|
+          case value
+          when Hash
+            collect[key] ||= {}
+            deep_merge(collect[key], value)
+          else
+            collect[key] = value
+          end
+        end
+        collect
+      end
+
+      def diff(item, new_contents)
+        diff_with = merge_stack(@stack.below(item).reverse)
+        result = new_contents.dup
+
+        diff_with.each_pair do |key, value|
+          if result.has_key?(key)
+            if result[key] == value
+              result.delete(key)
+            end
+          else
+            result[key] = nil
+          end
+        end
+
+        result
+      end
+    end
+  end
+
+  class Stack
+    include Unpath
+    include ItemEnum
+
+    def inspect
+      "<default>:#{@segments.join "/"} #{@valise.inspect}"
+    end
+
+    def initialize(path, set, merge_class, dump_load)
+      @segments = unpath(path)
+      @valise = set
+      @merge_diff = (merge_class || MergeDiff::TopMost).new(self)
+      @dump_load = dump_load
+    end
+
+    attr_reader :segments
+
+    def merged(item)
+      @merge_diff.merge(item)
+    end
+
+    def diffed(item, value)
+      @merge_diff.diff(item, value)
+    end
+
+    def not_above(item)
+      Stack.new(@segments, @valise.not_above(item.root), @merge_diff.class, @dump_load)
+    end
+
+    def below(item)
+      Stack.new(@segments, @valise.below(item.root), @merge_diff.class, @dump_load)
+    end
+
+    def each
+      @valise.each do |root|
+        yield(Item.new(self, root, @dump_load))
+      end
+    end
+
+    def reverse
+      Stack.new(@segments, @valise.reverse, @merge_diff.class, @dump_load)
+    end
+  end
+end

data/lib/valise/stem-decorator.rb

@@ -0,0 +1,56 @@
+module Valise
+  class StemDecorator < SearchRoot
+    def initialize(stem, search_root)
+      @stem, @search_root = stem, search_root
+    end
+
+    def under_stem(path)
+      segments = unpath(path)
+      top_part = segments[0...@stem.length]
+      if top_part == @stem
+        return segments[@stem.length..-1]
+      else
+        raise PathOutsideOfRoot
+      end
+    end
+
+    def inspect
+      "#{self.class.name.split(":").last}:[#{@stem.join("/")}]#{@search_root.inspect}"
+    end
+
+    def each
+      @search_root.each do |path|
+        yield(@stem + path)
+      end
+    end
+
+    def full_path(segments)
+      segments = under_stem(segments)
+      @search_root.full_path(segments)
+    end
+
+    def write(item)
+      @search_root.write(item)
+    end
+
+    def writable?(segments)
+      @search_root.writable?(under_stem(segments))
+    rescue PathOutsideOfRoot
+      return false
+    end
+
+    def present?(segments)
+      @search_root.present?(under_stem(segments))
+    rescue PathOutsideOfRoot
+      return false
+    end
+
+    def insert(item)
+      @search_root.insert(item)
+    end
+
+    def get_from(item)
+      @search_root.get_from(item)
+    end
+  end
+end

data/lib/valise/utils.rb

@@ -0,0 +1,65 @@
+module Valise
+  module StringTools
+    def align(string)
+      lines = string.split(/\n/)
+      first = lines.shift
+      match = /^(\s*)<<</.match(first)
+      unless(match.nil?)
+        catch(:haircut) do
+          return lines.map do |line|
+            raise line if /^#{match[1]}|^\s*$/ !~ line
+            throw :haircut if /^#{match[1]}|^\s*$/ !~ line
+            line.sub(/^#{match[1]}/, "")
+          end.join("\n")
+        end
+      end
+      return string
+    end
+    module_function :align
+  end
+
+  module Unpath
+    def unpath(parts)
+      if Array === parts and parts.length == 1
+        parts = parts[0]
+      end
+
+      case parts
+      when Array
+        if (parts.find{|part| not (String === part or Symbol === part)}.nil?)
+          parts = parts.map{|part| part.to_s}
+        else
+          raise "path must be composed of strings or symbols"
+        end
+      when String
+        parts = parts.split(::File::Separator)
+      when Symbol
+        parts = [parts.to_s]
+      when ::File
+        parts = parts.path
+        parts = parts.split(::File::Separator)
+      else
+        raise "path must be String, Array of Strings or File"
+      end
+
+      parts = parts.map do |part|
+        if /^~/ =~ part
+          ::File::expand_path(part).split(::File::Separator)
+        else
+          part
+        end
+      end.flatten
+
+      return parts
+    end
+
+    def repath(segments)
+      case segments
+      when Array
+        return segments.join(::File::Separator)
+      when String
+        return segments
+      end
+    end
+  end
+end

data/lib/valise.rb

@@ -0,0 +1,219 @@
+require 'valise/errors'
+require 'valise/search-root'
+require 'valise/utils'
+require 'valise/stack'
+require 'valise/path-matcher'
+require 'valise/stem-decorator'
+
+module Valise
+  module Debugging
+    def remark
+    end
+
+    class << self
+      attr_reader :remark_to
+
+      def enable(destination)
+        @remark_to = destination
+        class_eval do
+          def remark
+            self.class.remark_to.puts(yield)
+          end
+        end
+      end
+    end
+  end
+
+  class Set
+    include Debugging
+    include Enumerable
+
+    class StemmedDefiner
+      include Unpath
+      def initialize(path, set)
+        @segments = unpath(path)
+        @target = set
+      end
+
+      def rw(name)
+        @target.add_search_root(
+          StemDecorator.new(@segments, SearchRoot.new(name)))
+      end
+
+      def ro(name)
+        @target.add_search_root(
+          StemDecorator.new(@segments, ReadOnlySearchRoot.new(name)))
+      end
+    end
+
+    class Definer
+      include Unpath
+      def initialize(set)
+        @target = set
+      end
+
+      def rw(name, path = nil)
+        @target.add_search_root(SearchRoot.new(name))
+      end
+
+      def ro(name, path = nil)
+        @target.add_search_root(ReadOnlySearchRoot.new(name))
+      end
+
+      def stemmed(path, &block)
+        definer = StemmedDefiner.new(path, @target)
+        definer.instance_eval(&block) unless block.nil?
+        return definer
+      end
+
+      def from_here(rel_path)
+        m = /(.*):\d+/.match(caller[0])
+        dir = ::File::dirname(::File::expand_path(m[1]))
+
+        unpath(dir) + unpath(rel_path)
+      end
+
+      def handle(path, serialization, merge_diff = nil)
+        @target.add_handler(unpath(path),
+                            Valise::Serialization[serialization],
+                            Valise::MergeDiff[merge_diff])
+      end
+
+      def defaults(name=nil, &block)
+        loc = DefinedDefaults.define(&block)
+        @target.add_search_root(loc)
+      end
+    end
+
+    def initialize
+      @search_roots = []
+      @merge_diff = PathMatcher.new
+      @serialization = PathMatcher.new
+    end
+
+    def inspect
+      @search_roots.inspect
+    end
+
+    def reverse
+      set = Set.new
+      set.search_roots = @search_roots.reverse
+      set
+    end
+
+    def define(&block)
+      definer = Definer.new(self)
+      definer.instance_eval(&block)
+      return self
+    end
+
+    def self.define(&block)
+      return self.new.define(&block)
+    end
+
+    def prepend_search_root(search_root)
+      @search_roots.unshift(search_root)
+    end
+
+    def add_search_root(search_root)
+      @search_roots << search_root
+    end
+
+    def add_handler(segments, serialization_class, merge_diff_class)
+      @merge_diff[segments] = merge_diff_class unless merge_diff_class.nil?
+      @serialization[segments] = serialization_class unless serialization_class.nil?
+    end
+
+    def +(other)
+      result = self.class.new
+      result.search_roots = @search_roots + other.search_roots
+      result.merge_handlers(*other.handler_lists)
+      result.merge_handlers(*handler_lists)
+      return result
+    end
+
+    attr_accessor :search_roots
+    protected :search_roots, :search_roots=
+
+      include Unpath
+      def get(path)
+        return Stack.new(path, self,
+                         merge_diff(path),
+                         serialization(path))
+      end
+
+      def merge_diff(path)
+        @merge_diff[unpath(path)]
+      end
+
+      def serialization(path)
+        @serialization[unpath(path)]
+      end
+
+      def merge_handlers(merge_diff, serialization)
+        @merge_diff.merge!(merge_diff)
+        @serialization.merge!(serialization)
+      end
+
+      def handler_lists
+        [@merge_diff, @serialization]
+      end
+
+    def find(path)
+      return get(path).present.first
+    end
+
+    def each(&block)
+      @search_roots.each(&block)
+    end
+
+    def files
+      unless block_given?
+        return self.enum_for(:files)
+      end
+
+      visited = {}
+      @search_roots.each do |root|
+        root.each do |segments|
+          unless visited.has_key?(segments)
+            item = find(segments)
+            visited[segments] = item
+            yield(item)
+          end
+        end
+      end
+      return visited
+    end
+
+    def not_above(root)
+      index = @search_roots.index(root)
+      raise RootNotInSet if index.nil?
+      set = self.class.new
+      set.search_roots = @search_roots[index..-1]
+      set
+    end
+
+    def below(root)
+      index = @search_roots.index(root)
+      raise RootNotInSet if index.nil?
+      set = self.class.new
+      set.search_roots = @search_roots[(index+1)..-1]
+      set
+    end
+
+    def [](index)
+      return @search_roots[index]
+    end
+
+    def populate(to = self)
+      files do |item|
+        contents = item.contents
+        to_stack = to.get(item.segments)
+        to_stack = yield(to_stack) if block_given?
+        target = to_stack.writable.first
+        next if target.present?
+        target.contents = contents
+      end
+    end
+  end
+end

data/spec/addable.rb

@@ -0,0 +1,41 @@
+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"
+    one = Valise::Set.define do
+      handle "test", :yaml
+      rw ".conductor"
+    end
+
+    two = Valise::Set.define do
+      handle "test", nil, :hash_merge
+      defaults do
+      end
+    end
+
+    @sum = one + two
+  end
+
+
+  it "should be addable" do
+    @sum.should be_an_instance_of(Valise::Set)
+  end
+
+  it "should add in order" do
+    @sum[0].should be_an_instance_of(Valise::SearchRoot)
+    @sum[1].should be_an_instance_of(Valise::DefinedDefaults)
+  end
+
+  it "should combine file handlers" do
+    @sum.merge_diff("test").should == Valise::MergeDiff::HashMerge
+    @sum.serialization("test").should == Valise::Serialization::YAML
+  end
+end