hike 0.6.0 → 0.7.0

data/lib/hike.rb

@@ -1,7 +1,8 @@
 module Hike
-  VERSION = "0.5.1"
+  VERSION = "0.7.0"
 
   autoload :Extensions,      "hike/extensions"
+  autoload :Index,           "hike/index"
   autoload :NormalizedArray, "hike/normalized_array"
   autoload :Paths,           "hike/paths"
   autoload :Trail,           "hike/trail"

data/lib/hike/index.rb

@@ -0,0 +1,114 @@
+require 'pathname'
+
+module Hike
+  class Index
+    attr_reader :root, :paths, :extensions
+
+    def initialize(root, paths, extensions)
+      @root       = Pathname.new(root).expand_path
+      @paths      = paths.map { |path| Pathname.new(path).expand_path }
+      @extensions = extensions.to_a
+
+      @stats    = {}
+      @entries  = {}
+      @patterns = {}
+    end
+
+    def find(*logical_paths, &block)
+      if block_given?
+        options = extract_options!(logical_paths)
+        base_path = Pathname.new(options[:base_path] || @root)
+
+        logical_paths.each do |logical_path|
+          logical_path = Pathname.new(logical_path.sub(/^\//, ''))
+
+          if relative?(logical_path)
+            find_in_base_path(logical_path, base_path, &block)
+          else
+            find_in_paths(logical_path, &block)
+          end
+        end
+
+        nil
+      else
+        find(*logical_paths) do |path|
+          return path
+        end
+      end
+    end
+
+    protected
+      def extract_options!(arguments)
+        arguments.last.is_a?(Hash) ? arguments.pop.dup : {}
+      end
+
+      def relative?(logical_path)
+        logical_path.to_s =~ /^\.\.?\//
+      end
+
+      def find_in_paths(logical_path, &block)
+        dirname, basename = logical_path.split
+        paths.each do |base_path|
+          match(base_path.join(dirname), basename, &block)
+        end
+      end
+
+      def find_in_base_path(logical_path, base_path, &block)
+        candidate = base_path.join(logical_path)
+        dirname, basename = candidate.split
+        match(dirname, basename, &block) if paths_contain?(dirname)
+      end
+
+      def match(dirname, basename)
+        matches = entries(dirname)
+
+        pattern = pattern_for(basename)
+        matches = matches.select { |m| m.to_s =~ pattern }
+
+        sort_matches(matches, basename).each do |path|
+          pathname = dirname.join(path)
+          stat     = stat(pathname)
+
+          if stat && stat.file?
+            yield pathname.to_s
+          end
+        end
+      end
+
+      def stat(pathname)
+        if @stats.key?(pathname)
+          @stats[pathname]
+        else
+          begin
+            @stats[pathname] = pathname.stat
+          rescue Errno::ENOENT
+            @stats[pathname] = nil
+          end
+        end
+      end
+
+      def entries(pathname)
+        @entries[pathname] ||= pathname.entries.reject { |entry| entry.to_s =~ /^\.\.?$/ }
+      rescue Errno::ENOENT
+        @entries[pathname] = []
+      end
+
+      def paths_contain?(dirname)
+        paths.any? { |path| dirname.to_s[0, path.to_s.length] == path.to_s }
+      end
+
+      def pattern_for(basename)
+        @patterns[basename] ||= begin
+          extension_pattern = extensions.map { |e| Regexp.escape(e) }.join("|")
+          /^#{Regexp.escape(basename.to_s)}(?:#{extension_pattern}|)+$/
+        end
+      end
+
+      def sort_matches(matches, basename)
+        matches.sort_by do |match|
+          extnames = match.to_s[basename.to_s.length..-1].scan(/.[^.]+/)
+          extnames.inject(0) { |sum, ext| sum + extensions.index(ext) + 1 }
+        end
+      end
+  end
+end

data/lib/hike/trail.rb

@@ -1,5 +1,6 @@
 require 'pathname'
 require 'hike/extensions'
+require 'hike/index'
 require 'hike/paths'
 
 module Hike
@@ -7,8 +8,8 @@ module Hike
     attr_reader :paths, :extensions
 
     def initialize(root = ".")
-      @root = Pathname.new(root).expand_path
-      @paths = Paths.new(@root)
+      @root       = Pathname.new(root).expand_path
+      @paths      = Paths.new(@root)
       @extensions = Extensions.new
     end
 
@@ -16,113 +17,12 @@ module Hike
       @root.to_s
     end
 
-    def find(*logical_paths, &block)
-      if block_given?
-        options = extract_options!(logical_paths)
-        base_path = Pathname.new(options[:base_path] || @root)
-
-        options[:directories] ||= false
-
-        options[:stat_cache]     = {}
-        options[:entries_cache]  = {}
-        options[:patterns_cache] = {}
-
-        logical_paths.each do |logical_path|
-          logical_path = Pathname.new(logical_path.sub(/^\//, ''))
-
-          if relative?(logical_path)
-            find_in_base_path(logical_path, base_path, options, &block)
-          else
-            find_in_paths(logical_path, options, &block)
-          end
-        end
-
-        nil
-      else
-        find(*logical_paths) do |path|
-          return path
-        end
-      end
+    def index
+      Index.new(root, paths, extensions)
     end
 
-    protected
-      def extract_options!(arguments)
-        arguments.last.is_a?(Hash) ? arguments.pop.dup : {}
-      end
-
-      def relative?(logical_path)
-        logical_path.to_s =~ /^\.\.?\//
-      end
-
-      def pathnames
-        paths.map { |path| Pathname.new(path) }
-      end
-
-      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, options, &block)
-        candidate = base_path.join(logical_path)
-        dirname, basename = candidate.split
-        match(dirname, basename, options, &block) if paths_contain?(dirname)
-      end
-
-      def match(dirname, basename, options)
-        matches = entries(options[:entries_cache], dirname)
-
-        pattern = pattern_for(options[:patterns_cache], basename)
-        matches = matches.select { |m| m.to_s =~ pattern }
-
-        cache = options[:stat_cache]
-        sort_matches(matches, basename).each do |path|
-          pathname = dirname.join(path)
-
-          if options[:directories]
-            yield pathname.to_s
-          elsif (stat = self.stat(cache, pathname)) && stat.file?
-            yield pathname.to_s
-          end
-        end
-      end
-
-      def stat(cache, pathname)
-        if cache.key?(pathname)
-          cache[pathname]
-        else
-          begin
-            cache[pathname] = pathname.stat
-          rescue Errno::ENOENT
-            cache[pathname] = nil
-          end
-        end
-      end
-
-      def entries(cache, pathname)
-        cache[pathname] ||= pathname.entries.reject { |entry| entry.to_s =~ /^\.\.?$/ }
-      rescue Errno::ENOENT
-        cache[pathname] = []
-      end
-
-      def paths_contain?(dirname)
-        paths.any? { |path| dirname.to_s[0, path.to_s.length] == path }
-      end
-
-      def pattern_for(cache, basename)
-        cache[basename] ||= begin
-          extension_pattern = extensions.map { |e| Regexp.escape(e) }.join("|")
-          /^#{Regexp.escape(basename.to_s)}(?:#{extension_pattern}|)+$/
-        end
-      end
-
-      def sort_matches(matches, basename)
-        matches.sort_by do |match|
-          extnames = match.to_s[basename.to_s.length..-1].scan(/.[^.]+/)
-          extnames.inject(0) { |sum, ext| sum + extensions.index(ext) + 1 }
-        end
-      end
+    def find(*args, &block)
+      index.find(*args, &block)
+    end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: hike
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 3
   prerelease: 
   segments: 
   - 0
-  - 6
+  - 7
   - 0
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Sam Stephenson
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-30 00:00:00 -05:00
+date: 2011-04-03 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -30,6 +30,7 @@ extra_rdoc_files: []
 
 files: 
 - lib/hike/extensions.rb
+- lib/hike/index.rb
 - lib/hike/normalized_array.rb
 - lib/hike/paths.rb
 - lib/hike/trail.rb
@@ -64,7 +65,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.3
+rubygems_version: 1.5.0
 signing_key: 
 specification_version: 3
 summary: Find files in a set of paths