fynd 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,30 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fynd.gemspec
+gemspec
+
+group :test do
+  gem 'rake'
+end
+
+group :doc do
+  gem 'yard', '~> 0.8.2.1'
+  gem 'redcarpet', '~> 2.1.1'
+end
+
+group :test do
+  gem 'guard', '~> 1.3.2'
+  gem 'guard-rspec', '~> 1.2.1'
+  gem 'guard-spork', '~> 1.1.0'
+  gem 'rb-fsevent', '~> 0.9.1'
+  gem 'growl', '~> 1.0.3'
+  gem 'simplecov', '~> 0.6.4'
+  gem 'timecop', '~> 0.4.6'
+end
+
+# JSON
+# gem 'json', :platform => :jruby
+gem 'yajl-ruby', :platform => [ :ruby_18, :ruby_19 ]
+
+# OpenSSL
+gem 'jruby-openssl', :platform => :jruby

data/Guardfile

@@ -0,0 +1,13 @@
+ignore %r{^spec/fixtures/}
+
+guard 'rspec', :version => 2, :cli => "--color --format doc" do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+  watch(%r{^spec/support/.+.rb$}) { "spec" }
+end
+
+guard 'spork' do
+  watch('spec/spec_helper.rb')
+  watch(%r{^spec/support/.+.rb$}) { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Dan Ryan
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,55 @@
+# Fynd
+
+I found GNU find to be slow, so I made it slower.
+
+## Is it any good?
+
+[No.](http://news.ycombinator.com/item?id=3067434)
+
+## Installation
+
+    gem install fynd
+
+## Usage
+
+```ruby
+require 'fynd'
+include Fynd
+
+# `find /var/log -iname '*system*' -type f`
+
+find("/var/log").iname("system").type(:file).files
+
+=> ["/var/log/system.log", "/var/log/system.log.0.bz2", "/var/log/system.log.1.bz2", "/var/log/system.log.2.bz2", "/var/log/system.log.3.bz2", "/var/log/system.log.4.bz2", "/var/log/system.log.5.bz2", "/var/log/system.log.6.bz2", "/var/log/system.log.7.bz2"]
+```
+
+You can keep pass the files to a block [if you're a bad enough dude](http://i.imgur.com/x37pI.jpg).
+
+```ruby
+require 'fynd'
+include Fynd
+
+# `find /var/log -iname '*system` -type f -print
+
+find("/var/log").iname("system").type(:file).files do |file|
+  puts file
+end
+
+# Prints out:
+#   /var/log/system.log
+#   /var/log/system.log.0.bz2
+#   /var/log/system.log.1.bz2
+#   /var/log/system.log.2.bz2
+#   /var/log/system.log.3.bz2
+#   /var/log/system.log.4.bz2
+#   /var/log/system.log.5.bz2
+#   /var/log/system.log.6.bz2
+#   /var/log/system.log.7.bz2
+```
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/fynd.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fynd/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "fynd"
+  gem.version       = Fynd::VERSION
+  gem.authors       = ["Dan Ryan"]
+  gem.email         = ["scriptfu@gmail.com"]
+  gem.description   = %q{I found GNU find to be slow, so I made it slower.}
+  gem.summary       = %q{A pure Ruby re-implementation of GNU find.}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  
+  gem.add_dependency "activesupport", '~> 3.2.8'
+end

data/lib/fynd/actions.rb

@@ -0,0 +1,336 @@
+module Fynd::Actions
+  # Delete files; true if removal succeeded.  If the removal failed,
+  # an error message is issued.  Use of  this  action  automatically
+  # turns on the '-depth' option.
+  def delete
+  end
+
+  # Execute  command;  true  if 0 status is returned.  All following
+  # arguments to find are taken to be arguments to the command until
+  # an  argument  consisting of ';' is encountered.  The string '{}'
+  # is replaced by the current file name being processed  everywhere
+  # it occurs in the arguments to the command, not just in arguments
+  # where it is alone, as in some versions of find.  Both  of  these
+  # constructions might need to be escaped (with a '\') or quoted to
+  # protect them from expansion by the shell.  See the EXAMPLES sec-
+  # tion  for examples of the use of the '-exec' option.  The speci-
+  # fied command is run once for each matched file.  The command  is
+  # executed  in  the  starting  directory.  There are unavoidable
+  # security problems surrounding  use  of  the  -exec  option;  you
+  # should use the -execdir option instead.
+  #
+  # -exec command {} +
+  #
+  # This  variant  of the -exec option runs the specified command on
+  # the selected files, but the command line is built  by  appending
+  # each  selected file name at the end; the total number of invoca-
+  # tions of the command will  be  much  less  than  the  number  of
+  # matched  files. The command line is built in much the same way
+  # that xargs builds its command lines.  Only one instance of  '{}'
+  # is  allowed  within the command.  The command is executed in the
+  # starting directory.
+  def exec(command)
+  end
+
+  # Like -exec, but the specified command is run from the  subdirec-
+  # tory  containing  the  matched  file,  which is not normally the
+  # directory in which you started find.  This a  much  more  secure
+  # method  for invoking commands, as it avoids race conditions dur-
+  # ing resolution of the paths to the matched files.  As  with  the
+  # -exec option, the '+' form of -execdir will build a command line
+  # to process more than one matched file, but any given  invocation
+  # of command will only list files that exist in the same subdirec-
+  # tory.  If you use this option, you must ensure that  your  $PATH
+  # environment  variable  does not reference the current directory;
+  # otherwise, an attacker can run any commands they like by leaving
+  # an appropriately-named file in a directory in which you will run
+  # -execdir.
+  def execdir(command)
+  end
+
+  # True; like -ls but write to file like -fprint.  The output  file
+  # is  always created, even if the predicate is never matched.  See
+  # the UNUSUAL FILENAMES section for information about how  unusual
+  # characters in filenames are handled.
+  def fls(file)
+  end
+
+  # True; print the full file name into file file.  If file does not
+  # exist when find is run, it is created; if it does exist,  it  is
+  # truncated.   The  file names ''/dev/stdout'' and ''/dev/stderr''
+  # are handled specially; they refer to  the  standard  output  and
+  # standard  error output, respectively.  The output file is always
+  # created, even if  the  predicate  is  never  matched.   See  the
+  # UNUSUAL  FILENAMES  section  for  information  about how unusual
+  # characters in filenames are handled.
+  def fprint(file)
+  end
+
+  # True; like -print0 but write to file like -fprint.   The  output
+  # file  is always created, even if the predicate is never matched.
+  # See the UNUSUAL FILENAMES  section  for  information  about  how
+  # unusual characters in filenames are handled.
+  def fprint0(file)
+  end
+
+  # True;  like  -printf but write to file like -fprint.  The output
+  # file is always created, even if the predicate is never  matched.
+  # See  the  UNUSUAL  FILENAMES  section  for information about how
+  # unusual characters in filenames are handled.
+  def fprintf(file, format)
+  end
+
+  # Like -exec but ask the user first (on the  standard  input);  if
+  # the response does not start with 'y' or 'Y', do not run the com-
+  # mand, and return false.  If the command  is  run,  its  standard
+  # input is redirected from /dev/null.
+  def ok(command)
+  end
+
+  # Like -execdir but ask the user first (on the standard input); if
+  # the response does not start with 'y' or 'Y', do not run the com-
+  # mand,  and  return  false.   If the command is run, its standard
+  # input is redirected from /dev/null.
+  def okdir(command)
+  end
+
+  # Print the full file name on the standard output, followed
+  # by a newline.   If you  are  piping  the  output  of  find  into
+  # another  program  and there is the faintest possibility that the
+  # files which you are searching for might contain a newline,  then
+  # you should seriously consider using the '-print0' option instead
+  # of '-print'.  See the UNUSUAL FILENAMES section for  information
+  # about how unusual characters in filenames are handled.
+  def print
+
+  end
+
+  # Print the full file name on the standard output,  followed
+  # by  a  null  character  (instead  of  the newline character that
+  # '-print' uses).  This allows file names that contain newlines or
+  # other  types  of white space to be correctly interpreted by pro-
+  # grams that process the find output.  This option corresponds  to
+  # the '-0' option of xargs.
+  def print0
+  end
+
+  # Print  format  on  the  standard output, interpreting '\'
+  # escapes and '%' directives.  Field widths and precisions can  be
+  # specified  as  with  the  'printf' C function.  Please note that
+  # many of the fields are printed as %s rather than  %d,  and  this
+  # may  mean  that flags don't work as you might expect.  This also
+  # means that the '-' flag does work (it forces fields to be  left-
+  # aligned).   Unlike -print, -printf does not add a newline at the
+  # end of the string.  The escapes and directives are:
+  # 
+  # \a     Alarm bell.
+  # 
+  # \b     Backspace.
+  # 
+  # \c     Stop printing from this format immediately and flush  the
+  #  output.
+  # 
+  # \f     Form feed.
+  # 
+  # \n     Newline.
+  # 
+  # \r     Carriage return.
+  # 
+  # \t     Horizontal tab.
+  # 
+  # \v     Vertical tab.
+  # 
+  # \      ASCII NUL.
+  # 
+  # \\     A literal backslash ('\').
+  # 
+  # \NNN   The character whose ASCII code is NNN (octal).
+  # 
+  # A '\' character followed by any other character is treated as an
+  # ordinary character, so they both are printed.
+  # 
+  # %%     A literal percent sign.
+  # 
+  # %a     File's last access time in the format returned by  the  C
+  #  'ctime' function.
+  # 
+  # %Ak    File's  last  access  time  in the format specified by k,
+  #  which is either '@' or a directive for the  C  'strftime'
+  #  function.   The  possible  values for k are listed below;
+  #  some of them might not be available on all  systems,  due
+  #  to differences in 'strftime' between systems.
+  # 
+  #   @      seconds since Jan. 1, 1970, 00:00 GMT.
+  # 
+  #  Time fields:
+  # 
+  #   H     hour (00..23)
+  # 
+  #   I     hour (01..12)
+  # 
+  #   k     hour ( 0..23)
+  # 
+  #   l     hour ( 1..12)
+  # 
+  #   M     minute (00..59)
+  # 
+  #   p     locale's AM or PM
+  # 
+  #   r     time, 12-hour (hh:mm:ss [AP]M)
+  # 
+  #   S     second (00..61)
+  # 
+  #   T     time, 24-hour (hh:mm:ss)
+  # 
+  #   +     Date  and  time,  separated  by  '+', for example
+  #         '2004-04-28+22:22:05'.  The time is given in  the
+  #         current  timezone  (which may be affected by set-
+  #         ting the TZ environment variable).  This is a GNU
+  #         extension.
+  # 
+  #   X     locale's time representation (H:M:S)
+  # 
+  #   Z     time zone (e.g., EDT), or nothing if no time zone
+  #         is determinable
+  # 
+  #  Date fields:
+  # 
+  #   a     locale's abbreviated weekday name (Sun..Sat)
+  # 
+  #   A     locale's full weekday name, variable length (Sun-
+  #         day..Saturday)
+  # 
+  #   b     locale's abbreviated month name (Jan..Dec)
+  # 
+  #   B     locale's  full  month name, variable length (Jan-
+  #         uary..December)
+  # 
+  #   c     locale's date and time (Sat Nov 04  12:02:33  EST
+  #         1989)
+  # 
+  #   d     day of month (01..31)
+  # 
+  #   D     date (mm/dd/yy)
+  # 
+  #   h     same as b
+  # 
+  #   j     day of year (001..366)
+  # 
+  #   m     month (01..12)
+  # 
+  #   U     week  number  of year with Sunday as first day of
+  #         week (00..53)
+  # 
+  #   w     day of week (0..6)
+  # 
+  #   W     week number of year with Monday as first  day  of
+  #         week (00..53)
+  # 
+  #   x     locale's date representation (mm/dd/yy)
+  # 
+  #   y     last two digits of year (00..99)
+  # 
+  #   Y     year (1970...)
+  # 
+  # %b    The  amount  of disk space used for this file in 512-byte
+  #       blocks. Since disk space is allocated in multiples of the
+  #       filesystem  block  size  this  is  usually  greater  than
+  #       %s/1024, but it can also be smaller  if  the  file  is  a
+  #       sparse file.
+  # 
+  # %c    File's  last status change time in the format returned by
+  #       the C 'ctime' function.
+  # 
+  # %Ck   File's last status change time in the format specified by
+  #       k, which is the same as for %A.
+  # 
+  # %d    File's depth in the directory tree; 0 means the file is a
+  #       command line argument.
+  # 
+  # %D    The device number on which the file  exists  (the  st_dev
+  #       field of struct stat), in decimal.
+  # 
+  # %f    File's  name  with  any leading directories removed (only
+  #       the last element).
+  # 
+  # %F    Type of the filesystem the file is on; this value can  be
+  #       used for -fstype.
+  # 
+  # %g    File's  group  name, or numeric group ID if the group has
+  #       no name.
+  # 
+  # %G    File's numeric group ID.
+  # 
+  # %h    Leading directories of file's name (all but the last ele-
+  #       ment).  If the file name contains no slashes (since it is
+  #       in the current directory) the  %h  specifier  expands  to
+  #       ".".
+  # 
+  # %H    Command line argument under which file was found.
+  # 
+  # %i    File's inode number (in decimal).
+  # 
+  # %k    The amount of disk space used for this file in 1K blocks.
+  #       Since  disk  space  is  allocated  in  multiples  of  the
+  #       filesystem  block  size  this  is  usually  greater  than
+  #       %s/1024, but it can also be smaller  if  the  file  is  a
+  #       sparse file.
+  # 
+  # %l    Object  of  symbolic  link (empty string if file is not a
+  #       symbolic link).
+  # 
+  # %m    File's permission bits (in octal).  This option uses  the
+  #       'traditional'  numbers  which  most  Unix implementations
+  #       use,  but  if  your  particular  implementation  uses  an
+  #       unusual  ordering of octal permissions bits, you will see
+  #       a difference between the actual value of the file's  mode
+  #       and  the output of %m.   Normally you will want to have a
+  #       leading zero on this number, and to do this,  you  should
+  #       use the # flag (as in, for example, '%#m').
+  # 
+  # %M    File's  permissions  (in symbolic form, as for ls).  This
+  #       directive is supported in findutils 4.2.5 and later.
+  # 
+  # %n    Number of hard links to file.
+  # 
+  # %p    File's name.
+  # 
+  # %P    File's name with the name of the  command  line  argument
+  #       under which it was found removed.
+  # 
+  # %s    File's size in bytes.
+  # 
+  # %t    File's  last  modification time in the format returned by
+  #       the C 'ctime' function.
+  # 
+  # %Tk   File's last modification time in the format specified  by
+  #       k, which is the same as for %A.
+  # 
+  # %u    File's  user  name, or numeric user ID if the user has no
+  #       name.
+  # 
+  # %U    File's numeric user ID.
+  # 
+  # %y    File's type (like in ls -l),  U=unknown  type  (shouldn't
+  #       happen)
+  # 
+  # %Y    File's  type  (like  %y),  plus  follow symlinks: L=loop,
+  #       N=nonexistent
+  # 
+  # %Z    (SELinux only) file's security context.
+  # 
+  # A '%' character followed by any  other  character  is  discarded
+  # (but the other character is printed).
+  # 
+  # The  %m and %d directives support the # , 0 and + flags, but the
+  # other directives do not, even if they  print  numbers.   Numeric
+  # directives that do not support these flags include G, U, b, D, k
+  # and n.  The '-' format flag is supported and changes the  align-
+  # ment  of  a field from right-justified (which is the default) to
+  # left-justified.
+  # 
+  # See the UNUSUAL FILENAMES  section  for  information  about  how
+  # unusual characters in filenames are handled.
+  def printf(format)
+  end
+end

data/lib/fynd/criteria.rb

@@ -0,0 +1,75 @@
+require 'forwardable'
+require 'find' # <- lol
+
+require 'fynd/sieve'
+
+module Fynd
+  class Criteria
+    extend Forwardable
+
+    attr_accessor :sieve
+    
+    def_delegators :@sieve, :collection, :conditions
+    
+    def initialize(*paths)
+      @sieve = Sieve.new
+      @sieve.collection = []      
+      @sieve.conditions = {}
+      @sieve.conditions['actions'] = {}
+      @sieve.conditions['operators'] = {}
+      @sieve.conditions['tests'] = {}
+      
+      # For every path...
+      paths.each do |path|
+        # Pull out all directories
+        # dirs = Dir.glob(File.expand_path(path)).select { |f| File.stat(f).directory? }
+        # Shove all found files into the collection
+        # @sieve.collection << Dir.glob(File.expand_path(path))
+        @sieve.collection << Find.find(path).to_a
+      end
+      
+      # Flatten it and strip out non-unique files
+      @sieve.collection.flatten!.uniq!
+    end
+
+    # def find(*paths)
+    #   where(:paths => paths)
+    #   self
+    # end
+    
+    def run
+      sieve.run
+      return sieve.files
+    end
+    
+    def files
+      files = sieve.run
+      
+      if block_given?
+        yield files
+      else
+        return files
+      end
+    end
+    
+    def method_missing(symbol, *args, &block)
+      if sieve.respond_to?(symbol)
+        if ACTIONS.include?(symbol)
+          # Only one action per expression
+          sieve.conditions['action'] = { symbol.to_s => args[0] }
+        elsif OPERATORS.include?(symbol)
+          sieve.conditions['operations'].deep_merge!({ symbol.to_s => args[0] })
+        elsif TESTS.include?(symbol)
+          sieve.conditions['tests'].deep_merge!({ symbol.to_s => args[0] })
+        else
+          super(symbol, *args, &blocks)
+        end
+        self
+      else
+        super(symbol, *args, &blocks)
+      end
+    end
+    
+    # TODO: implement enumerables; all, first, each, etc.
+  end
+end

data/lib/fynd/helpers.rb

@@ -0,0 +1,3 @@
+module Fynd::Helpers
+
+end

data/lib/fynd/operators.rb

@@ -0,0 +1,10 @@
+module Fynd::Operators
+  def not(expr)
+  end
+
+  def and(expr)
+  end
+
+  def or(expr)
+  end
+end

data/lib/fynd/sieve.rb

@@ -0,0 +1,34 @@
+require 'forwardable'
+
+require 'fynd/actions'
+require 'fynd/operators'
+require 'fynd/tests'
+require 'fynd/helpers'
+
+module Fynd
+  class Sieve
+    include Helpers
+    include Actions
+    include Operators
+    include Tests
+        
+    attr_accessor :collection, :conditions, :files
+    
+    def initialize
+      @collection = []
+      @conditions = {}
+      @files = nil
+    end
+
+    def run
+      @files = collection.dup
+      # first we match files with our tests 
+      conditions['tests'].each do |symbol, value|
+        value.nil? ? self.__send__(symbol) : self.__send__(symbol, value)
+      end
+      
+      @files
+    end
+    
+  end
+end

data/lib/fynd/tests.rb

@@ -0,0 +1,357 @@
+require 'etc'
+
+module Fynd::Tests
+  # Numeric arguments can be specified as
+  # 
+  # +n     for greater than n,
+  # 
+  # -n     for less than n,
+  # 
+  # n      for exactly n.
+  
+  # File was last accessed n minutes ago.
+  def amin(n)
+  end
+
+  # File was last accessed more recently than file was modified. If
+  # file is a symbolic link and the -H option or the -L option is in
+  # effect, the access time of the file it points to is always used.
+  def anewer(other)
+    files.select! do |file|
+      File.stat(file).atime > File.stat(other).atime
+    end
+  end
+
+  # File was last accessed n*24 hours ago. When find figures out
+  # how many 24-hour periods ago the file was last accessed, any
+  # fractional part is ignored, so to match -atime +1, a file has to
+  # have been accessed at least two days ago.
+  def atime(n)
+    match = n.match(/([-+]?)(\d+)/)
+    comparer, interval = match[1], match[2].to_i
+    time = Time.now    
+    
+    files.select! do |file|
+      atime = File.stat(file).atime
+      
+      case comparer
+      when '+'
+        # more than n days ago
+        atime < time - interval.days
+      when '-'
+        # less than n days ago
+        atime > time - interval.days
+      when ''
+        # exactly n days ago
+        atime <= time - (interval - 1).days && atime >= time - interval.days
+      else
+        raise ArgumentError, "argument must be n, +n, or -n"
+      end    
+    end
+  end
+
+  # File's status was last changed n minutes ago.
+  def cmin(n)
+  end
+
+  # File's status was last changed more recently than file was modi-
+  # fied. If file is a symbolic link and the -H option or the -L
+  # option is in effect, the status-change time of the file it
+  # points to is always used.
+  def cnewer(other)
+    files.select! do |file|
+      File.stat(file).ctime > File.stat(other).ctime
+    end
+  end
+
+  # File's status was last changed n*24 hours ago. See the comments
+  # for -atime to understand how rounding affects the interpretation
+  # of file status change times.
+  def ctime(n)
+  end
+
+  # File is empty and is either a regular file or a directory.
+  def empty
+    files.select! do |file|
+      File.stat(file).zero?
+    end
+  end
+
+  alias :empty? :empty
+
+  # Always false.
+  def false
+    # false
+  end
+
+  alias :false? :false
+
+  # File's numeric group ID is n.
+  def gid(n)
+    files.select! do |file|
+      File.stat(file).gid == n.to_i
+    end
+  end
+
+  # File belongs to group gname (numeric group ID allowed).
+  def group(name)
+    files.select! do |file|
+      gid = File.stat(file).gid
+      Etc.getgrgid(gid).name == name
+    end
+  end
+
+  # Like -lname, but the match is case insensitive.  If the -L
+  # option or the -follow option is in effect, this test returns
+  # false unless the symbolic link is broken.
+  def ilname(pattern)
+  end
+
+  # Like -name, but the match is case insensitive. For example, the
+  # patterns 'fo*' and 'F??' match the file names 'Foo', 'FOO',
+  # 'foo', 'fOo', etc.  In these patterns, unlike filename expan-
+  # sion by the shell, an initial '.' can be matched by '*'. That
+  # is, find -name *bar will match the file '.foobar'.  Please note
+  # that you should quote patterns as a matter of course, otherwise
+  # the shell will expand any wildcard characters in them.
+  def iname(pattern)
+    files.select! do |file|
+      file =~ /#{pattern}/i
+    end
+  end
+
+  # File has inode number n. It is normally easier to use the
+  # -samefile test instead.
+  def inum(n)
+    files.select! do |file|
+      File.stat(file).ino == n.to_i
+    end
+  end
+
+  # Like -regex, but the match is case insensitive.
+  def iregex(pattern)
+  end
+
+  # Like -wholename, but the match is case insensitive.
+  def iwholename(pattern)
+  end
+
+  # File has n links.
+  def links(n)
+  end
+
+  # File is a symbolic link whose contents match shell pattern pat-
+  # tern. The metacharacters do not treat '/' or '.' specially. If
+  # the -L option or the -follow option is in effect, this test
+  # returns false unless the symbolic link is broken.
+  def lname(pattern)
+  end
+
+  # File's data was last modified n minutes ago.
+  def mmin(n)
+  end
+
+  # File's data was last modified n*24 hours ago. See the comments
+  # for -atime to understand how rounding affects the interpretation
+  # of file modification times.
+  def mtime(n)
+  end
+
+  # Base of file name (the path with the leading directories
+  # removed) matches shell pattern pattern.  The metacharacters
+  # ('*', '?', and '[]') match a '.' at the start of the base name
+  # (this is a change in findutils-4.2.2; see section STANDARDS CON-
+  # FORMANCE below). To ignore a directory and the files under it,
+  # use -prune; see an example in the description of -wholename.
+  # Braces are not recognised as being special, despite the fact
+  # that some shells including Bash imbue braces with a special
+  # meaning in shell patterns. The filename matching is performed
+  # with the use of the fnmatch(3) library function.  Don't forget
+  # to enclose the pattern in quotes in order to protect it from
+  # expansion by the shell.
+  def name(pattern)
+    files.select! do |file|
+      file =~ /#{pattern}/
+    end
+  end
+
+  # File was modified more recently than file. If file is a sym-
+  # bolic link and the -H option or the -L option is in effect, the
+  # modification time of the file it points to is always used.
+  def newer(other)
+  end
+
+  # No user corresponds to file's numeric user ID.
+  def nouser
+    files.select! do |file|
+      uid = File.stat(file).uid
+      begin
+        Etc.getpwuid(uid)
+        false
+      rescue ArgumentError => e
+        true
+      end
+    end
+  end
+
+  # No group corresponds to file's numeric group ID.
+  def nogroup
+    files.select! do |file|
+      gid = File.stat(file).gid
+      begin
+        Etc.getgrgid(gid)
+        false
+      rescue ArgumentError => e
+        true
+      end
+    end
+  end
+
+  # See -wholename. The predicate -path is also supported by HP-UX find.
+  def path(pattern)
+  end
+
+  # -perm mode
+  #
+  # File's permission bits are exactly mode (octal or symbolic).
+  # Since an exact match is required, if you want to use this form
+  # for symbolic modes, you may have to specify a rather complex
+  # mode string. For example '-perm g=w' will only match files
+  # which have mode 0020 (that is, ones for which group write per-
+  # mission is the only permission set). It is more likely that you
+  # will want to use the '/' or '-' forms, for example '-perm -g=w',
+  # which matches any file with group write permission.  See the
+  # EXAMPLES section for some illustrative examples.
+  #
+  # -perm -mode
+  #
+  # All of the permission bits mode are set for the file. Symbolic
+  # modes are accepted in this form, and this is usually the way in
+  # which would want to use them. You must specify 'u', 'g' or 'o'
+  # if you use a symbolic mode.  See the EXAMPLES section for some
+  # illustrative examples.
+  # 
+  # -perm /mode
+  #
+  # Any of the permission bits mode are set for the file. Symbolic
+  # modes are accepted in this form. You must specify 'u', 'g' or
+  # 'o' if you use a symbolic mode. See the EXAMPLES section for
+  # some illustrative examples. If no permission bits in mode are
+  # set, this test currently matches no files. However, it will
+  # soon be changed to match any file (the idea is to be more con-
+  # sistent with the behaviour of perm -000).
+  def perm(mode)
+  end
+
+  # File name matches regular expression pattern. This is a match
+  # on the whole path, not a search. For example, to match a file
+  # named './fubar3', you can use the regular expression '.*bar.' or
+  # '.*b.*3', but not 'f.*r3'. The regular expressions understood
+  # by find are by default Emacs Regular Expressions, but this can
+  # be changed with the -regextype option.
+  def regex(pattern)
+  end
+
+  # File refers to the same inode as name.  When -L is in effect,
+  # this can include symbolic links.
+  def samefile(other)
+  end
+
+  # File uses n units of space. The following suffixes can be used:
+  # 
+  # 'b'  for 512-byte blocks (this is the default if no suffix is
+  #    used)
+  # 
+  # 'c'  for bytes
+  # 
+  # 'w'  for two-byte words
+  # 
+  # 'k'  for Kilobytes (units of 1024 bytes)
+  # 
+  # 'M'  for Megabytes (units of 1048576 bytes)
+  # 
+  # 'G'  for Gigabytes (units of 1073741824 bytes)
+  # 
+  # The size  does not count indirect blocks, but it does count
+  # blocks in sparse files that are not actually allocated. Bear in
+  # mind that the '%k' and '%b' format specifiers of -printf handle
+  # sparse files differently.  The  'b' suffix always  denotes
+  # 512-byte blocks and never 1 Kilobyte blocks, which is different
+  # to the behaviour of -ls.
+  def size(n)
+  end
+
+  # Always true.
+  def true
+  end
+
+  # File is of type c:
+  # 
+  # b   block (buffered) special
+  # c   character (unbuffered) special
+  # d   directory
+  # p   named pipe (FIFO)
+  # f   regular file
+  # l   symbolic link; this is never true if the -L option or the
+  #     -follow option is in effect, unless the symbolic link is
+  #     broken. If you want to search for symbolic links when -L
+  #     is in effect, use -xtype.
+  # s   socket
+  # D   door (Solaris)
+  def type(c)
+    files.select! do |file|
+      case c.to_s
+      when 'f', 'file'
+        File.stat(file).file?
+      when 'd', 'dir', 'directory'
+        File.stat(file).directory?
+      else
+        false
+      end
+    end
+  end
+
+  # File's numeric user ID is n.
+  def uid(n)
+    files.select! do |file|
+      File.stat(file).uid == n.to_i
+    end
+  end
+
+  # File was last accessed n days after its status was last changed.
+  def used(n)
+  end
+
+  # File is owned by user uname (numeric user ID allowed).
+  def user(name)
+    files.select! do |file|
+      uid = File.stat(file).uid.to_i
+      Etc.getpwuid(uid).name == name
+    end
+  end
+
+  # File name matches shell pattern pattern. The metacharacters do
+  # not treat '/' or '.' specially; so, for example,
+  #   
+  #   find . -wholename './sr*sc'
+  #
+  # will print an entry for a directory called './src/misc' (if one
+  # exists). To ignore a whole directory tree, use -prune rather
+  # than checking every file in the tree. For example, to skip the
+  # directory 'src/emacs' and all files and directories under it,
+  # and print the names of the other files found, do something like
+  # this:
+  # 
+  #   find . -wholename './src/emacs' -prune -o -print
+  #
+  def wholename(pattern)
+  end
+
+  # The same as -type unless the file is a symbolic link. For sym-
+  # bolic links: if the -H or -P option was specified, true if the
+  # file is a link to a file of type c; if the -L option has been
+  # given, true if c is 'l'. In other words, for symbolic links,
+  # -xtype checks the type of the file that -type does not check.
+  def xtype(c)
+  end
+end

data/lib/fynd/version.rb

@@ -0,0 +1,3 @@
+module Fynd
+  VERSION = "0.1.0"
+end

data/lib/fynd.rb

@@ -0,0 +1,22 @@
+require 'active_support/all'
+
+require 'fynd/version'
+
+require 'fynd/actions'
+require 'fynd/operators'
+require 'fynd/tests'
+
+require 'fynd/criteria'
+
+module Fynd  
+  ACTIONS = Fynd::Actions.instance_methods
+  OPERATORS = Fynd::Operators.instance_methods
+  TESTS = Fynd::Tests.instance_methods
+  
+  extend self
+  
+  def find(*paths)
+    Criteria.new(*paths)
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'spork'
+
+Spork.prefork do
+  $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+  $LOAD_PATH.unshift(File.dirname(__FILE__))
+  require 'bundler'
+  Bundler.require
+
+  require 'rspec'
+  require 'timecop'
+  # require 'fakefs'
+  require 'fileutils'
+  
+  require 'fynd'
+  
+  RSpec.configure do |config|
+    config.before do
+      Timecop.freeze
+      # FakeFS.activate!
+    end
+    config.after do
+      Timecop.return
+      # FakeFS.deactivate!
+    end
+  end
+end
+
+Spork.each_run do
+  # This code will be run each time you run your specs.
+  Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+end
+
+# Crash loud in tests!
+Thread.abort_on_exception = true

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: fynd
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Dan Ryan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.8
+description: I found GNU find to be slow, so I made it slower.
+email:
+- scriptfu@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- fynd.gemspec
+- lib/fynd.rb
+- lib/fynd/actions.rb
+- lib/fynd/criteria.rb
+- lib/fynd/helpers.rb
+- lib/fynd/operators.rb
+- lib/fynd/sieve.rb
+- lib/fynd/tests.rb
+- lib/fynd/version.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+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: -1732080129686787563
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1732080129686787563
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A pure Ruby re-implementation of GNU find.
+test_files:
+- spec/spec_helper.rb
+has_rdoc: