fun_with_files 0.0.15 → 0.0.18

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,82 +1,12 @@
 require 'xdg'
 require 'digest'      # stdlib
 require 'pathname'    # stdlib
+require 'set'
 require 'tmpdir'      # Dir.tmpdir
 
+require 'debug'
 
-# Do the bare minimum to get FilePath.requir working
-# file_path = File.join( "fun_with", "files", "file_path" )
-# string_behavior = File.join( "fun_with", "files", "string_behavior" )
-#
-#
-# require_relative file_path
-# require_relative string_behavior
-#
-# FunWith::Files::FilePath.send( :include, FunWith::Files::StringBehavior )
-# FunWith::Files::FilePath.new( "fun_with" ).requir
-#
-# debugger
+require_relative 'fun_with/files/bootstrapper'
+# sets up everything needed to load .requir(), which loads everything else
+FunWith::Files::Bootstrapper.bootstrap
 
-
-
-core_extension_folder = File.join( "lib", "fun_with", "files", "core_extensions" )
-
-for fil in Dir.glob( File.join( core_extension_folder, "*.rb" ) )
-  # Dir.glob targets the root directory, while require_relative is relative to lib/,
-  # so the [4..-4] removes the leading lib/ and the trailing extension to make it
-  # require_relative-friendly.
-  require_path = fil[4..-4]   # 
-  basename = File.basename( fil )[0..-4]
-  # debugger if basename =~ /class/
-  
-  target_class_str = basename.split( "_" ).map(&:capitalize).join("")
-  target_class = Kernel.const_get( target_class_str )
-  mixin_class_str  = "FunWith::Files::CoreExtensions::#{target_class_str}"
-
-  # puts "Basename: #{basename}"
-  # puts "Mixin: " + mixin_class_str.inspect
-  # puts "Target: #{target_class}"
-  # puts "requiring: #{require_path}"
-  require_relative require_path
-  mixin_class = Kernel.const_get( mixin_class_str )
-  # puts mixin_class.to_s
-  
-  target_class.send( :include, mixin_class )
-end
-
-
-
-# for fil in ["string", "array", "false", "hash", "nil", "object",]
-#   require_relative File.join( "fun_with", "files", "core_extensions", fil )
-# end
-#
-# for klass in ["String", "Object", "NilClass", "Hash", "FalseClass", "Array", "Set"]
-#   puts klass
-#   debugger if klass == "Set"
-#   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

@@ -28,5 +28,10 @@ class TestCoreExtensions < FunWith::Files::TestCase
       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_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( /juwelier/ ).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", :md5 => "f498e76ea5690a4c29ef97d0a1d8e58e", :sha1 => "ccabf74107cba7ad69f70e45c04c3876e7f34630" )
+          # 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

data/test/test_file_manipulation.rb

@@ -21,9 +21,9 @@ class TestFileManipulation < FunWith::Files::TestCase
     should "gsub copy of license.txt" do
       copied = @license.cp( "test", "tmp" )
       copied.file_gsub!( /Bryce Anderson/, "Wilford Brimley" )
-      assert copied.size > 1000
+      assert copied.size > 1000, "File is too small"
       
-      assert_file_contents copied, /Wilford Brimley/
+      assert_file_contents copied, /Wilford Brimley/, "Error 441: Wilford Brimley not found"
     end
     
     should "empty files and directories" do

data/test/test_file_path.rb

@@ -10,17 +10,17 @@ class TestFilePath < FunWith::Files::TestCase
     end
     
     should "have location class methods available" do
-      assert_respond_to( FunWith::Files::FilePath, :home )
-      assert_respond_to( FunWith::Files::FilePath, :config_dir )
-      assert_respond_to( FunWith::Files::FilePath, :root )
-      assert_respond_to( FunWith::Files::FilePath, :data_dir )
+      assert_respond_to FunWith::Files::FilePath, :home 
+      assert_respond_to FunWith::Files::FilePath, :config_dir
+      assert_respond_to FunWith::Files::FilePath, :root
+      assert_respond_to FunWith::Files::FilePath, :data_dir 
     end
     
     
     should "join smoothly" do
       bin_dir = "/bin".fwf_filepath
-      assert_equal( "/bin/bash", bin_dir.join("bash").to_s )
-      assert_equal( "/bin/bash", bin_dir.join("bash".fwf_filepath).to_s )
+      assert_equal "/bin/bash", bin_dir.join("bash").to_s
+      assert_equal "/bin/bash", bin_dir.join("bash".fwf_filepath).to_s
     end
 
     should "go up/down when asked" do
@@ -99,17 +99,20 @@ class TestFilePath < FunWith::Files::TestCase
     should "sequence files nicely" do
       seqfile = @tmp_dir.join("sequence.txt")
       
+      files = [seqfile]
+      
       10.times do |i|
         seqfile.write( i.to_s )
         seqfile = seqfile.succ
+        files << seqfile
       end
       
-      assert_file @tmp_dir.join("sequence.txt")
-      assert_file @tmp_dir.join("sequence.000000.txt")
-      assert_file @tmp_dir.join("sequence.000008.txt")
+      assert_file files[0]
+      assert_file files[1]
+      assert_file files[9]
       
-      assert_file_contents @tmp_dir.join("sequence.txt"), "0"
-      assert_file_contents @tmp_dir.join("sequence.000008.txt"), "9"
+      assert_file_contents files[0], "0"
+      assert_file_contents files[9], "9"
     end
     
     should "sequence files with custom stamp length" do
@@ -128,35 +131,7 @@ class TestFilePath < FunWith::Files::TestCase
       assert_file_contents @tmp_dir.join("sequence.0008.txt"), "9"
     end
     
-    should "sequence files with datestamps" do
-      seqfile = @tmp_dir.join("sequence.txt")
-      
-      10.times do |i|
-        seqfile.write( i.to_s )
-        seqfile = seqfile.succ( timestamp: true )
-        sleep(0.002)
-      end
-      
-      files = seqfile.succession( timestamp: true )
-      assert files.length == 10
-      
-      files.each_with_index do |file, i|
-        assert_file file
-        assert_file_contents file, i.to_s
-      end
-      
-      file_name_strings = files.map(&:to_s)
-      assert_equal file_name_strings[1..-1], file_name_strings[1..-1].sort
-    end
-
-    should "timestamp files using the timestamp() method" do
-      timestampable_file = @tmp_dir.join( "timestamped.dat" )
-      timestamped_file1  = timestampable_file.timestamp
-      timestamped_file2  = timestampable_file.timestamp("%Y")
 
-      assert timestamped_file1 =~ /timestamped.\d{17}.dat$/
-      assert timestamped_file2 =~ /timestamped.\d{4}.dat$/
-    end
   end
   
 
@@ -294,4 +269,8 @@ class TestFilePath < FunWith::Files::TestCase
       assert_equal expected, result
     end
   end
+  
+  context "testing block form" do
+    
+  end
 end

data/test/test_file_requirements.rb

@@ -0,0 +1,36 @@
+require 'helper'
+
+class TestFileRequirements < FunWith::Files::TestCase
+  context "testing FileRequirements methods" do
+    setup do
+      @tmp_dir = FunWith::Files.root("test", "tmp")
+      @file    = @tmp_dir.join("file.txt").touch
+      @dir     = @tmp_dir.join("dir").touch_dir
+    end
+    
+    teardown do
+      empty_temp_directory
+    end
+    
+    context "needs_to_exist()" do
+      should "raise an error when a file doesn't exist" do
+        assert_raises Errno::ENOENT do
+          @tmp_dir.join("missing_file.txt").needs_to_exist
+        end
+      end
+      
+      should "raise an error when a file isn't empty" do
+        assert_raises Errors::FileNotEmpty do
+          @file.append("Zorpy was here")
+          @file.needs_to_be_empty
+        end
+      end
+      
+      should "raise an error when a file oughta be a directory" do
+        assert_raises Errors::NotADirectory do
+          @file.must_be_directory
+        end
+      end
+    end
+  end
+end

data/test/test_fun_with_files.rb

@@ -26,7 +26,7 @@ class TestFunWithFiles < FunWith::Files::TestCase
       assert_respond_to( FunWith::Files, :root )
       assert_respond_to( FunWith::Files, :version )
       
-      assert_equal "0.0.14", FunWith::Files.version   # Gotta change with every point release.  Ick.
+      assert_equal "0.0.17", FunWith::Files.version   # Gotta change with every point release.  Ick.
     end
   end
 end