hike 0.2.0 → 0.3.0

data/lib/hike.rb

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

data/lib/hike/trail.rb

@@ -10,77 +10,87 @@ module Hike
     end
 
     def find(*logical_paths)
-      options = logical_paths.last.is_a?(Hash) ? logical_paths.pop : {}
-      if relative_to = options[:relative_to]
-        base_path = File.dirname(relative_to)
-      end
-
-      index.expire_cache
+      options = extract_options!(logical_paths)
+      base_path = options[:base_path] || root
+      reset!
 
-      logical_paths.each do |logical_path|
-        if relative_to
-          result = find_path_relative(logical_path, base_path)
+      searching(logical_paths) do |logical_path|
+        if relative?(logical_path)
+          find_in_base_path(logical_path, base_path)
         else
-          result = find_path(logical_path)
+          find_in_paths(logical_path)
         end
-
-        return File.expand_path(result) if result
       end
-      nil
     end
 
     protected
-      attr_reader :index
-
-      def find_path(logical_path)
-        dirname, basename = File.split(logical_path)
-        pattern = filename_pattern_for(basename)
+      def reset!
+        @index.expire_cache
+        @patterns = {}
+      end
 
-        paths.each do |base_path|
-          if path = find_in_base(File.join(base_path, dirname), basename, pattern)
-            return path
-          end
-        end
-        nil
+      def extract_options!(arguments)
+        arguments.last.is_a?(Hash) ? arguments.pop : {}
       end
 
-      def find_path_relative(logical_path, base_path)
-        dirname, basename = File.split(File.join(base_path, logical_path))
-        dirname = File.expand_path(dirname)
-        pattern = filename_pattern_for(basename)
+      def relative?(logical_path)
+        logical_path =~ /^\.\.?\//
+      end
 
-        if paths.any? { |path| dirname[0, path.length] == path }
-          find_in_base(File.expand_path(dirname), basename, pattern)
+      def find_in_paths(logical_path)
+        dirname, basename = File.split(logical_path)
+        searching(paths) do |base_path|
+          match(File.join(base_path, dirname), basename)
         end
       end
 
-      def find_in_base(base_path, base_name, pattern)
-        matches = match_files_in(base_path, pattern)
-        File.join(base_path, match_from(matches, base_name)) unless matches.empty?
+      def find_in_base_path(logical_path, base_path)
+        candidate = File.expand_path(File.join(base_path, logical_path))
+        dirname, basename = File.split(candidate)
+        match(dirname, basename) if paths_contain?(dirname)
       end
 
-      def match_files_in(dirname, pattern)
-        index.files(dirname).grep(pattern)
+      def match(dirname, basename)
+        matches = @index.files(dirname).grep(pattern_for(basename))
+        unless matches.empty?
+          path = select_match_from(matches, basename)
+          File.expand_path(File.join(dirname, path))
+        end
       end
 
-      def filename_pattern_for(basename)
-        extension_pattern = extensions.map { |e| Regexp.escape(e) }.join("|")
-        /^#{Regexp.escape(basename)}(?:#{extension_pattern}|)+$/
+      def paths_contain?(dirname)
+        paths.any? { |path| dirname[0, path.length] == path }
+      end
+
+      def pattern_for(basename)
+        @patterns[basename] ||= begin
+          extension_pattern = extensions.map { |e| Regexp.escape(e) }.join("|")
+          /^#{Regexp.escape(basename)}(?:#{extension_pattern}|)+$/
+        end
       end
 
-      def match_from(matches, basename)
+      def select_match_from(matches, basename)
         if matches.length == 1
           matches.first
         elsif matches.length > 1
-          ordered_match_from(matches, basename)
+          select_ordered_match_from(matches, basename)
         end
       end
 
-      def ordered_match_from(matches, basename)
+      def select_ordered_match_from(matches, basename)
         matches.sort_by do |match|
           extnames = match[basename.length..-1].scan(/.[^.]+/)
           extnames.inject(0) { |sum, ext| sum + extensions.index(ext) + 1 }
         end.first
       end
+
+      def searching(collection)
+        collection.each do |value|
+          if result = yield(value)
+            return result
+          end
+        end
+        nil
+      end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: hike
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 19
   prerelease: false
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Sam Stephenson
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-23 00:00:00 -06:00
+date: 2010-11-25 00:00:00 -06:00
 default_executable: 
 dependencies: []