fun_with_files 0.0.14 → 0.0.18

data/lib/fun_with/files/watcher.rb

@@ -0,0 +1,157 @@
+# You want to watch a list of files or directories for changes 
+# (files created, deleted, or modified), and then return a... list?
+# of changes.  
+#
+# Tricky part is, what constitutes a "change" for a directory.
+# or a file, for that matter.
+#
+# Cool expansion: customize the sorts of changes that trigger actions.
+# You can already do that to some extent with the user-code that the
+# change list is delivered to
+#
+# usr/ (modified, watched)
+#   bin/ (modified)
+#     new_directory/ (created)
+#       README.txt (created)
+#     bash (unchanged)
+#     
+#   lib/ (modified)
+#     libgpg.so (unchanged)
+#     libmysql.so (deleted)
+#     libzip.so (modified)
+#     libjpeg.so  (file_created)
+#     you_have_been_hacked_by_chinese.txt (file_created)
+#  cache/ (deleted)
+#    firefox/ (deleted)
+#      cached_item.jpg (deleted)
+#      cached_folder/ (deleted)
+#        cache_file.csv (deleted)
+#
+# When you find a change in a subdirector/file, the :modified status 
+# propagates up the tree.
+# Feels like a job for a visitor.
+#
+# If you create the top-level watcher, it could create any sub-watchers 
+# for the files and folders.  It asks its watchers to update their 
+# statuses and report back.
+#
+# But the top-level one should know that it's the top level, so it
+# shouldn't be deleting its watchers that might be, for example, 
+# waiting for a file to come into being. 
+#
+# Hence, anyone using this code probably ought to stick to using the main Watcher
+# class, and not worry about the ones it uses in the background
+#
+# Filters can be added
+module FunWith
+  module Files
+    class Watcher
+      def self.watch( *paths, interval: 1.0, notice: [], ignore: [], &block )
+        watcher = self.new( paths ).sleep_interval( interval ).filter( notice: notice, ignore: ignore )
+        
+        if block_given?
+          watcher.watch( &block )
+        else
+          watcher
+        end
+      end
+      
+      def self.factory( path )
+        path = path.fwf_filepath
+        
+        if path.exist?
+          if path.directory?
+            Watchers::DirectoryWatcher.new( path )
+          elsif path.file?
+            Watchers::FileWatcher.new( path )
+          end
+        else
+          Watchers::MissingWatcher.new( path )
+        end
+      end
+      
+      def initialize( paths )
+        @sleep_interval = 1.0
+        @notice_filters = []
+        @ignore_filters = []
+        
+        # Create a watcher for every single thing that we're
+        # asking it to watch
+        @watchers = paths.inject({}) do |watchers, path|
+          watchers[path.fwf_filepath] = self.class.factory( path )
+          watchers
+        end
+      end
+      
+      def sleep_interval( i )
+        @sleep_interval = i
+        self
+      end
+      
+      def watch( &block )
+        while true
+          sleep( @sleep_interval )
+          yield self.update
+        end
+      end
+      
+      def filter( notice: [], ignore: [] )
+        @notice_filters += [notice].flatten
+        @ignore_filters += [ignore].flatten
+        
+        self
+      end
+      
+      # returns a hash of the changes that have happened in the file system being monitored,
+      def update
+        {}.tap do |changes|
+          for path, watcher in @watchers
+            changes.merge!( watcher.update )
+            replace_watcher( path, changes[path] )  # a DirectoryWatcher might need to be replaced with a MissingWatcher, for example, or vice-versa
+            
+            # corner case: if a directory is created, everything created under the directory
+            # is deemed to have also been created at the same time
+            if path.directory? && changes[path] == :created
+              changes.merge!( path.glob(:all).inject({}){ |memo,path| memo[path] = :created ; memo } )
+            end
+          end
+          
+          apply_filters( changes )
+        end
+      end
+      
+      def replace_watcher( path, change )
+        case change
+        when nil
+          # didn't change
+        when :deleted, :created
+          @watchers[path] = self.class.factory( path )
+        end
+      end
+      
+      # 
+      def apply_filters( changes )
+        apply_notice_filters( changes )
+        apply_ignore_filters( changes )
+        changes
+      end
+      
+      def apply_notice_filters( changes )
+        for filter in @notice_filters
+          for path in changes.keys
+            changes.delete( path ) if path !~ filter
+          end
+        end
+      end
+      
+      def apply_ignore_filters( changes )
+        for filter in @ignore_filters
+          for path in changes.keys
+            changes.delete( path ) if path =~ filter
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/fun_with/files/watchers/directory_watcher.rb

@@ -0,0 +1,67 @@
+module FunWith
+  module Files
+    module Watchers
+      class DirectoryWatcher < NodeWatcher
+        def initialize( path )
+          set_path( path )
+          @watchers = create_watchers( self.path.entries )
+        end
+      
+      
+        # returns a hash of changes
+        def update
+          new_changeset do
+            if self.path.exist?
+              update_existing_files
+              find_new_files
+            else
+              # If the directory is gone, you can assume the same is true
+              # for all the files it held.  
+              report_files( self.all_paths, :deleted )
+            end
+          end
+        end
+      
+        def update_existing_files
+          # first, check on the files we're supposed to be keeping track of
+          for path, watcher in @watchers
+            @changes[path] = :deleted unless path.exist?
+            @changes.merge!( watcher.update )
+          
+            # While the main Watcher will continue to monitor the places it's
+            # been told, even if they're missing, the subwatchers just disappear
+            # when the files they're watching do.
+            @watchers.delete( path ) unless path.exist?
+          end
+        end
+      
+        def find_new_files
+          # next, get the updated list of files/folders beneath this directory
+          current_paths = self.path.entries
+        
+          for path in current_paths
+            unless @watchers.has_key?( path )
+              w = Watcher.factory( path )
+            
+              report_files( w.all_paths, :created )
+
+              @watchers[path] = w
+            end
+          end
+        end
+      
+        # modify the current list of changes by adding "deleted" for 
+        # every file/folder below this one.
+        def report_files( paths, status )  
+          for path in paths
+            @changes[path] = status
+          end 
+        end
+      
+        def all_paths
+          @watchers.map{|path, watcher| watcher.all_paths }.flatten + [self.path]
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/files/watchers/file_watcher.rb

@@ -0,0 +1,45 @@
+   
+module FunWith
+  module Files
+    module Watchers
+      class FileWatcher < NodeWatcher
+        attr_accessor :last_modified
+      
+        def initialize( path )
+          set_path( path )
+          refresh_last_modified
+        end
+      
+        def refresh_last_modified
+          self.last_modified = self.path.stat.mtime if self.path.exist?
+        end
+      
+        def modified?
+          self.path.exist? && self.last_modified < self.path.stat.mtime
+        end
+      
+        def deleted?
+          ! self.path.exist?
+        end
+      
+        def update
+          if deleted?
+            { self.path => :deleted }
+          elsif modified?
+            refresh_last_modified
+            { self.path => :modified }
+          else
+            {}
+          end
+        end
+        
+        # returns all paths below it in the hierarchy, including 
+        # the path of the node itself.  In this case, there's
+        # only one path to return.
+        def all_paths
+          [self.path]
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/files/watchers/missing_watcher.rb

@@ -0,0 +1,23 @@
+module FunWith
+  module Files
+    module Watchers
+      # Watches a path where nothing currently exists, and reports a change if
+      # something appears there.   
+      class MissingWatcher < NodeWatcher
+        def initialize( path )
+          set_path( path )
+        end
+      
+        # The fact that the watcher now needs to be replaced with a File/DirectoryWatcher
+        # must be handled elsewhere.
+        def update
+          self.path.exist? ? {self.path => :created } : {}
+        end
+      
+        def all_paths
+          []
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/files/watchers/node_watcher.rb

@@ -0,0 +1,44 @@
+
+
+
+
+
+
+
+
+
+
+
+
+module FunWith
+  module Files
+    module Watchers
+      class NodeWatcher
+        attr_accessor :path
+      
+        def set_path( path )
+          self.path = path.fwf_filepath
+        end
+      
+        def create_watchers( paths )
+          {}.tap do |watchers|
+            for path in paths
+              watchers[path.fwf_filepath] = Watcher.factory( path )
+            end
+          end
+        end
+      
+        # sets up an object variable for changes, then clears it and returns
+        # the changes.  I got sick of passing the changes hash around.
+        def new_changeset( &block )
+          @changes = {}
+          yield
+        
+          changes = @changes
+          @changes = {}
+          changes
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/testing/assertions/fun_with_files.rb

@@ -0,0 +1,91 @@
+module FunWith
+  module Testing
+    module Assertions
+      module FunWithFiles
+        # The object given must be an instance of class FilePath
+        def assert_fwf_filepath( file, msg = nil )
+          msg = message(msg){ "File <#{file}> should be a FunWith::Files::FilePath" }
+          assert_kind_of FunWith::Files::FilePath, file, msg  
+        end
+        
+        # The object given is an instance of class FilePath, and points to
+        # a file that exists.
+        def assert_file( file, msg = nil )
+          assert_fwf_filepath( file, message(nil){ "...is not a file." } )
+          
+          msg = message(msg){ "File should exist at <#{file}>." }
+          assert file.file?, msg
+        end
+        
+        # The object given is a filepath, but doesn't point to 
+        # an existing file or directory.  
+        def assert_no_file( file, msg = nil )
+          assert_fwf_filepath( file, message )
+          msg = message(msg){ "No file/directory should exist at <#{file}>." }
+          refute file.file?, msg
+        end
+        
+        # The object given is a filepath, and points to a directory
+        def assert_directory( file, msg = nil )
+          assert_fwf_filepath( file, msg )
+          msg = message(msg){ "<#{file}> should be a directory." }
+          assert file.directory?, msg
+        end
+        
+        # The object given is a filepath, but doesn't point to a directory.
+        def assert_not_directory( file, msg = nil )
+          assert_fwf_filepath( file, message )
+          msg = message(msg){ "<#{file}> shouldn't be a directory." }
+          refute file.directory?
+        end
+        
+        # The object given is a filepath.
+        # It points to a file that exists.
+        # That file is empty.
+        def assert_empty_file( file, msg = nil )
+          assert_fwf_filepath( file )
+          msg = message(msg){ "Empty file should exist at <#{file}>." }
+          assert file.file? && file.empty?, msg
+        end
+        
+        # The object given is a filepath.
+        # It points to a directory that exists.
+        # That directory is empty.
+        def assert_empty_directory( file, msg = nil )
+          assert_fwf_filepath( file )
+          msg = message(msg){ "Empty directory should exist at <#{file}>." }
+          assert file.directory? && file.empty?, msg
+        end
+        
+        
+        # The object given is a filepath.
+        # It points to a file that exists.
+        # That file contains content.
+        def assert_file_has_content( file, msg = nil )
+          assert_fwf_filepath( file, message )
+          msg = message(msg){ "File should exist at <#{file}>, and have content." }
+          assert file.exist?, msg.call + "(file does not exist)"
+          assert file.file?, msg.call + "(not a file)"
+          refute file.empty?, msg.call + "(file is not empty)"
+        end
+        
+        alias :assert_file_not_empty :assert_file_has_content
+        
+        
+        def assert_file_contents( file, content, msg = nil )
+          assert_file( file )
+          
+          case content
+          when String
+            # message = build_message( message, "File <#{file}> contents should be #{content[0..99].inspect}#{'...(truncated)' if content.length > 100}" )
+            assert_equal( content, file.read, msg )
+          when Regexp
+            assert_match( content, file.read, msg )
+          end
+        end
+        
+        
+      end
+    end
+  end
+end

data/lib/fun_with/testing/test_case_extensions.rb

@@ -0,0 +1,12 @@
+# The bulk of FunWith::Testing::TestCase can be found in the fun_with_testing gem.
+
+module FunWith
+  module Testing
+    module TestCaseExtensions
+      def install_fun_with_files_assertions
+        include FunWith::Testing::Assertions::Basics        # some of the FWF assertions rely on these
+        include FunWith::Testing::Assertions::FunWithFiles
+      end
+    end
+  end
+end

data/lib/fun_with_files.rb

@@ -1,38 +1,12 @@
 require 'xdg'
 require 'digest'      # stdlib
 require 'pathname'    # stdlib
+require 'set'
 require 'tmpdir'      # Dir.tmpdir
 
+require 'debug'
 
-for fil in ["string", "array", "false", "hash", "nil", "object"]
-  require_relative File.join( "fun_with", "files", "core_extensions", fil )
-end
+require_relative 'fun_with/files/bootstrapper'
+# sets up everything needed to load .requir(), which loads everything else
+FunWith::Files::Bootstrapper.bootstrap
 
-for klass in ["String", "Object", "NilClass", "Hash", "FalseClass", "Array"]
-  Kernel.const_get(klass).send( :include, FunWith::Files::CoreExtensions.const_get(klass))  
-end
-
-
-for fil in ["file_path", "string_behavior", "file_manipulation_methods", "file_permission_methods", "digest_methods", "file_requirements"]
-  require_relative File.join( "fun_with", "files", fil )
-end
-
-
-# These have some FilePath methods required by .requir()
-for mod in [ FunWith::Files::StringBehavior,
-             FunWith::Files::FileManipulationMethods, 
-             FunWith::Files::FilePermissionMethods, 
-             FunWith::Files::DigestMethods,
-             FunWith::Files::FileRequirements ]
-  FunWith::Files::FilePath.send( :include, mod )
-end
-
-lib_dir = File.dirname(__FILE__).fwf_filepath( "fun_with" )
-
-# And requir() everything else
-lib_dir.requir
-
-FunWith::Files::RootPath.rootify( FunWith::Files, __FILE__.fwf_filepath.dirname.up )
-FunWith::Files::FilePath.extend( FunWith::Files::FilePathClassMethods )
-
-FunWith::Files.extend( FunWith::Files::GemAPI )

data/test/helper.rb

@@ -21,13 +21,21 @@ require 'fun_with_files'
 
 class FunWith::Files::TestCase < FunWith::Testing::TestCase
   include FunWith::Files
-  include FunWith::Testing::Assertions::FunWithFiles
-  include FunWith::Testing::Assertions::Basics
+  include FunWith::Files::Errors
+  
+  
+  self.install_fun_with_files_assertions
+  # include FunWith::Testing::Assertions::FunWithFiles
+  # include FunWith::Testing::Assertions::Basics
   
   def tmpdir( &block )
-    FilePath.tmpdir do |d|
-      @tmpdir = d
-      yield
+    if block_given?
+      FilePath.tmpdir do |d|
+        @tmpdir = d
+        yield
+      end
+    else
+      @tmpdir = FilePath.tmpdir      # remember to remove the directory when you're done
     end
   end
   

data/test/test_core_extensions.rb

@@ -26,6 +26,12 @@ class TestCoreExtensions < FunWith::Files::TestCase
     should "fwf_blank? nicely." do
       assert_equal false, { 1 => 2 }.fwf_blank?
       assert_equal true, {}.fwf_blank?
+      assert_equal true, true.fwf_present?
+    end
+    
+    should "respond to fwf_filepath" do
+      assert_respond_to ".", :fwf_filepath
+      assert_respond_to ".".fwf_filepath, :fwf_filepath
     end
   end
 end

data/test/test_descent.rb

@@ -7,11 +7,11 @@ class TestDescent < FunWith::Files::TestCase
     ascent = []
     descent = []
     
-    FunWith::Files.root.ascend do |path|
+    root.ascend do |path|
       ascent << path
     end
     
-    FunWith::Files.root.descend do |path|
+    root.descend do |path|
       descent << path
     end
 

data/test/test_directory_builder.rb

@@ -54,7 +54,7 @@ class TestDirectoryBuilder < FunWith::Files::TestCase
         gemfile = b.current_path.join("Gemfile")
         assert gemfile.exist?
         assert !gemfile.zero?
-        assert_equal 1, gemfile.grep( /jeweler/ ).length
+        assert_equal 1, gemfile.grep( /fun_with_testing/ ).length
       end
     end
   
@@ -70,18 +70,37 @@ class TestDirectoryBuilder < FunWith::Files::TestCase
     should "download random crap from all over the Internet" do
       if_internet_works do
         DirectoryBuilder.tmpdir do |b|
-          gist_url = "http://bannedsorcery.com/downloads/testfile.txt"
-          gist_text = "This is a file\n==============\n\n**silent**: But _bold_! [Link](http://slashdot.org)\n"
-          b.download( gist_url, "gist.txt" )
+          # The file Bryce uses on Github to prove to Keybase that he owns this Github account
+          # I used to host a test file on my own site, but apparently if you stop paying DigitalOcean 
+          # for a few measly months your website goes away.  Github will probably provide a more
+          # stable target.
+          url = "https://gist.githubusercontent.com/darthschmoo/ac3ca60338ed41e87b94448f9e851fd3/raw" + 
+                "/3cba6b60b552266f4d5aa92d307ef2cda0cf228b/fun_with_files.download.txt"
+                
+          dest_file  = "download.01.txt"
+          dest_file2 = "download.02.txt"
+          
+          downloaded_text        = "You have successfully downloaded a file.  Huzzah!"
+          downloaded_text_md5    = "2e9d3a924ea36c860c3dd491166ec1ce"
+          downloaded_text_sha1   = "d9be1d5b5c8bd1de6b1dcb99e02cab8e35ed9659"
+          downloaded_text_sha256 = "dc9a6e5d571b39b9754b9592a3b586db8186121d37ec72f7fcbf45241cc43aa6"
+
+          b.download( url, dest_file, 
+                      :md5    => downloaded_text_md5,
+                      :sha1   => downloaded_text_sha1,
+                      :sha256 => downloaded_text_sha256
+          )
+          
         
-          b.file( "gist.txt.2" ) do
-            b.download( gist_url )
+          b.file( dest_file2 ) do
+            b.download( url )
           end
         
           assert b.current_file.nil?
-          assert b.current_path.join("gist.txt").exist?
-          assert b.current_path.join("gist.txt.2").exist?
-          assert_equal gist_text, b.current_path.join("gist.txt").read
+          assert b.current_path.join( dest_file ).exist?
+          assert b.current_path.join( dest_file2 ).exist?
+          assert_equal downloaded_text, b.current_path.join( dest_file ).read
+          assert_equal downloaded_text, b.current_path.join( dest_file2 ).read
         end
       end
     end
@@ -112,7 +131,7 @@ class TestDirectoryBuilder < FunWith::Files::TestCase
           end
         end
         
-        assert "Hello", b.current_path.join("earth", "air", "fire", "water", "hello.txt").read
+        assert_equal "Hello", b.current_path.join("earth", "air", "fire", "water", "hello.txt").read
         
         b.dir( "fire", "water", "earth", "air" ) do
           assert b.current_path.exist?

data/test/test_extension_methods.rb

@@ -0,0 +1,62 @@
+require 'helper'
+
+class TestExtensionMethods < FunWith::Files::TestCase
+  context "Testing extension methods" do
+    setup do
+      @bash = "/bin/bash".fwf_filepath
+      @log  = "/var/log/apache/access.log".fwf_filepath
+      @older_log = "/var/log/apache/access.log.9"
+    end
+
+    context "Testing ext?()" do
+      should "correctly identify the extension" do
+        assert_true @bash.ext?("")
+        
+        assert_true  @log.ext?(".log")
+        assert_true  @log.ext?(:log)
+        assert_false @log.ext?(".blog")
+        assert_true  @log.ext?(:blog, :flog, :frog, :log)
+      end
+      
+      should "run a block if the extension matches" do
+        var = 5
+        
+        @log.ext?(:log) do |f|
+          assert_equal @log, f
+          var = 6
+        end
+        
+        assert_equal 6, var
+      end
+    end
+  
+    context "Testing file.ext()" do
+    
+      should "draw a blank on bash file" do
+        assert_blank @bash.ext
+        assert_equal "", @bash.ext
+      end
+    
+      should "add an extension when an extension is given as an argument" do
+        bash2 = @bash.ext( 12 )
+      
+        assert_fwf_filepath bash2
+        assert_equal "12", bash2.ext
+      
+        for ext in [:exe, "exe"]
+          bash2 = @bash.ext( ext )
+          assert_fwf_filepath bash2
+          assert_equal "exe", bash2.ext
+        end
+      end
+    
+      should "add multiple extensions when multiple extensions are given" do
+        for args in [ [:tar, :gz], ["tar", "gz"], [".tar", ".gz"] ]
+          bash2 = @bash.ext( *args )
+          assert_equal "gz", bash2.ext
+          assert_equal "/bin/bash.tar.gz", bash2.path
+        end
+      end
+    end
+  end
+end