hike 0.4.0 → 0.5.0

data/lib/hike.rb

@@ -1,5 +1,5 @@
 module Hike
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 
   autoload :DirectoryIndex,  "hike/directory_index"
   autoload :Extensions,      "hike/extensions"

data/lib/hike/directory_index.rb

@@ -1,3 +1,5 @@
+require 'pathname'
+
 module Hike
   class DirectoryIndex
     def initialize
@@ -11,10 +13,10 @@ module Hike
     end
 
     def entries(dirname)
-      dirname = File.expand_path(dirname)
-      @entries[dirname] ||= if File.directory?(dirname)
-        Dir.entries(dirname).reject do |entry|
-          entry =~ /^\.\.?$/
+      dirname = Pathname.new(dirname).expand_path
+      @entries[dirname] ||= if dirname.directory?
+        dirname.entries.reject do |entry|
+          entry.to_s =~ /^\.\.?$/
         end.sort
       else
         []
@@ -22,10 +24,10 @@ module Hike
     end
 
     def files(dirname)
-      dirname = File.expand_path(dirname)
+      dirname = Pathname.new(dirname).expand_path
       @files[dirname] ||= entries(dirname).select do |entry|
-        File.file?(File.join(dirname, entry))
-      end
+        dirname.join(entry).file?
+      end.map(&:to_s)
     end
   end
 end

data/lib/hike/paths.rb

@@ -1,13 +1,16 @@
+require 'pathname'
+
 module Hike
   class Paths < NormalizedArray
     def initialize(root = ".")
-      @root = root
+      @root = Pathname.new(root)
       super()
     end
 
     def normalize_element(path)
-      path = File.join(@root, path) unless path[/^\//]
-      File.expand_path(path)
+      path = Pathname.new(path)
+      path = @root.join(path) if path.relative?
+      path.expand_path.to_s
     end
   end
 end

data/lib/hike/trail.rb

@@ -1,25 +1,35 @@
+require 'pathname'
+
 module Hike
   class Trail
-    attr_reader :root, :paths, :extensions
+    attr_reader :paths, :extensions
 
     def initialize(root = ".")
-      @root = File.expand_path(root)
-      @index = DirectoryIndex.new
+      @root = Pathname.new(root).expand_path
       @paths = Paths.new(@root)
       @extensions = Extensions.new
     end
 
+    def root
+      @root.to_s
+    end
+
     def find(*logical_paths, &block)
       if block_given?
         options = extract_options!(logical_paths)
-        base_path = options[:base_path] || root
-        reset!
+        base_path = Pathname.new(options[:base_path] || @root)
+
+        options[:directories] ||= false
+
+        options[:index_cache]    = DirectoryIndex.new
+        options[:patterns_cache] = {}
 
         logical_paths.each do |logical_path|
+          logical_path = Pathname.new(logical_path)
           if relative?(logical_path)
-            find_in_base_path(logical_path, base_path, &block)
+            find_in_base_path(logical_path, base_path, options, &block)
           else
-            find_in_paths(logical_path, &block)
+            find_in_paths(logical_path, options, &block)
           end
         end
 
@@ -32,53 +42,57 @@ module Hike
     end
 
     protected
-      def reset!
-        @index.expire_cache
-        @patterns = {}
-      end
-
       def extract_options!(arguments)
-        arguments.last.is_a?(Hash) ? arguments.pop : {}
+        arguments.last.is_a?(Hash) ? arguments.pop.dup : {}
       end
 
       def relative?(logical_path)
-        logical_path =~ /^\.\.?\//
+        logical_path.to_s =~ /^\.\.?\//
+      end
+
+      def pathnames
+        paths.map { |path| Pathname.new(path) }
       end
 
-      def find_in_paths(logical_path, &block)
-        dirname, basename = File.split(logical_path)
-        paths.each do |base_path|
-          match(File.join(base_path, dirname), basename, &block)
+      def find_in_paths(logical_path, options, &block)
+        dirname, basename = logical_path.split
+        pathnames.each do |base_path|
+          match(base_path.join(dirname), basename, options, &block)
         end
       end
 
-      def find_in_base_path(logical_path, base_path, &block)
-        candidate = File.expand_path(File.join(base_path, logical_path))
-        dirname, basename = File.split(candidate)
-        match(dirname, basename, &block) if paths_contain?(dirname)
+      def find_in_base_path(logical_path, base_path, options, &block)
+        candidate = base_path.join(logical_path).expand_path
+        dirname, basename = candidate.split
+        match(dirname, basename, options, &block) if paths_contain?(dirname)
       end
 
-      def match(dirname, basename)
-        matches = @index.files(dirname).grep(pattern_for(basename))
+      def match(dirname, basename, options)
+        index   = options[:index_cache]
+        pattern = pattern_for(basename, options)
+
+        matches = options[:directories] ? index.entries(dirname) : index.files(dirname)
+        matches = matches.select { |m| m.to_s =~ pattern }
+
         sort_matches(matches, basename).each do |path|
-          yield File.expand_path(File.join(dirname, path))
+          yield dirname.join(path).expand_path.to_s
         end
       end
 
       def paths_contain?(dirname)
-        paths.any? { |path| dirname[0, path.length] == path }
+        paths.any? { |path| dirname.to_s[0, path.to_s.length] == path }
       end
 
-      def pattern_for(basename)
-        @patterns[basename] ||= begin
+      def pattern_for(basename, options)
+        options[:patterns_cache][basename] ||= begin
           extension_pattern = extensions.map { |e| Regexp.escape(e) }.join("|")
-          /^#{Regexp.escape(basename)}(?:#{extension_pattern}|)+$/
+          /^#{Regexp.escape(basename.to_s)}(?:#{extension_pattern}|)+$/
         end
       end
 
       def sort_matches(matches, basename)
         matches.sort_by do |match|
-          extnames = match[basename.length..-1].scan(/.[^.]+/)
+          extnames = match.to_s[basename.to_s.length..-1].scan(/.[^.]+/)
           extnames.inject(0) { |sum, ext| sum + extensions.index(ext) + 1 }
         end
       end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: hike
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 11
   prerelease: 
   segments: 
   - 0
-  - 4
+  - 5
   - 0
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Sam Stephenson
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-04 00:00:00 -06:00
+date: 2011-03-21 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -65,7 +65,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.0
+rubygems_version: 1.5.3
 signing_key: 
 specification_version: 3
 summary: Find files in a set of paths