valise 0.8.2 → 0.9.0

data/lib/valise/set/definer.rb

@@ -42,17 +42,18 @@ module Valise
         return definer
       end
 
-      def from_here(rel_path)
-        m = /(.*):\d+/.match(caller[0])
-        dir = ::File::dirname(::File::expand_path(m[1]))
+      def handle(path, serialization, merge_diff = nil)
+        @target.add_handler(unpath(path),
+                            serialization,
+                            merge_diff)
+      end
 
-        collapse(unpath(dir) + unpath(rel_path))
+      def serialize(path, serialization, options = nil)
+        @target.add_serialization_handler(path, serialization, options)
       end
 
-      def handle(path, serialization, merge_diff = nil)
-        @target.add_handler(unpath(path),
-                            Valise::Serialization[serialization],
-                            Valise::MergeDiff[merge_diff])
+      def merge(path, merge_diff, options = nil)
+        @target.add_merge_diff_handler(path, merge_diff, options)
       end
 
       def defaults(name=nil, &block)

data/lib/valise/set/extensions-decorator.rb

@@ -0,0 +1,35 @@
+require 'valise/set'
+
+module Valise
+  class Set
+    class ExtensionsDecorator < Set
+      def initialize(set)
+        @set = set
+        @extensions = []
+      end
+      attr_accessor :extensions
+      attr_reader :set
+      protected :set
+
+      def inspect
+        super + "x#{extensions.inspect}"
+      end
+
+      def search_roots
+        set.search_roots
+      end
+
+      def merge_diff
+        set.merge_diff
+      end
+
+      def serialization
+        set.serialization
+      end
+
+      def get(path)
+        set.get(path).exts(*extensions)
+      end
+    end
+  end
+end

data/lib/valise/set.rb

@@ -6,11 +6,13 @@ require 'valise/stack'
 require 'valise/path-matcher'
 require 'valise/stem-decorator'
 require 'valise/set/definer'
+require 'valise/set/extensions-decorator'
 
 module Valise
   class Set
     include Debugging
     include Enumerable
+    include Unpath
 
     def initialize
       @search_roots = []
@@ -19,32 +21,67 @@ module Valise
     end
 
     def inspect
-      @search_roots.inspect
+      search_roots.inspect
     end
 
     def to_s
-      @search_roots.map(&:to_s).join(":")
+      search_roots.map(&:to_s).join(":")
+    end
+
+    def exts(*extensions)
+      exts = ExtensionsDecorator.new(self)
+      exts.extensions = extensions
+      return exts
+    end
+
+    def transform
+      set = self.class.new
+      set.search_roots = yield search_roots
+      set.merge_diff = merge_diff.dup
+      set.serialization = serialization.dup
+      return set
     end
 
     def reverse
-      set = Set.new
-      set.search_roots = @search_roots.reverse
-      set.merge_diff = @merge_diff.dup
-      set.serialization = @serialization.dup
-      set
+      transform do |roots|
+        roots.reverse
+      end
     end
 
     def sub_set(path)
       segments = unpath(path)
-      set = Set.new
-      set.search_roots = @search_roots.map do |root|
-        new_root = root.dup
-        new_root.segments += segments
-        new_root
+      transform do |roots|
+        roots.map do |root|
+          new_root = root.dup
+          new_root.segments += segments
+          new_root
+        end
+      end
+    end
+
+    def stemmed(path)
+      segments = unpath(path)
+      transform do |roots|
+        roots.map do |root|
+          StemDecorator.new(segments, root)
+        end
+      end
+    end
+
+    def not_above(root)
+      index = search_roots.index(root)
+      raise Errors::RootNotInSet if index.nil?
+      transform do |roots|
+        roots[index..-1]
+      end
+    end
+
+    def below(root)
+      index = search_roots.index(root)
+      raise Errors::RootNotInSet if index.nil?
+      transform do |roots|
+        roots[(index+1)..-1]
       end
-      set.merge_diff = @merge_diff.dup
-      set.serialization = @serialization.dup
-      set
     end
 
     def define(&block)
@@ -58,21 +95,33 @@ module Valise
     end
 
     def prepend_search_root(search_root)
-      @search_roots.unshift(search_root)
+      search_roots.unshift(search_root)
     end
 
     def add_search_root(search_root)
-      @search_roots << 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?
+      add_serialization_handler(segments, serialization_class)
+      add_merge_handler(segments, merge_diff_class)
+    end
+
+    def add_serialization_handler(pattern, serializer, options = nil)
+      return if serializer.nil?
+      Strategies::Serialization.check!(serializer)
+      serialization[pattern] = [serializer, options]
+    end
+
+    def add_merge_handler(pattern, merger, options = nil)
+      return if merger.nil?
+      Strategies::MergeDiff.check!(merger)
+      merge_diff[pattern] = [merger, options]
     end
 
     def +(other)
       result = self.class.new
-      result.search_roots = @search_roots + other.search_roots
+      result.search_roots = search_roots + other.search_roots
       result.merge_handlers(*other.handler_lists)
       result.merge_handlers(*handler_lists)
       return result
@@ -83,38 +132,36 @@ module Valise
       :merge_diff=, :merge_diff,
       :serialization=, :serialization
 
-    include Unpath
-    def get(path)
-      return Stack.new(path, self,
-                       merge_diff(path),
-                       serialization(path))
+    def merge_diff_for(stack)
+      type, options = *(merge_diff[unpath(stack.segments)] || [])
+      options = (options || {}).merge(:stack => stack)
+      Strategies::MergeDiff.instance(type, options)
     end
 
-    def merge_diff(path)
-      @merge_diff[unpath(path)]
+    def serialization_for(stack)
+      type, options = *serialization[unpath(stack.segments)]
+      Strategies::Serialization.instance(type, options)
     end
 
-    def serialization(path)
-      @serialization[unpath(path)]
+    def merge_handlers(new_merge_diff, new_serialization)
+      merge_diff.merge!(new_merge_diff)
+      serialization.merge!(new_serialization)
     end
 
-    def merge_handlers(merge_diff, serialization)
-      @merge_diff.merge!(merge_diff)
-      @serialization.merge!(serialization)
+    def handler_lists
+      [merge_diff, serialization]
     end
 
-    def handler_lists
-      [@merge_diff, @serialization]
+    def get(path)
+      Stack.new(path, self)
     end
 
     def find(path)
-      item = get(path).present.first
-      return item unless item.nil?
-      raise Errors::NotFound, "#{path} not found in #{@search_roots.inspect}"
+      get(path).find
     end
 
     def each(&block)
-      @search_roots.each(&block)
+      search_roots.each(&block)
     end
 
     def glob(path_matcher)
@@ -125,7 +172,7 @@ module Valise
       visited = {}
       path_matcher = PathMatcher.build(path_matcher)
 
-      @search_roots.each do |root|
+      search_roots.each do |root|
         root.each do |segments|
           next unless path_matcher === segments
           unless visited.has_key?(segments)
@@ -143,28 +190,12 @@ module Valise
       glob(ALL_FILES, &block)
     end
 
-    def not_above(root)
-      index = @search_roots.index(root)
-      raise Errors::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 Errors::RootNotInSet if index.nil?
-      set = self.class.new
-      set.search_roots = @search_roots[(index+1)..-1]
-      set
-    end
-
     def depth_of(root)
-      return @search_roots.index(root)
+      return search_roots.index(root)
     end
 
     def [](index)
-      return @search_roots[index]
+      return search_roots[index]
     end
 
     def populate(to = self)

data/lib/valise/stack/extensions-decorator.rb

@@ -0,0 +1,53 @@
+require 'valise/stack'
+
+module Valise
+  class Stack
+    class ExtensionsDecorator < Stack
+      def initialize(stack)
+        @stack = stack
+        @extensions = []
+        @stacks = Hash.new{|h,segments| h[segments] = @stack.valise.get(segments) }
+      end
+
+      attr_accessor :extensions
+
+      def inspect
+        @stack.inspect + "x#{extensions.inspect}"
+      end
+
+      def valise
+        @stack.valise
+      end
+
+      def reget(root)
+        decorated = self.new(super)
+        decorated.extensions = self.extensions
+        decorated
+      end
+
+      def merged(item)
+        item.stack.merged(item)
+      end
+
+      def diffed(item, value)
+        item.stack.diffed(item, value)
+      end
+
+      def rel_path
+        @stack.rel_path
+      end
+
+      def each
+        return enum_for(:each) unless block_given?
+        @stack.each do |item|
+          @extensions.each do |ext|
+            dir = item.segments.dup
+            file = dir.pop
+            ext_stack = @stacks[dir + [file + ext]]
+            yield(ext_stack.item_for(item.root))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/valise/stack.rb

@@ -1,177 +1,84 @@
-# 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
-
+require 'valise/utils'
+require 'valise/item-enum'
+require 'valise/strategies/merge-diff'
+require 'valise/stack/extensions-decorator'
 
 module Valise
-  module ItemEnum
-    include Enumerable
-
-    class Enumerator
-      include ItemEnum
-
-      def initialize(list, &filter)
-        @list = list
-        @filter = proc(&filter)
-      end
+  class Stack
+    include Unpath
+    include ItemEnum
 
-      def each
-        @list.each do |item|
-          next unless @filter[item]
-          yield(item)
-        end
-      end
+    def inspect
+      "<default>:#{(@segments||%w{?}).join "/"} #{@valise.inspect}"
     end
 
-    def writable
-      Enumerator.new(self) do |item|
-        item.writable?
-      end
+    def initialize(path, set)
+      @segments = collapse(unpath(path))
+      @valise = set
     end
 
-    def absent
-      Enumerator.new(self) do |item|
-        not item.present?
-      end
-    end
+    attr_reader :segments, :valise
 
-    def present
-      Enumerator.new(self) do |item|
-        item.present?
-      end
-    end
-  end
-
-  class MergeDiff
-    @@classes = {}
-    def self.[](index)
-      @@classes[index]
+    def rel_path
+      repath(@segments)
     end
 
-    def self.register(index)
-      @@classes[index] = self
+    def merge_diff
+      @valise.merge_diff_for(self)
     end
 
-    def initialize(stack)
-      @stack = stack
+    def dump_load
+      @valise.serialization_for(self)
     end
 
-    class TopMost < MergeDiff
-      register :topmost
-
-      def merge(item)
-        item.load_contents
-      end
-
-      def diff(item, value)
-        value
-      end
+    def merged(item)
+      merge_diff.merge(item)
     end
 
-    class HashMerge < MergeDiff
-      register :hash_merge
-
-      def merge(item)
-        merge_stack(@stack.not_above(item).reverse)
-      end
-
-      def merge_stack(stack)
-        stack.present.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
+    def diffed(item, value)
+      merge_diff.diff(item, value)
     end
-  end
-
-  class Stack
-    include Unpath
-    include ItemEnum
 
-    def inspect
-      "<default>:#{@segments.join "/"} #{@valise.inspect}"
+    def not_above(item)
+      reget(valise.not_above(item.root))
     end
 
-    def initialize(path, set, merge_class, dump_load)
-      @segments = collapse(unpath(path))
-      @valise = set
-      @merge_diff = (merge_class || MergeDiff::TopMost).new(self)
-      @dump_load = dump_load
+    def below(item)
+      reget(valise.below(item.root))
     end
 
-    attr_reader :segments
-
-    def merged(item)
-      @merge_diff.merge(item)
+    def reverse
+      reget(valise.reverse)
     end
 
-    def rel_path
-      repath(@segments)
+    def depth_of(item)
+      valise.depth_of(item.root)
     end
 
-    def diffed(item, value)
-      @merge_diff.diff(item, value)
+    def find
+      item = present.first
+      return item unless item.nil?
+      raise Errors::NotFound, "#{rel_path} not found in #{@valise.inspect}"
     end
 
-    def not_above(item)
-      Stack.new(@segments, @valise.not_above(item.root), @merge_diff.class, @dump_load)
+    def exts(*extensions)
+      exts = ExtensionsDecorator.new(self)
+      exts.extensions = extensions
+      return exts
     end
 
-    def below(item)
-      Stack.new(@segments, @valise.below(item.root), @merge_diff.class, @dump_load)
+    def reget(root)
+      root.get(@segments)
     end
 
-    def depth_of(item)
-      @valise.depth_of(item.root)
+    def item_for(root)
+      Item.new(self, root, dump_load)
     end
 
     def each
-      @valise.each do |root|
-        yield(Item.new(self, root, @dump_load))
+      valise.each do |root|
+        yield(item_for(root))
       end
     end
-
-    def reverse
-      Stack.new(@segments, @valise.reverse, @merge_diff.class, @dump_load)
-    end
   end
 end

data/lib/valise/stem-decorator.rb

@@ -60,10 +60,6 @@ module Valise
       return false
     end
 
-    def insert(item)
-      @search_root.insert(item)
-    end
-
     def get_from(item)
       @search_root.get_from(item)
     end

data/lib/valise/strategies/merge-diff.rb

@@ -0,0 +1,68 @@
+require 'valise/strategies/set'
+
+module Valise
+  module Strategies
+    class MergeDiff < Set
+      def initialize(options)
+        @stack = options[:stack]
+      end
+
+      class TopMost < MergeDiff
+        register :topmost
+        default
+
+        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.present.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
+  end
+end

data/lib/valise/strategies/serialization.rb

@@ -0,0 +1,33 @@
+require 'valise/strategies/set'
+
+module Valise
+  module Strategies
+    class Serialization < Set
+      register :raw
+      default
+
+      def initialize(options)
+      end
+
+      def dump(item)
+        item.load_contents
+      end
+
+      def load(item)
+        item.raw_contents
+      end
+
+      class YAML < Serialization
+        register :yaml
+
+        def dump(item)
+          ::YAML::dump(super)
+        end
+
+        def load(item)
+          ::YAML::load(super)
+        end
+      end
+    end
+  end
+end