findler 0.0.6 → 0.0.7

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZGNkZjllNWFjMzlhZjFlN2RjOGRkNWExMWU0NGU4ZDRiM2VhODhkZQ==
+  data.tar.gz: !binary |-
+    MTFiM2Y3Y2ZlMjk5MTRjMzBjYTQ0N2FmZTMyNTk3YjQ4MzA3NzhiMg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    NWY4NDA4NzE2YzFkNWU0MWI5NjVkZGRhOTBhOWNiZjg0ZmY1NGJiYWI0MTll
+    YTcxMTg3N2I0ZjE2Y2RmODMxZTgyOTk0ZjUzOGQ0NzE2M2JhYmU3MDY1NjVh
+    NGYwNGZjMWRmNWEwOTAwMzhjODM1NDcxNWNkN2Q0MjI1MjJjZmE=
+  data.tar.gz: !binary |-
+    Njg4MDNmMTU4N2Q2NDc2NTcyZGU0ZWE2YjBhNGI1MmFjOGY4MTljNjQzMzY5
+    YTU5Yjk5NjBlYjc2MjI2Yzc4YmQxYTFiNTUyMDBhMzBmOWMxOGYyZDdjMjcy
+    NGY2NjI5YWQzNTM3MTJiMWJhZTgyMTg2MDBkMDE5NTRlYTNjMmM=

data/.travis.yml

@@ -3,4 +3,7 @@ script: bundle exec rake
 rvm:
   - 1.8.7
   - 1.9.3
+  - 2.0.0
+  - jruby-18mode # JRuby in 1.8 mode
+  - jruby-19mode # JRuby in 1.9 mode
   - rbx-18mode

data/Gemfile

@@ -1,3 +1,3 @@
-source "http://rubygems.org"
+source 'https://rubygems.org'
 gemspec
 

data/README.md

@@ -26,25 +26,17 @@ The entire state of the iteration for the filesystem is returned, which can then
 be pushed onto any durable storage, like ActiveRecord or Redis, or just a local file:
 
 ```ruby
-File.open('iterator.state', 'w') { |f| Marshal.dump(iterator, f) }
+File.open('iterator.state', 'wb') { |f| Marshal.dump(iterator, f) }
 ```
 
 To resume iteration:
 
 ```ruby
-Marshal.load(IO.open('iterator.state'))
-iterator.next_file
+iterator2 = Marshal.load(File.open('iterator.state', 'rb'))
+iterator2.next_file
 # => "/Users/mrm/Photos/img_1001.jpg"
 ```
 
-To re-check a directory hierarchy for files that you haven't visited yet:
-
-```ruby
-iterator.rescan!
-iterator.next_file
-# => "/Users/mrm/Photos/img_1002.jpg"
-```
-
 External synchronization between the serialized state of the
 iterator and the other processes will have to be done by you, of course.
 The ```load```, ```next_file``` , and ```dump``` should be done while holding
@@ -123,6 +115,12 @@ Because procs and lambdas aren't ```Marshal```able, and I didn't want to use som
 
 ## Changelog
 
+### 0.0.7
+ * Use a non-inherited set per iterator, rather than a global bloom filter
+ * Removed the ability to "rescan" due to the weight of the bloom filter in marshalling when
+   traversing an enormous tree.
+ * Fixed marshal documentation and tests to support ruby 1.9+
+
 ### 0.0.6
  * ```add_filters``` takes an array, not a glob
  * added tests for order_by_mtime filters

data/findler.gemspec

@@ -1,12 +1,12 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "findler/version"
+$:.push File.expand_path('../lib', __FILE__)
+require 'findler/version'
 
 Gem::Specification.new do |gem|
-  gem.name = "findler"
+  gem.name = 'findler'
   gem.version = Findler::VERSION
-  gem.authors = ["Matthew McEachen"]
-  gem.email = ["matthew+github@mceachen.org"]
+  gem.authors = ['Matthew McEachen']
+  gem.email = %w(matthew+github@mceachen.org)
   gem.homepage = "https://github.com/mceachen/findler/"
   gem.summary = %q{Findler is a stateful filesystem iterator}
   gem.description = %q{Findler is designed for very large filesystem hierarchies,
@@ -17,9 +17,9 @@ Gem::Specification.new do |gem|
   gem.test_files = `git ls-files -- {test,features}/*`.split("\n")
   gem.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   gem.require_paths = ["lib"]
-  gem.add_development_dependency "rake"
-  gem.add_development_dependency "yard"
-  gem.add_development_dependency "minitest"
-  gem.add_development_dependency "minitest-reporters"
-  gem.add_dependency "bloomer"
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'yard'
+  gem.add_development_dependency 'minitest'
+  gem.add_development_dependency 'minitest-great_expectations'
+  gem.add_development_dependency 'minitest-reporters'
 end

data/lib/findler.rb

@@ -1,19 +1,18 @@
-class Findler
-
-  autoload :Iterator, "findler/iterator"
-  autoload :Error, "findler/error"
-  require "findler/filters"
+require 'findler/error'
+require 'findler/filters'
+require 'findler/iterator'
+require 'findler/path'
 
-  IGNORE_CASE = 1
-  INCLUDE_HIDDEN = 2
+class Findler
+  attr_reader :path
 
   def initialize(path)
-    @path = path
+    @path = Path.clean(path)
     @flags = 0
   end
 
-  # These are File.fnmatch patterns.
-  # If any pattern matches, it will be returned by Iterator#next.
+  # These are File.fnmatch patterns, and are only applied to files, not directories.
+  # If any pattern matches, it will be returned by Iterator#next_file.
   # (see File.fnmatch?)
   def patterns
     @patterns ||= []
@@ -38,31 +37,39 @@ class Findler
   # Should patterns be interpreted in a case-sensitive manner? The default is case sensitive,
   # but if your local filesystem is not case sensitive, this flag is a no-op.
   def case_sensitive!
-    @flags &= ~IGNORE_CASE
+    @flags &= ~File::FNM_CASEFOLD
   end
 
   def case_insensitive!
-    @flags |= IGNORE_CASE
+    @flags |= File::FNM_CASEFOLD
+  end
+
+  def ignore_case?
+    (@flags & File::FNM_CASEFOLD) > 0
   end
 
   # Should we traverse hidden directories and files? (default is to skip files that start
   # with a '.')
   def include_hidden!
-    @flags |= INCLUDE_HIDDEN
+    @flags |= File::FNM_DOTMATCH
   end
 
   def exclude_hidden!
-    @flags &= ~INCLUDE_HIDDEN
+    @flags &= ~File::FNM_DOTMATCH
   end
 
-  def filter_class
-    (@filter_class ||= Filters)
+  def include_hidden?
+    (@flags & File::FNM_DOTMATCH) > 0
   end
 
-  def filter_class=(new_filter_class)
-    raise Error unless new_filter_class.is_a? Class
-    filters.each{|ea|new_filter_class.method(ea)} # verify the filters class has those methods defined
-    @filter_class = new_filter_class
+  def filters_class
+    @filters_class ||= Filters
+  end
+
+  def filters_class=(new_filters_class)
+    raise Error unless new_filters_class.is_a? Class
+    filters.each { |ea| new_filters_class.method(ea) } # verify the filters class has those methods defined
+    @filters_class = new_filters_class
   end
 
   # Accepts symbols whose names are class methods on Finder::Filters.
@@ -78,12 +85,11 @@ class Findler
   # Note that the last filter added will be last to order the children, so it will be the
   # "primary" sort criterion.
   def add_filter(filter_symbol)
-    filter_class.method(filter_symbol)
     filters << filter_symbol
   end
 
   def filters
-    (@filters ||= [])
+    @filters ||= []
   end
 
   def add_filters(filter_symbols)
@@ -91,14 +97,41 @@ class Findler
   end
 
   def iterator
-    Iterator.new(:path => @path,
-                 :patterns => @patterns,
-                 :flags => @flags,
-                 :filters => @filters)
+    Iterator.new(self, path)
   end
 
   private
 
+  def filter_paths(pathnames)
+    viable_paths = pathnames.select { |ea| viable_path?(ea) }
+    filters.inject(viable_paths) do |paths, filter_symbol|
+      apply_filter(paths, filter_symbol)
+    end
+  end
+
+  # Should the given file or directory be iterated over?
+  def viable_path?(pathname)
+    return false if !pathname.exist?
+    return false if !include_hidden? && Path.hidden?(pathname)
+    if patterns.empty? || pathname.directory?
+      true
+    else
+      patterns.any? { |p| pathname.fnmatch(p, @flags) }
+    end
+  end
+
+  def apply_filter(pathnames, filter_method_sym)
+    filtered_pathnames = filters_class.send(filter_method_sym, pathnames.dup)
+    unless filtered_pathnames.respond_to? :map
+      raise Error, "#{filters_class}.#{filter_method_sym} did not return an Enumerable"
+    end
+    unexpected_paths = filtered_pathnames - pathnames
+    unless unexpected_paths.empty?
+      raise Error, "#{filters_class}.#{filter_method_sym} returned unexpected paths: #{unexpected_paths.collect { |ea| ea.to_s }.join(",")}"
+    end
+    filtered_pathnames
+  end
+
   def normalize_extension(extension)
     if extension.nil? || extension.empty? || extension.start_with?(".")
       extension

data/lib/findler/error.rb

@@ -1,2 +1,4 @@
-class Findler::Error < StandardError
+class Findler
+  class Error < StandardError
+  end
 end

data/lib/findler/filters.rb

@@ -1,38 +1,40 @@
-class Findler::Filters
-  # files first, then directories
-  def self.files_first(paths)
-    preserve_sort_by(paths) { |ea| ea.file? ? -1 : 1 }
-  end
+class Findler
+  class Filters
+    # files first, then directories
+    def self.files_first(paths)
+      preserve_sort_by(paths) { |ea| ea.file? ? -1 : 1 }
+    end
 
-  # directories first, then files
-  def self.directories_first(paths)
-    preserve_sort_by(paths) { |ea| ea.directory? ? -1 : 1 }
-  end
+    # directories first, then files
+    def self.directories_first(paths)
+      preserve_sort_by(paths) { |ea| ea.directory? ? -1 : 1 }
+    end
 
-  # order by the mtime of each file. Oldest files first.
-  def self.order_by_mtime_asc(paths)
-    preserve_sort_by(paths)  { |ea| ea.mtime.to_i }
-  end
+    # order by the mtime of each file. Oldest files first.
+    def self.order_by_mtime_asc(paths)
+      preserve_sort_by(paths) { |ea| ea.mtime.to_i }
+    end
 
-  # reverse order by the mtime of each file. Newest files first.
-  def self.order_by_mtime_desc(paths)
-    preserve_sort_by(paths)  { |ea| -1 * ea.mtime.to_i }
-  end
+    # reverse order by the mtime of each file. Newest files first.
+    def self.order_by_mtime_desc(paths)
+      preserve_sort_by(paths) { |ea| -1 * ea.mtime.to_i }
+    end
 
-  # order by the name of each file.
-  def self.order_by_name(paths)
-    preserve_sort_by(paths)  { |ea| ea.basename.to_s }
-  end
+    # order by the name of each file.
+    def self.order_by_name(paths)
+      preserve_sort_by(paths) { |ea| ea.basename.to_s }
+    end
 
-  # reverse the order of the sort
-  def self.reverse(paths)
-    paths.reverse
-  end
+    # reverse the order of the sort
+    def self.reverse(paths)
+      paths.reverse
+    end
 
-  def self.preserve_sort_by(array, &block)
-    ea_to_index = Hash[array.zip((0..array.size-1).to_a)]
-    array.sort_by do |ea|
-      [yield(ea), ea_to_index[ea]]
+    def self.preserve_sort_by(array, &block)
+      ea_to_index = Hash[array.zip((0..array.size-1).to_a)]
+      array.sort_by do |ea|
+        [yield(ea), ea_to_index[ea]]
+      end
     end
   end
 end

data/lib/findler/iterator.rb

@@ -1,56 +1,17 @@
-require 'bloomer'
-require 'pathname'
+require 'set'
+require 'forwardable'
 
 class Findler
-
   class Iterator
+    extend Forwardable
+    def_delegators :@configuration, :filter_paths
+    attr_reader :path
 
-    attr_reader :path, :parent, :patterns, :flags, :filters_class, :filters, :visited_dirs, :visited_files
-
-    def initialize(attrs, parent = nil)
-      @path = attrs[:path]
-      @path = Pathname.new(@path) unless @path.is_a? Pathname
-      @path = @path.expand_path unless @path.absolute?
-      @parent = parent
-
-      set_inheritable_ivar(:visited_dirs, attrs) { self.class.new_presence_collection }
-      set_inheritable_ivar(:visited_files, attrs) { self.class.new_presence_collection }
-      set_inheritable_ivar(:patterns, attrs) { nil }
-      set_inheritable_ivar(:flags, attrs) { 0 }
-      set_inheritable_ivar(:filters, attrs) { [] }
-      set_inheritable_ivar(:filters_class, attrs) { Filters }
-      set_inheritable_ivar(:sort_with, attrs) { nil }
-
-      @sub_iter = self.class.new(attrs[:sub_iter], self) if attrs[:sub_iter]
-    end
-
-    # Visit this directory and all sub directories, and check for unseen files. Only call on the root iterator.
-    def rescan!
-      raise Error, "Only invoke on root" unless @parent.nil?
-      @visited_dirs = self.class.new_presence_collection
-      @children = nil
-      @sub_iter = nil
-    end
-
-    def ignore_case?
-      (Findler::IGNORE_CASE & flags) > 0
-    end
-
-    def include_hidden?
-      (Findler::INCLUDE_HIDDEN & flags) > 0
-    end
-
-    def fnmatch_flags
-      @fnmatch_flags ||= (@parent && @parent.fnmatch_flags) || begin
-        f = 0
-        f |= File::FNM_CASEFOLD if ignore_case?
-        f |= File::FNM_DOTMATCH if include_hidden?
-        f
-      end
-    end
-
-    def path
-      @path
+    def initialize(findler, path, parent_iterator = nil)
+      @configuration = findler
+      @path = Path.clean(path).freeze
+      @parent = parent_iterator
+      @visited = []
     end
 
     def next_file
@@ -59,76 +20,40 @@ class Findler
       if @sub_iter
         nxt = @sub_iter.next_file
         return nxt unless nxt.nil?
-        @visited_dirs.add @sub_iter.path.to_s
+        mark_visited(@sub_iter.path)
         @sub_iter = nil
       end
 
-      # If someone touches the directory while we iterate, redo the @children.
-      @children = nil if @path.ctime != @ctime || @path.mtime != @mtime
-
-      if @children.nil?
-        @mtime = @path.mtime
-        @ctime = @path.ctime
-        children = @path.children.delete_if { |ea| skip?(ea) }
-        filtered_children = @filters.inject(children){ |c, f| filter(c, f) }
-        @children = filtered_children
-      end
-
-      nxt = @children.shift
+      nxt = next_visitable_child
       return nil if nxt.nil?
 
       if nxt.directory?
-        @sub_iter = Iterator.new({:path => nxt}, self)
+        @sub_iter = Iterator.new(@configuration, nxt, self)
         self.next_file
       else
-        @visited_files.add nxt.to_s
+        mark_visited(nxt)
         nxt
       end
     end
 
     private
 
-    def self.new_presence_collection
-      Bloomer::Scalable.new(256, 1.0/1_000_000)
-    end
-
-    def filter(children, filter_symbol)
-      filtered_children = filters_class.send(filter_symbol, children)
-      unless filtered_children.respond_to? :collect
-        raise Error, "#{path.to_s}: filter_with, must return an Enumerable"
-      end
-      children_as_pathnames = filtered_children.collect { |ea| ea.is_a?(Pathname) ? ea : Pathname.new(ea) }
-      illegal_children = children_as_pathnames - children
-      unless illegal_children.empty?
-        raise Error, "#{path.to_s}: filter_with returned unexpected paths: #{illegal_children.join(",")}"
+    def children
+      # If someone touches the directory while we iterate, redo the @children.
+      if @children.nil? || @mtime != @path.mtime || @ctime != @path.ctime
+        @mtime = @path.mtime
+        @ctime = @path.ctime
+        @children = filter_paths(@path.children)
       end
-      children_as_pathnames
+      @children
     end
 
-    # Sets the instance variable to the value in attrs[field].
-    # If attrs is missing a value, pull the value from the parent.
-    # If the parent doesn't have a value, use the block to generate a default.
-    def set_inheritable_ivar(field, attrs, &block)
-      v = attrs[field]
-      sym = "@#{field}".to_sym
-      v ||= parent.instance_variable_get(sym)
-      v ||= yield
-      instance_variable_set(sym, v)
+    def next_visitable_child
+      children.detect { |ea| !@visited.include?(Path.base(ea)) }
     end
 
-    def hidden?(pathname)
-      pathname.basename.to_s.start_with?(".")
-    end
-
-    def skip? pathname
-      s = pathname.to_s
-      return true if !include_hidden? && hidden?(pathname)
-      return visited_dirs.include?(s) if pathname.directory?
-      return true if visited_files.include?(s)
-      unless patterns.nil?
-        return true if patterns.none? { |p| pathname.fnmatch(p, fnmatch_flags) }
-      end
-      return false
+    def mark_visited(path)
+      @visited << Path.base(path)
     end
   end
 end

data/lib/findler/path.rb

@@ -0,0 +1,27 @@
+require 'pathname'
+
+class Findler
+  class Path
+    def self.clean(path)
+      path = Pathname.new(path) unless path.is_a? Pathname
+      path = path.expand_path unless path.absolute?
+      path
+    end
+
+    def self.base(path)
+      path.basename.to_s
+    end
+
+    def self.clean_array(array)
+      array.map { |ea| clean(ea) }
+    end
+
+    def self.base_array(array)
+      array.map { |ea| base(ea) }
+    end
+
+    def self.hidden?(path)
+      base(path).start_with?('.')
+    end
+  end
+end

data/lib/findler/version.rb

@@ -1,3 +1,3 @@
 class Findler
-  VERSION = "0.0.6"
-end
+  VERSION = Gem::Version.new("0.0.7")
+end

data/test/findler_test.rb

@@ -9,7 +9,7 @@ class Findler::Filters
   end
 
   def self.invalid_return(children)
-    "/invalid/file"
+    Pathname.new('/invalid/file')
   end
 
   def self.files_to_s(children)
@@ -23,107 +23,90 @@ describe Findler do
     `mkdir .hide ; touch .outer-hide dir-0/.hide .hide/normal.txt .hide/.secret`
   end
 
-  it "should detect hidden files properly" do
-    i = Findler::Iterator.new(:path => "/tmp")
-    i.send(:hidden?, Pathname.new("/a/b")).must_equal false
-    i.send(:hidden?, Pathname.new("/a/.b")).must_equal true
-    i.send(:hidden?, Pathname.new("/.a/.b")).must_equal true
-    i.send(:hidden?, Pathname.new("/.a/b")).must_equal false
-  end
-
-  it "should skip hidden files by default" do
-    i = Findler.new("/tmp").iterator
-    i.send(:skip?, Pathname.new("/tmp/not-hidden")).must_equal false
-    i.send(:skip?, Pathname.new("/tmp/.hidden")).must_equal true
+  it 'detects hidden files properly' do
+    %w(/a/b /.a/b).each do |ea|
+      p = Pathname.new(ea)
+      Findler::Path.hidden?(p).must_be_false
+    end
+    %w(/a/.b /a/.b).each do |ea|
+      p = Pathname.new(ea)
+      Findler::Path.hidden?(p).must_be_true
+    end
   end
 
-  it "should not skip hidden files when set" do
-    f = Findler.new("/tmp")
-    f.include_hidden!
-    i = f.iterator
-    i.send(:skip?, Pathname.new("/tmp/not-hidden")).must_equal false
-    i.send(:skip?, Pathname.new("/tmp/.hidden")).must_equal false
+  it 'skips hidden files by default' do
+    with_tmp_dir do |dir|
+      visible = (dir + rand_alphanumeric).tap { |ea| ea.touch }
+      hidden = (dir + ".#{rand_alphanumeric}").tap { |ea| ea.touch }
+      f = Findler.new(dir)
+      f.send(:viable_path?, visible).must_equal true
+      f.send(:viable_path?, hidden).must_equal false
+      f.include_hidden!
+      f.send(:viable_path?, visible).must_equal true
+      f.send(:viable_path?, hidden).must_equal true
+    end
   end
 
-  it "should find all non-hidden files by default" do
+  it 'finds all non-hidden files by default' do
     with_tree(%W(.jpg .txt)) do |dir|
       touch_secrets
       f = Findler.new(dir)
-      collect_files(f.iterator).sort.must_equal `find * -type f -not -name '.*'`.split.sort
+      collect_files(f.iterator).must_equal_contents `find * -type f -not -name '.*'`.split
       f.exclude_hidden! # should be a no-op
-      collect_files(f.iterator).sort.must_equal `find * -type f -not -name '.*'`.split.sort
+      collect_files(f.iterator).must_equal_contents `find * -type f -not -name '.*'`.split
       f.include_hidden!
-      collect_files(f.iterator).sort.must_equal `find . -type f | sed -e 's/^\\.\\///'`.split.sort
+      collect_files(f.iterator).must_equal_contents `find . -type f | sed -e 's/^\\.\\///'`.split
     end
   end
 
-  it "should find only .jpg files when constrained" do
+  it 'finds only .jpg files when constrained' do
     with_tree(%W(.jpg .txt .JPG)) do |dir|
       f = Findler.new(dir)
       f.add_extension ".jpg"
       if fs_case_sensitive?
         f.case_sensitive!
-        collect_files(f.iterator).sort.must_equal `find * -type f -name \\*.jpg`.split.sort
+        collect_files(f.iterator).must_equal_contents `find * -type f -name \\*.jpg`.split
       end
       f.case_insensitive!
-      collect_files(f.iterator).sort.must_equal `find * -type f -iname \\*.jpg`.split.sort
+      collect_files(f.iterator).must_equal_contents `find * -type f -iname \\*.jpg`.split
     end
   end
 
-  it "should find .jpg or .JPG files when constrained" do
-    with_tree(%W(.jpg .txt .JPG)) do |dir|
+  it 'finds .jpg or .JPG files when constrained' do
+    with_tree(%w(.jpg .txt .JPG)) do |dir|
       f = Findler.new(dir)
-      f.add_extension ".jpg"
+      f.add_extension '.jpg'
       f.case_insensitive!
       iter = f.iterator
-      collect_files(iter).sort.must_equal `find * -type f -iname \\*.jpg`.split.sort
+      collect_files(iter).must_equal_contents `find * -type f -iname \\*.jpg`.split
     end
   end
 
-  it "should find files added after iteration started" do
+  it 'finds files added after iteration started' do
     with_tree(%W(.txt)) do |dir|
       f = Findler.new(dir)
       iter = f.iterator
       iter.next_file.wont_be_nil
-
-      # cheating with mtime on the touch doesn't properly update the parent directory ctime,
-      # so we have to deal with the second-granularity resolution of the filesystem.
-      sleep(1.1)
-
-      FileUtils.touch(dir + "new.txt")
-      collect_files(iter).must_include("new.txt")
-    end
-  end
-
-  it "should find new files after a rescan" do
-    with_tree([".txt", ".no"]) do |dir|
-      f = Findler.new(dir)
-      f.add_extension ".txt"
-      iter = f.iterator
-      collect_files(iter).sort.must_equal `find * -type f -iname \\*.txt`.split.sort
-      FileUtils.touch(dir + "dir-0" + "dir-1" + "new-0.txt")
-      FileUtils.touch(dir + "dir-1" + "dir-0" + "new-1.txt")
-      FileUtils.touch(dir + "dir-2" + "dir-2" + "new-2.txt")
-      collect_files(iter).must_be_empty
-      iter.rescan!
-      collect_files(iter).sort.must_equal ["dir-0/dir-1/new-0.txt", "dir-1/dir-0/new-1.txt", "dir-2/dir-2/new-2.txt"]
+      sleep(1.1) # <- deal with the second-granularity resolution of the filesystem
+      (dir + 'new.txt').touch
+      collect_files(iter).must_include('new.txt')
     end
   end
 
-  it "should not return files removed after iteration started" do
-    with_tree([".txt"]) do |dir|
+  it 'should not return files removed after iteration started' do
+    with_tree(%w(.txt)) do |dir|
       f = Findler.new(dir)
       iter = f.iterator
       iter.next_file.wont_be_nil
-      sleep(1.1) # see above for hand-wringing-defense of this atrocity
-
-      (dir + "tmp-1.txt").unlink
+      sleep(1.1) # < make sure mtime change will be detected (which only has second resolution)
+      (dir + 'tmp-1.txt').unlink
       collect_files(iter).wont_include("tmp-1.txt")
     end
   end
 
-  it "should dump/load in the middle of iterating" do
-    with_tree(%W(.jpg .txt .JPG)) do |dir|
+
+  it 'dump/loads in the middle of iterating' do
+    with_tree(%w(.jpg .txt .JPG)) do |dir|
       all_files = `find * -type f -iname \\*.jpg`.split
       all_files.size.times do |i|
         f = Findler.new(dir)
@@ -131,19 +114,24 @@ describe Findler do
         f.case_insensitive!
         iter_a = f.iterator
         files_a = i.times.collect { relative_path(iter_a.path, iter_a.next_file) }
-        iter_b = Marshal.load(Marshal.dump(iter_a))
+        iter_b = marshal_round_trip(iter_a)
         files_b = collect_files(iter_b)
 
-        iter_c = Marshal.load(Marshal.dump(iter_b))
-        collect_files(iter_c)
-        iter_c.next_file.must_be_nil
+        files_a.wont_include_any files_b
+        files_b.wont_include_any files_a
+        (files_a + files_b).must_equal_contents all_files
+
+        # iter_b should be "exhausted" now.
+        collect_files(iter_b).must_be_empty
 
-        (files_a + files_b).sort.must_equal all_files.sort
+        # and "exhaustion" should survive marshalling:
+        iter_c = marshal_round_trip(iter_b)
+        collect_files(iter_c).must_be_empty
       end
     end
   end
 
-  it "should create an iterator even for a non-existent directory" do
+  it 'creates an iterator even for a non-existent directory' do
     tmpdir = nil
     Dir.mktmpdir do |dir|
       tmpdir = Pathname.new dir
@@ -153,7 +141,7 @@ describe Findler do
     collect_files(f.iterator).must_be_empty
   end
 
-  it "should raise an error if the block given to next_file returns nil" do
+  it 'raises an error if the block given to next_file returns nil' do
     Dir.mktmpdir do |dir|
       f = Findler.new(dir)
       f.add_filter :no_return
@@ -162,7 +150,7 @@ describe Findler do
     end
   end
 
-  it "should raise an error if the block returns non-children" do
+  it 'raises an error if the block returns non-children' do
     with_tree(%W(.txt)) do |dir|
       f = Findler.new(dir)
       f.add_filter :invalid_return
@@ -171,32 +159,31 @@ describe Findler do
     end
   end
 
-  it "should support filter_with against global/Kernel methods" do
+  it 'raises error when filter methods return strings' do
     with_tree(%W(.txt)) do |dir|
       f = Findler.new(dir)
       f.add_filter :files_to_s
-      iter = f.iterator
-      files = collect_files(iter)
-      files.sort.must_equal `find * -type f`.split.sort
+      i = f.iterator
+      lambda { i.next_file }.must_raise(Findler::Error)
     end
   end
 
-  it "should support next_file blocks properly" do
+  it 'supports next_file blocks properly' do
     with_tree(%W(.a .b)) do |dir|
       Dir["**/*.a"].each { |ea| File.open(ea, 'w') { |f| f.write("hello") } }
       f = Findler.new(dir)
       f.add_filter :non_empty_files
       iter = f.iterator
       files = collect_files(iter)
-      files.sort.must_equal `find * -type f -name \\*.a`.split.sort
+      files.must_equal_contents `find * -type f -name \\*.a`.split
     end
   end
 
-  it "should support files_first ordering" do
+  it 'supports files_first ordering' do
     with_tree(%W(.a), {
-        :depth => 2,
-        :files_per_dir => 2,
-        :subdirs_per_dir => 1,
+      :depth => 2,
+      :files_per_dir => 2,
+      :subdirs_per_dir => 1,
     }) do |dir|
       f = Findler.new(dir)
       f.add_filters([:order_by_name, :files_first])
@@ -207,11 +194,11 @@ describe Findler do
     end
   end
 
-  it "should support directory_first ordering" do
+  it 'supports directory_first ordering' do
     with_tree(%W(.a), {
-        :depth => 2,
-        :files_per_dir => 2,
-        :subdirs_per_dir => 1,
+      :depth => 2,
+      :files_per_dir => 2,
+      :subdirs_per_dir => 1,
     }) do |dir|
       f = Findler.new(dir)
       f.add_filters([:order_by_name, :directories_first])

data/test/minitest_helper.rb

@@ -1,11 +1,13 @@
-require 'minitest/spec'
-require 'minitest/reporters'
 require 'minitest/autorun'
+require 'minitest/great_expectations'
 require 'tmpdir'
 require 'fileutils'
 require 'findler'
 
-MiniTest::Reporters.use!
+unless ENV['CI']
+  require 'minitest/reporters'
+  MiniTest::Reporters.use!
+end
 
 def with_tmp_dir(&block)
   cwd = Dir.pwd
@@ -27,20 +29,20 @@ end
 
 def mk_tree(target_dir, options)
   opts = {
-      :depth => 3,
-      :files_per_dir => 3,
-      :subdirs_per_dir => 3,
-      :prefix => "tmp",
-      :suffix => "",
-      :dir_prefix => "dir",
-      :dir_suffix => ""
+    :depth => 3,
+    :files_per_dir => 3,
+    :subdirs_per_dir => 3,
+    :prefix => 'tmp',
+    :suffix => '',
+    :dir_prefix => 'dir',
+    :dir_suffix => ''
   }.merge options
   p = target_dir.is_a?(Pathname) ? target_dir : Pathname.new(target_dir)
   p.mkdir unless p.exist?
 
   opts[:files_per_dir].times do |i|
     fname = "#{opts[:prefix]}-#{i}#{opts[:suffix]}"
-    FileUtils.touch(p + fname).to_s
+    (p + fname).touch
   end
   return if (opts[:depth] -= 1) <= 0
   opts[:subdirs_per_dir].times do |i|
@@ -58,9 +60,15 @@ def relative_path(parent, pathname)
   pathname.relative_path_from(parent).to_s
 end
 
+def marshal_round_trip(iter)
+  output = "#{rand_alphanumeric}.ser"
+  File.open(output, 'wb') { |io| Marshal.dump(iter, io) }
+  Marshal.load(File.open(output, 'rb'))
+end
+
 def collect_files(iter)
   files = []
-  while nxt = iter.next_file
+  while (nxt = iter.next_file)
     files << relative_path(iter.path, nxt)
   end
   files
@@ -68,16 +76,25 @@ end
 
 def fs_case_sensitive?
   @fs_case_sensitive ||= begin
-    `touch CASETEST`
-    !File.exist?('casetest')
+    downcase = Pathname.new(rand_alphanumeric.downcase)
+    downcase.touch
+    upcase = Pathname.new(downcase.basename.to_s.upcase)
+    !upcase.exist?
   ensure
-    `rm CASETEST`
-  end
+    downcase.unlink
+  end.tap { |ea| puts "fs_case_sensitive = #{ea}" }
 end
 
-ALPHANUMERIC = (('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a).freeze
+ALPHANUMERIC = (('a'..'z').to_a + ('0'..'9').to_a).freeze
+
 def rand_alphanumeric(length = 10)
   (0..length).collect do
     ALPHANUMERIC[rand(ALPHANUMERIC.length)]
   end.join
 end
+
+class Pathname
+  def touch
+    FileUtils.touch(self.expand_path.to_s)
+  end
+end

metadata

@@ -1,20 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: findler
 version: !ruby/object:Gem::Version
-  version: 0.0.6
-  prerelease: 
+  version: 0.0.7
 platform: ruby
 authors:
 - Matthew McEachen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-30 00:00:00.000000000 Z
+date: 2013-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -22,7 +20,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -30,7 +27,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -38,7 +34,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -46,7 +41,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -54,15 +48,13 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest-reporters
+  name: minitest-great_expectations
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -70,23 +62,20 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bloomer
+  name: minitest-reporters
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -112,39 +101,33 @@ files:
 - lib/findler/error.rb
 - lib/findler/filters.rb
 - lib/findler/iterator.rb
+- lib/findler/path.rb
 - lib/findler/version.rb
 - test/filters_test.rb
 - test/findler_test.rb
 - test/minitest_helper.rb
 homepage: https://github.com/mceachen/findler/
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 1051954001939010091
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 1051954001939010091
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Findler is a stateful filesystem iterator
 test_files:
 - test/filters_test.rb