valise 0.9.1 → 1.0.0

data/lib/valise/adapters/tilt.rb

@@ -39,7 +39,7 @@ module Valise
         if block_given?
           options = yield(mapping)
         end
-        new_set.add_serialization_handler("**/*.#{mapping}", :tilt, options)
+        new_set.add_serialization_handler("**.#{mapping}", :tilt, options)
       end
       new_set
     end

data/lib/valise/errors.rb

@@ -1,6 +1,6 @@
 module Valise
   module Errors
-    class Error < ::Exception; end
+    class Error < ::StandardError; end
 
     class PathOutsideOfRoot < Error; end
     class PathNotInRoot < Error; end
@@ -11,6 +11,7 @@ module Valise
     class MalformedTree < Error; end
     class RootNotInSet < Error; end
     class UnderIndented < Error; end
+    class NoMatchingPath < Error; end
 
     class UnregisteredStrategy < Error
       def initialize(klass, type)

data/lib/valise/path-matcher.rb

@@ -6,131 +6,56 @@ module Valise
     include Enumerable
 
     def self.build(path, value = true)
-      case path
-      when PathMatcher
-        return path
-      when String, Array
-        matcher = PathMatcher.new
-        matcher[path] = value
-        return matcher
-      else
-        raise ArgumentError, "Path matchers can only be built from arrays or strings"
-      end
-    end
-
-    def initialize(segment = nil)
-      @children = []
-      @segment = segment
-      @value = nil
+      return path if PathMatcher === path
+      path = Unpath::make_pathname(path).to_s
+      self.new(path, value)
     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 each(prefix = [])
-      each_pair do |segments, value|
-        yield(segments) if !!value
-      end
+    def initialize(first_pattern=nil, first_value=true)
+      @pattern_pairs = []
+      set(first_pattern, first_value) unless first_pattern.nil?
     end
 
-    def merge!(other)
-      other.each_pair do |path, value|
-        self[path] = value
-      end
-    end
-
-    def [](path)
-      retreive(unpath(path))
+    def ===(path)
+      path = make_pathname(path)
+      fetch(path)
+      return true
+    rescue KeyError
+      return false
     end
 
-    def retreive(segments)
-      if segments.empty?
-        return @value
-      else
-        @children.each do |child|
-          val = child.access(segments)
-          return val unless val.nil?
+    def fetch(path)
+      @pattern_pairs.each do |pattern, value|
+        if path.fnmatch?(pattern)
+          return value
         end
       end
-      return nil
-    end
-
-    def access(segments)
-      return retreive(segments.drop(1)) if match?(segments.first)
-      return nil
+      raise KeyError, "No pattern matches #{path.to_s}"
     end
 
-    def match?(segment)
-      @segment == segment
-    end
-
-    def []=(pattern, result)
-      store(unpath(pattern), result)
-    end
-
-    def ===(path)
-      return !!self[path]
+    def [](path)
+      fetch(path)
+    rescue KeyError
+      nil
     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.unshift m}
-          end
-        target.store(segments, result)
+    def set(pattern, value)
+      @pattern_pairs.delete_if do |old_pattern, _|
+        pattern == old_pattern
       end
+      @pattern_pairs << [pattern.to_s, value]
     end
-  end
-
-  class DirGlob < PathMatcher
-    def initialize
-      super('**')
-    end
+    alias []= set
 
-    def match?(segment)
-      true
-    end
-
-    def access(segments)
-      if segments.empty?
-        return @value
-      else
-        retreive(segments) || access(segments.drop(1))
+    def each_pair
+      @pattern_pairs.each do |pattern, value|
+        yield pattern, value
       end
     end
-  end
-
-  class FileGlob < PathMatcher
-    def initialize(segment)
-      super
-      @regex = %r{^#{segment.gsub(/[.]/, "[.]").gsub(/[*]/,".*")}$}
-    end
-
-    def match?(segment)
-      @regex =~ segment
-    end
 
-    def store(segments, result)
-      if segments.empty?
-        @value = result
-      else
-        raise ArgumentError, "File globs can only be used as suffixes"
+    def merge!(other)
+      other.each_pair do |pattern, value|
+        set(pattern, value)
       end
     end
   end

data/lib/valise/search-root.rb

@@ -10,33 +10,23 @@ module Valise
     include Enumerable
 
     def initialize(path)
-      @segments = unpath(path)
+      @segments = make_pathname(path)
     end
 
     attr_accessor :segments
 
-    #ALL_FILES = PathMatcher.build('**')
     def each(pathmatch = nil)
-#      pathmatch ||= ALL_FILES
-#      files = pathmatch.fnmatchers(@segments).inject([]) do |list, fnmatch|
-#        list + Dir.glob(fnmatch).find_all{|path| File::file?(path)}
-#      end
-#      pathmatch.sort(files).each
-#
-#
-      paths = [[]]
+      paths = [make_pathname("")]
       until paths.empty?
         rel = paths.shift
-        path = repath(@segments + rel)
+        path = @segments + rel
         #symlinks?
-        if(File::directory?(path))
-          Dir.entries(path).each do |entry|
-            next if entry == "."
-            next if entry == ".."
-            paths.push(rel + [entry])
+        if path.directory?
+          paths += path.children(false).map do |child|
+            rel + child
           end
-        elsif(File::file?(path))
-          yield(unpath(rel))
+        elsif path.file?
+          yield rel
         end
       end
     end
@@ -50,7 +40,7 @@ module Valise
     end
 
     def full_path(segments)
-      repath(@segments + segments)
+      (@segments + make_pathname(segments)).to_s
     end
 
     def write(item)
@@ -96,7 +86,7 @@ module Valise
     end
 
     def full_path(segments)
-      "<DEFAULTS>:" + repath(segments)
+      "<DEFAULTS>:" + segments.to_s
     end
 
     def present?(segments)
@@ -105,7 +95,7 @@ module Valise
 
     def each
       @files.each_key do |path|
-        yield(unpath(path))
+        yield(make_pathname(path))
       end
     end
 
@@ -133,7 +123,7 @@ module Valise
         end
         check_path.pop
       end
-      @files[path] = contents
+      @files[make_pathname(path)] = contents
     end
 
     def add_dir(path)

data/lib/valise/set/definer.rb

@@ -7,7 +7,7 @@ module Valise
     class StemmedDefiner
       include Unpath
       def initialize(path, set)
-        @segments = unpath(path)
+        @segments = make_pathname(path)
         @target = set
       end
 
@@ -43,7 +43,7 @@ module Valise
       end
 
       def handle(path, serialization, merge_diff = nil)
-        @target.add_handler(unpath(path),
+        @target.add_handler(make_pathname(path),
                             serialization,
                             merge_diff)
       end

data/lib/valise/set.rb

@@ -1,4 +1,3 @@
-require 'valise/debugging'
 require 'valise/errors'
 require 'valise/search-root'
 require 'valise/utils'
@@ -10,7 +9,6 @@ require 'valise/set/extensions-decorator'
 
 module Valise
   class Set
-    include Debugging
     include Enumerable
     include Unpath
 
@@ -24,8 +22,8 @@ module Valise
       search_roots.inspect
     end
 
-    def to_s
-      search_roots.map(&:to_s).join(":")
+    def to_s(joiner=nil)
+      search_roots.map(&:to_s).join(joiner||":")
     end
 
     def exts(*extensions)
@@ -49,7 +47,7 @@ module Valise
     end
 
     def sub_set(path)
-      segments = unpath(path)
+      segments = make_pathname(path)
       transform do |roots|
         roots.map do |root|
           new_root = root.dup
@@ -60,7 +58,7 @@ module Valise
     end
 
     def stemmed(path)
-      segments = unpath(path)
+      segments = make_pathname(path)
       transform do |roots|
         roots.map do |root|
           StemDecorator.new(segments, root)
@@ -102,7 +100,13 @@ module Valise
       search_roots << search_root
     end
 
+    def clean_pattern(pattern)
+      #deprecation warning maybe
+      pattern.sub(%r{^[*][*]/[*]}, '**')
+    end
+
     def add_handler(segments, serialization_class, merge_diff_class)
+      segments = clean_pattern(segments)
       add_serialization_handler(segments, serialization_class)
       add_merge_handler(segments, merge_diff_class)
     end
@@ -133,13 +137,13 @@ module Valise
       :serialization=, :serialization
 
     def merge_diff_for(stack)
-      type, options = *(merge_diff[unpath(stack.segments)] || [])
+      type, options = *(merge_diff[make_pathname(stack.segments)] || [])
       options = (options || {}).merge(:stack => stack)
       Strategies::MergeDiff.instance(type, options)
     end
 
     def serialization_for(stack)
-      type, options = *serialization[unpath(stack.segments)]
+      type, options = *serialization[make_pathname(stack.segments)]
       Strategies::Serialization.instance(type, options)
     end
 
@@ -160,6 +164,10 @@ module Valise
       get(path).find
     end
 
+    def contents(path)
+      find(path).contents
+    end
+
     def each(&block)
       search_roots.each(&block)
     end

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

@@ -6,7 +6,9 @@ module Valise
       def initialize(stack)
         @stack = stack
         @extensions = []
-        @stacks = Hash.new{|h,segments| h[segments] = @stack.valise.get(segments) }
+        @stacks = Hash.new do |h,segments|
+          h[segments] = @stack.valise.get(segments)
+        end
       end
 
       attr_accessor :extensions
@@ -41,9 +43,8 @@ module Valise
         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]]
+            dir, file = *item.segments.split
+            ext_stack = @stacks[dir + (file.to_s + ext)]
             yield(ext_stack.item_for(item.root))
           end
         end

data/lib/valise/stack.rb

@@ -9,18 +9,18 @@ module Valise
     include ItemEnum
 
     def inspect
-      "<default>:#{(@segments||%w{?}).join "/"} #{@valise.inspect}"
+      "<default>:#{(@segments||%{?})} #{@valise.inspect}"
     end
 
     def initialize(path, set)
-      @segments = collapse(unpath(path))
+      @segments = make_pathname(path)
       @valise = set
     end
 
     attr_reader :segments, :valise
 
     def rel_path
-      repath(@segments)
+      @segments
     end
 
     def merge_diff
@@ -58,7 +58,7 @@ module Valise
     def find
       item = present.first
       return item unless item.nil?
-      raise Errors::NotFound, "#{rel_path} not found in #{@valise.inspect}"
+      raise Errors::NotFound, "'#{rel_path}' not found in #{valise.inspect}"
     end
 
     def exts(*extensions)

data/lib/valise/stem-decorator.rb

@@ -19,18 +19,21 @@ module Valise
       @search_root.segments = segments
     end
 
+    def stem_pattern
+      (@stem + "**").to_s
+    end
+
     def under_stem(path)
-      segments = unpath(path)
-      top_part = segments[0...@stem.length]
-      if top_part == @stem
-        return segments[@stem.length..-1]
+      segments = make_pathname(path)
+      if path.fnmatch?(stem_pattern)
+        return path.relative_path_from(@stem)
       else
         raise Errors::PathOutsideOfRoot
       end
     end
 
     def inspect
-      "#{self.class.name.split(":").last}:[#{@stem.join("/")}]#{@search_root.inspect}"
+      "#{self.class.name.split(":").last}:[#{@stem.to_s}]#{@search_root.inspect}"
     end
 
     def each

data/lib/valise/utils.rb

@@ -1,3 +1,6 @@
+require 'pathname'
+require 'valise/errors'
+
 module Valise
   module StringTools
     def align(string)
@@ -17,13 +20,8 @@ module Valise
     module_function :align
   end
 
-  #XXX This has been overtaken by std-lib Pathname and should be mostly
-  #refactored out
   module Unpath
-    def string_to_segments(string)
-      return string if string.empty?
-      string.split(::File::Separator)
-    end
+    extend self
 
     def file_from_backtrace(line)
       /(.*):\d+/.match(line)[1]
@@ -31,88 +29,109 @@ module Valise
 
     def from_here(rel_path, base_path = nil)
       base_path ||= file_from_backtrace(caller[0])
-      repath(collapse(unpath(base_path) + unpath(rel_path)))
+      make_pathname(base_path) + make_pathname(rel_path)
+    end
+
+    def starting_directory
+      make_pathname(ENV['PWD'] || Dir.pwd)
+      #Otherwise symlinks won't behave as expected
+    end
+    alias start_dir starting_directory
+
+    def current_directory
+      make_pathname(Dir.pwd)
     end
 
-    def up_to(up_to = nil, base_path = nil)
+    def up_to(up_to=nil, base_path = nil)
       base_path ||= file_from_backtrace(caller[0])
       up_to ||= "lib"
 
-      abs_path = File::expand_path(base_path)
-      base_path = unpath(base_path)
-      until base_path.empty? or base_path.last == up_to
-        base_path.pop
+      up_until(base_path, "Path with basename #{up_to.inspect}") do |path|
+        path.basename.to_s == up_to
       end
+    end
 
-      if base_path.empty?
-        raise "Relative root #{up_to.inspect} not found in #{abs_path.inspect}"
-      end
+    class WorkspaceFinder
+      include Unpath
 
-      return repath(base_path)
-    end
+      attr_accessor :search_from, :workspace_children, :description, :fallback
 
-    def unpath(parts)
-      if Array === parts and parts.length == 1
-        parts = parts[0]
+      def search_from
+        @search_from ||= start_dir
       end
 
-      case parts
-      when Array
-        if (parts.find{|part| not (String === part or Symbol === part)}.nil?)
-          parts = parts.map{|part| string_to_segments(part.to_s)}.flatten
-        else
-          raise ArgumentError, "path must be composed of strings or symbols"
-        end
-      when String
-        parts = string_to_segments(parts)
-      when Symbol
-        parts = string_to_segments(parts.to_s)
-      when ::File
-        parts = parts.path
-        parts = parts.split(::File::Separator)
-      else
-        raise ArgumentError, "path must be String, Array of Strings or File"
+      def workspace_children
+        @workspace_children ||= %w{.git .hg _MTN}
       end
 
-      if /^~/ =~ parts[0]
-        parts = ::File::expand_path(parts[0]).split(::File::Separator) + parts[1..-1]
+      def description
+        @description ||= "Version control workspace"
       end
 
-      return parts
-    end
+      def search_start
+        path = make_pathname(search_from)
+        path = path.realpath unless path.absolute?
+        path
+      end
 
-    def collapse(segments)
-      collapsed = []
-      segments.each do |segment|
-        case segment
-        when '.'
-        when ""
-          if collapsed.empty?
-            collapsed.push segment
-          end
-        when '..'
-          if collapsed.empty?
-            collapsed.push segment
-          else
-            collapsed.pop
+      def find
+        up_until(search_start, description) do |path|
+          path.children(false).any? do |child|
+            workspace_children.any? do |vc_config|
+              child.fnmatch? vc_config
+            end
           end
+        end
+      rescue Errors::NoMatchingPath
+        if fallback.nil?
+          raise
         else
-          collapsed.push segment
+          fallback
         end
       end
-      collapsed
     end
 
-    def repath(segments)
-      case segments
+    def containing_workspace
+      finder = WorkspaceFinder.new
+      yield finder if block_given?
+      finder.find
+    end
+
+    def up_until(base_path = nil, description=nil)
+      base_path ||= file_from_backtrace(caller[0])
+      make_pathname(base_path).ascend do |path|
+        if yield(path)
+          return path
+        end
+      end
+      raise Errors::NoMatchingPath, "#{description || "Satisfactory path"} not found in #{base_path}"
+    end
+
+    def clean_pathname(pathname)
+      pathname.sub(/^~[^#{File::Separator}]*/) do |homedir|
+        File::expand_path(homedir)
+      end.cleanpath
+    end
+
+    def make_pathname(parts)
+      case parts
+      when Pathname
+        return clean_pathname(parts)
       when Array
-        return segments.join(::File::Separator)
+        unless parts.any?{|part| not (String === part or Symbol === part)}
+          parts = File::join(parts.map{|part| part.to_s})
+        else
+          raise ArgumentError, "path must be composed of strings or symbols"
+        end
       when String
-        return segments
+      when Symbol
+        parts = parts.to_s
+      when ::File
+        parts = parts.path
+      else
+        raise ArgumentError, "path must be String, Array of Strings or File"
       end
+      pathname = clean_pathname(Pathname.new(parts))
     end
-
-    module_function :from_here, :up_to, :unpath, :repath, :string_to_segments, :file_from_backtrace
-    public :from_here, :up_to, :file_from_backtrace
   end
 end

data/spec/fileset.rb

@@ -36,7 +36,7 @@ describe Valise do
 
   describe "retrieving files" do
     it "should get default text files" do
-      @valise.find("text").contents.should == "Some text"
+      @valise.contents("text").should == "Some text"
       @valise.find(:text).contents.should == "Some text"
     end
 

data/spec/population.rb

@@ -31,7 +31,7 @@ describe Valise do
     end
 
     it "should populate successfully" do
-      @to.find("egg").contents.should == "yolk"
+      @to.contents("egg").should == "yolk"
       @to.find("existed").contents.should == "TEST"
     end
   end
@@ -45,7 +45,7 @@ describe Valise do
 
     it "should populate successfully" do
       @to.find("egg").contents.should == "yolk"
-      @to.find("existed").contents.should == "TEST"
+      @to.contents("existed").should == "TEST"
     end
   end
 end

data/spec_help/spec_helper.rb

@@ -1,5 +1,9 @@
 require 'rspec'
+#require 'cadre/rspec'
 
 RSpec.configure do |config|
   config.backtrace_clean_patterns.delete(/gems/)
+  config.run_all_when_everything_filtered = true
+#  config.add_formatter(Cadre::RSpec::NotifyOnCompleteFormatter)
+#  config.add_formatter(Cadre::RSpec::QuickfixFormatter)
 end

metadata

@@ -1,32 +1,32 @@
 --- !ruby/object:Gem::Specification
 name: valise
 version: !ruby/object:Gem::Version
-  version: 0.9.1
   prerelease: 
+  version: 1.0.0
 platform: ruby
 authors:
 - Judson Lester
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-31 00:00:00.000000000 Z
+date: 2013-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  prerelease: false
+  type: :development
   name: corundum
-  requirement: !ruby/object:Gem::Requirement
-    none: false
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
     none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+    none: false
 description: ! "  Valise provides an API for accessing configuration and data files
   for your\n  application, including the population of default values, and managing
   search\n  paths.  Written to encourage a cross-platform approach to maintaining
@@ -107,7 +107,6 @@ files:
 - doc/Specifications
 - lib/valise.rb
 - lib/valise/item-enum.rb
-- lib/valise/debugging.rb
 - lib/valise/utils.rb
 - lib/valise/errors.rb
 - lib/valise/adapters.rb
@@ -209,24 +208,24 @@ rdoc_options:
 - --main
 - doc/README
 - --title
-- valise-0.9.1 RDoc
+- valise-1.0.0 RDoc
 require_paths:
 - lib/
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
       segments:
       - 0
-      hash: 907833537
-required_rubygems_version: !ruby/object:Gem::Requirement
+      hash: -884203725
+      version: '0'
   none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+  none: false
 requirements: []
 rubyforge_project: valise
 rubygems_version: 1.8.24

data/lib/valise/debugging.rb

@@ -1,19 +0,0 @@
-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
-end