fun_with_files 0.0.7 → 0.0.8

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YTg3ZGQzMDAxYTczMjBjNTc5NjU2ZDA0MDRlNzQ0YTc5MzBjMmE2OQ==
+    YjBjMTU1NDdlNDRhMmM5YmRhOGQ2MDJiMTFhM2QwMjZmM2ZjMmQwYw==
   data.tar.gz: !binary |-
-    NTBhOGNkNTcyZGRlNGNjYTFjNzMyYzVhYzhmNWE0NmU3ODMwODFjMw==
+    NmRiMGRmZmE1YzRkYTRhZjMyNzI4MDYyZTkyMWFjNmVhMTQ4ZGJjZA==
 SHA512:
   metadata.gz: !binary |-
-    M2VhMTIwMDRjNDRiODQ3MTcwNDJiYmJlYmExODA3ZmVlOTQwYzI3ODFkNGI4
-    MTNkZGUxYTRkNjE5ZmZjYjMwYzUyNDdkYjNmN2MxNjU3NmY5YmVlMTQ5NzZj
-    NzY5ODZlNWIyMGU4MjI4MDI4ZGM2MTRkZDg4NzEzMThlY2FmMjU=
+    NzAxZjhmYTA2NzIyNjkwNmVlNTMwMjNiZmQ3MjhlYTc5ZWM5ZDMyOTUwNmY1
+    YTAyMTNiMDkwZTgzY2FiMTMyMzMwMTk2NzBiMTcyNDBiNTQ2YTMyNmQwNjMw
+    MmM0ODdiYWM3Yjk3ZDBkZTI4ZjA1MDdmYWYxYzM0NDBhODE3MTI=
   data.tar.gz: !binary |-
-    YzI5ZGYyZDgwYzQ0ODg0MjNjNjVhYTI4OGEzZDcwODk4MjI0OGZlNmMzZWRi
-    ZGQyZjUwN2M0MjBmYzQzMTY3YWZhYmNhNDdhNGE5M2NhM2MyNzYxZGQ3NDA3
-    YjRjNWM5NWRiZGUxODc2MTFlM2ZmMGZlNGJlZDZjNjQ0ODJjMDk=
+    YjhlYjRhODBmMzc3NDNkZGE4NDM3MzgwMTFlMDgyMWZjY2U5MTdjZjI0NDU5
+    M2VmNzAxOGU2NmQ4N2ZlN2Y4NTE4NWQ1OWUwZDMxODE3ODJkYmNhMGU3MWRh
+    YjFhMDc3NTZkODRkMTBiMDc4N2I4YTZiYTVhZGFhNDQ4MmZlZDY=

data/Gemfile

@@ -7,11 +7,12 @@ source "http://rubygems.org"
 # Include everything needed to run rake, tests, features, etc.
 
 group :development do
-  gem "shoulda", ">= 3.5"
-  gem "rdoc", "~> 3.12"
-  gem "bundler", "~> 1.5"
-  gem "jeweler", "~> 2.0"
+  # gem "shoulda", "~> 3", ">= 3.5"
+  # gem "rdoc", "~> 3.12"
+  # gem "bundler", "~> 1.5"
+  # gem "jeweler", "~> 2.0"
   # gem "debugger", "~> 1.6"
+  gem "fun_with_testing", "~> 0.0"
 end
 
-gem "xdg"
+gem "xdg", "~> 2"

data/Rakefile

@@ -1,7 +1,8 @@
 # encoding: utf-8
 
-require 'rubygems'
-require 'bundler'
+require 'fun_with_testing'
+# require 'rubygems'
+# require 'bundler'
 
 begin
   Bundler.setup(:default, :development)
@@ -13,7 +14,7 @@ end
 
 require 'rake'
 
-require 'jeweler'
+# require 'jeweler'
 Jeweler::Tasks.new do |gem|
   # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
   gem.name = "fun_with_files"

data/VERSION

@@ -1 +1 @@
-0.0.7
+0.0.8

data/lib/fun_with/files/digest_methods.rb

@@ -2,7 +2,35 @@ module FunWith
   module Files
     module DigestMethods
       def md5
-        self.file? ? Digest::MD5.hexdigest( self.read ) : ""
+        digest( Digest::MD5 )
+      end
+      
+      def sha1
+        digest( Digest::SHA1 )
+      end
+      
+      def sha2
+        digest( Digest::SHA2 )
+      end
+
+      def sha224
+        digest( Digest::SHA224 )
+      end
+
+      def sha256
+        digest( Digest::SHA256 )
+      end
+
+      def sha384
+        digest( Digest::SHA384 )
+      end
+      
+      def sha512
+        digest( Digest::SHA512 )
+      end
+
+      def digest( digest_class = Digest::MD5 )
+        self.file? ? digest_class.hexdigest( self.read ) : ""
       end
     end
   end

data/lib/fun_with/files/file_manipulation_methods.rb

@@ -15,11 +15,13 @@ module FunWith
       # ln_s(list, destdir, options)
       # ln_sf(src, dest, options)
       
+      # Opts are same as for FileUtils.cp_r
+      # returns the destination path.
+      # How to detect failure?  What to return on failure?
       def cp( *args )
-        self.destination_and_options( args ) do |dest, opts|
-          FileUtils.cp_r( self, dest, opts )
-          dest.fwf_filepath
-        end
+        dest, opts = self.destination_and_options( args )
+        FileUtils.cp_r( self, dest, opts )
+        dest.fwf_filepath
       end
       
       alias :copy :cp
@@ -41,11 +43,15 @@ module FunWith
         end
       end
       
-      def ln_s( link, options = {} )
-        FileUtils.ln_s( self, link, options )
+      def ln_s( *args )
+        link, opts = self.destination_and_options( args )
+        FileUtils.ln_s( self, link, opts )
         link.fwf_filepath
       end
       
+      alias :symlink :ln_s
+      
+      
       def file_gsub( *args, &block )
         lines = []
         self.each_line do |line|
@@ -59,6 +65,18 @@ module FunWith
         self.write( self.file_gsub(*args,&block) )
       end
       
+      def empty!
+        if self.directory?
+          FileUtils.rm_rf( self.entries, secure: true )
+        else
+          self.write( "" )
+        end
+      end
+      
+      def truncate( len )
+        self.write( self.read( len ) )
+      end
+      
       protected
       def destination_and_options( args, &block )
         options = args.last.is_a?(Hash) ? args.pop : {}
@@ -72,19 +90,33 @@ module FunWith
       end
       
       
-      
       # logic should be shared by various manipulators
+      # 
+      # You can describe the destination as either a filepath or a bunch of strings for arguments.
+      # If the FilePath is relative, or if string args are given, then the destination will be
+      # relative to the path being copied (or in the case of a file, its parent directory).
+      #
+      # If dest doesn't exist, and src (self) is a file, dest is taken to be the complete path.
+      # If dest doesn't exist, and src (self) is a directory, then dest is taken to be 
+      # If dest is a directory and the source is a file, then the file will be copied into dest with the src's basename
       def find_destination_from_args( args )
+        raise ArgumentError.new("File #{self} must exist.") unless self.exist?
+        
         if args.first.is_a?(Pathname) 
+          raise ArgumentError.new( "accepts a FilePath or string args, not both" ) unless args.length == 1
           dest = args.first
-        elsif self.directory?
-          # what if they're trying to define an absolute dest, but being splitty?
-          dest = self.join( *args )
+          dest = dest.directory.join( dest ).expand if dest.relative?
         else
-          # ......
-          dest = self.dirname.join( *args )
-          dest = dest.join( self.basename ) if dest.directory?
+          dest = self.directory.join(*args).expand  # expand gets rid of /../ (parent_dir)
+        end
+        
+        if self.file? && dest.directory?
+          dest = dest.join( self.basename )
+        elsif self.directory? && dest.file?
+          raise ArgumentError.new( "cannot overwrite a file with a directory" )
         end
+                
+        dest
       end
         
       # rm(list, options)

data/lib/fun_with/files/file_path.rb

@@ -1,19 +1,13 @@
 module FunWith
   module Files
     class FilePath < Pathname
+      SUCC_DIGIT_COUNT = 6
+      DEFAULT_TIMESTAMP_FORMAT = "%Y%m%d%H%M%S%L"
+      
       def initialize( *args )
         super( File.join( *args ) )
       end
 
-      # args implicitly joined to cwd
-      def self.cwd( *args )
-        Dir.pwd.fwf_filepath.join( *args )
-      end
-      
-      def self.pwd( *args )
-        self.cwd( *args )
-      end
-      
       # If block given, temporary directory is deleted at the end of the block, and the
       # value given by the block is returned.
       # 
@@ -29,10 +23,6 @@ module FunWith
         end
       end
 
-      def self.home( *args )
-        Dir.home.fwf_filepath.join( *args )
-      end
-
       def join( *args, &block )
         if block_given?
           yield self.class.new( super(*args) )
@@ -61,11 +51,11 @@ module FunWith
       #                  Can be given as an integer: (File::FNM_DOTMATCH | File::FNM_NOESCAPE)  
       #                  or as an array: [File::FNM_CASEFOLD, File::FNM_DOTMATCH]
       #                
-      #    :class  =>  [self.class] The class of objects you want returned (String, FilePath, ClassLoader, etc.)
+      #    :class  =>  [self.class] The class of objects you want returned (String, FilePath, etc.)
       #                Should probably be a subclass of FilePath or String.  Class.initialize() must accept a string
       #                [representing a file path] as the sole argument.
       #
-      #    :recurse => [false] 
+      #    :recurse => [defaults true]
       #    :recursive (synonym for :recurse)
       #    
       #    :ext => []  A single symbol, or a list containing strings/symbols representing file name extensions.
@@ -80,48 +70,88 @@ module FunWith
       #    results explicitly with arguments like .glob("**", "*.rb")
       # 
       # :all : if :all is the only argument, this is the same as .glob("**", "*")
+      # 
+      # Examples:
+      # @path.glob( "css", "*.css" )      # Picks up all css files in the css folder
+      # @path.glob( "css", :ext => :css ) # same
+      # @path.glob                        # Picks up all directories, subdirectories, and files
+      # @path.glob(:all)                  # same. Note: :all cannot be used in conjunction with :ext
+      # @path.glob("**", "*")             # same
+      # @path.entries                     # synonym for :all, :recursive => false
+      # 
       def glob( *args )
+        args.push( :all ) if args.fwf_blank?
         opts = args.last.is_a?(Hash) ? args.pop : {}
         
-        flags = case opts[:flags]
-        when NilClass
-          0
-        when Array      # should be an array of integers
-          opts[:flags].inject(0) do |memo, obj|
-            memo | obj
-          end
-        when Integer
-          opts[:flags]
+        if args.last == :all
+          all_arg_given = true
+          args.pop
+        else
+          all_arg_given = false
         end
         
+        flags = case (flags_given = opts.delete(:flags))
+                when NilClass
+                  0
+                when Array      # should be an array of integers
+                  flags_given.inject(0) do |memo, obj|
+                    memo | obj
+                  end
+                when Integer
+                  flags_given
+                end
+        
         flags |= File::FNM_DOTMATCH if opts[:dots]
         flags |= File::FNM_CASEFOLD if opts[:sensitive]
+    
+        recurse = if all_arg_given
+                    if opts[:recursive] == false || opts[:recurse] == false
+                      false
+                    else
+                      true
+                    end
+                  else
+                    opts[:recursive] == true || opts[:recurse] == true || false
+                  end
         
-        if args.first == :all
-          args = ["**", "*"]
+        if all_arg_given
+          if recurse
+            args = ["**", "*"]
+          else
+            args = ["*"]
+          end
         else
-          recurser = (opts[:recurse] || opts[:recursive]) ? "**" : nil
+          args.push("**") if recurse
+
           extensions = case opts[:ext]
           when Symbol, String
             "*.#{opts[:ext]}"
           when Array
             extensions = opts[:ext].map(&:to_s).join(',')
-            "*.{#{extensions}}"
+            "*.{#{extensions}}"                            # The Dir.glob format for this is '.{ext1,ext2,ext3}'
           when NilClass
-            nil
+            if args.fwf_blank?
+              "*"
+            else
+              nil
+            end
           end
           
-          args += [recurser, extensions]
-          args.compact!
+          args.push( extensions ) if extensions
         end
         
-        opts[:class] ||= self.class
+        class_to_return = opts[:class] || self.class
+        
+        files = Dir.glob( self.join(*args), flags ).map{ |f| class_to_return.new( f ) }
+        files.reject!{ |f| f.basename.to_s.match( /^\.\.?$/ ) } unless opts[:parent_and_current]
         
-        files = Dir.glob( self.join(*args), flags ).map{ |f| opts[:class].new(f) }
-        files.reject!{ |f| f.basename.to_s.match(/^\.{1,2}$/) } unless opts[:parent_and_current]
         files
       end
       
+      def entries
+        self.glob( :recurse => false )
+      end
+      
       def expand
         self.class.new( File.expand_path( self ) )
       end
@@ -193,7 +223,7 @@ module FunWith
         if self.file?
           File.size( self ) == 0
         elsif self.directory?
-          self.glob( "**", "*" ).fwf_blank?
+          self.glob( :all ).fwf_blank?
         end
       end
             
@@ -206,11 +236,18 @@ module FunWith
         self.gsub(/\.#{self.ext}$/, '')
       end
       
+      # Two separate modes.  With no arguments given, returns the current extension as a string (not a filepath)
+      # With an argument, returns the path with a .(arg) tacked onto the end.  The leading period is wholly optional.
       # Does not return a filepath.
       # Does not include leading period
-      def ext
-        split_basename = self.basename.to_s.split(".")
-        split_basename.length > 1 ? split_basename.last : ""
+      def ext( *args )
+        if args.length == 0
+          split_basename = self.basename.to_s.split(".")
+          split_basename.length > 1 ? split_basename.last : ""
+        elsif args.length == 1
+          ext = args.first.to_s.gsub(/^\./,'')
+          self.class.new( @path.dup + ".#{ext}" )
+        end
       end
       
       # base, ext =  @path.basename_and_ext
@@ -226,6 +263,20 @@ module FunWith
         [self.dirname, self.basename_no_ext, self.ext]
       end
       
+      # if it's a file, returns the immediate parent directory.
+      # if it's not a file, returns itself
+      def directory
+        self.directory? ? self : self.dirname
+      end
+      
+      def original?
+        !self.symlink?
+      end
+      
+      def original
+        self.symlink? ? self.readlink.original : self
+      end
+      
       # Basically Pathname.relative_path_from, but you can pass in strings
       def relative_path_from( dir )
         dir = super( Pathname.new( dir ) )
@@ -245,10 +296,12 @@ module FunWith
       # You can change the length of the sequence string by passing
       # in an argument, but it should always be the same value for
       # a given set of files.
-      SUCC_DIGIT_COUNT = 6
+      # 
+      # TODO: Need to get this relying on the specifier() method.
       def succ( opts = { digit_count: SUCC_DIGIT_COUNT, timestamp: false } )
-        if opts[:timestamp]
-          timestamp = Time.now.strftime("%Y%m%d%H%M%S%L")
+        if timestamp = opts[:timestamp]
+          timestamp_format = timestamp.is_a?(String) ? timestamp : DEFAULT_TIMESTAMP_FORMAT
+          timestamp = Time.now.strftime( timestamp_format )
           digit_count = timestamp.length
         else
           timestamp = false
@@ -287,6 +340,10 @@ module FunWith
         self.up.join( chunks.join(".") )
       end
     
+      
+      def timestamp( format = true )
+        self.succ( :timestamp => format )
+      end
     
       def specifier( str )
         str = str.to_s
@@ -334,7 +391,7 @@ module FunWith
           stamped = [ chunks[0..-2], glob_stamp_matcher, chunks[-1] ].flatten.join(".")
         end
       
-        [self.dirname.glob(original), self.dirname.glob(stamped)].flatten
+        [self.dirname.join(original), self.dirname.glob(stamped)].flatten
       end
 
 
@@ -394,7 +451,7 @@ module FunWith
                 successfully_required += 1
               rescue Exception => e
                 failed_requirements << requirement
-                error_messages << "#{e.message} (#{e.class})"
+                error_messages << "Error while requiring #{requirement} : #{e.message} (#{e.class})"
               end
             end
             

data/lib/fun_with/files/file_path_location_methods.rb

@@ -0,0 +1,38 @@
+module FunWith
+  module Files
+    module FilePathLocationMethods
+      # args implicitly joined to cwd
+      def cwd( *args )
+        Dir.pwd.fwf_filepath.join( *args )
+      end
+      
+      def pwd( *args )
+        self.cwd( *args )
+      end
+      
+      def home( *args )
+        Dir.home.fwf_filepath.join( *args )
+      end
+      
+      def config_dir( *args )
+        XDG['CONFIG'].fwf_filepath.join( *args )
+      end
+      
+      def data_dir( *args )
+        XDG['DATA'].fwf_filepath.join( *args )
+      end
+      
+      # Honestly this is a token attempt at Windows compatibility.
+      # This could go wrong all sorts of ways, and hasn't been tested
+      # on Windows.  More to the point, when a Windows machine has
+      # multiple drives mounted, what do you even call the root?
+      def root( *args )
+        if self.home =~ /^[a-zA-Z]:/
+          self.home.to_s[0..3].fwf_filepath.join( *args )
+        else
+          "/".fwf_filepath.join( *args )
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/files/root_path.rb

@@ -17,7 +17,11 @@ module FunWith
 
     class RootPath
       def self.rootify( target, path )
-        raise "#{target} already responds to :root" if target.respond_to?(:root)
+        if target.respond_to?(:root)
+          warn( "#{target} already responds to :root, skipping installation" )
+          return nil
+        end
+        
         target.extend( RootPathExtensions )
         target.set_root_path( FilePath.new( path ) )
       end

data/lib/fun_with/files/string_behavior.rb

@@ -23,6 +23,11 @@ module FunWith
       def scan( *args, &block )
         @path.scan( *args, &block )
       end
+      
+      # Lets it be a string when a string is called for.  Replacement argument in .gsub(), for example.
+      def to_str
+        @path.dup
+      end
     end
   end
 end

data/lib/fun_with_files.rb

@@ -1,6 +1,7 @@
-require 'digest/md5' # stdlib
-require 'pathname'   # stdlib
-require 'tmpdir'
+require 'xdg'
+require 'digest'      # stdlib
+require 'pathname'    # stdlib
+require 'tmpdir'      # Dir.tmpdir
 
 files = Dir.glob( File.join( File.dirname(__FILE__), "fun_with", "**", "*.rb" ) )
 
@@ -13,12 +14,14 @@ FunWith::Files::RootPath.rootify( FunWith::Files, __FILE__.fwf_filepath.dirname.
 module FunWith
   module Files
     class FilePath
-      for mod in [ StringBehavior,
-                   FileManipulationMethods,
-                   FilePermissionMethods,
-                   DigestMethods ]
-        include mod
+      for moduul in [ StringBehavior,
+                      FileManipulationMethods,
+                      FilePermissionMethods,
+                      DigestMethods ]
+        include moduul
       end
     end
   end
 end
+
+FunWith::Files::FilePath.extend( FunWith::Files::FilePathLocationMethods )

data/test/helper.rb

@@ -1,31 +1,44 @@
-require 'rubygems'
-require 'bundler'
+# require 'rubygems'
+# require 'bundler'
+# require 'debugger'
+require 'fun_with_testing'
 
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
 
-require 'test/unit'
-require 'shoulda'
+# begin
+#   Bundler.setup(:default, :development)
+# rescue Bundler::BundlerError => e
+#   $stderr.puts e.message
+#   $stderr.puts "Run `bundle install` to install missing gems"
+#   exit e.status_code
+# end
+# 
+# require 'test/unit'
+# require 'shoulda'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'fun_with_files'
 
-class Test::Unit::TestCase
-end
+# class Test::Unit::TestCase
+# end
 
-class FunWith::Files::TestCase < Test::Unit::TestCase
+class FunWith::Files::TestCase < FunWith::Testing::TestCase
   include FunWith::Files
+  include FunWith::Testing::Assertions::FunWithFiles
+  include FunWith::Testing::Assertions::Basics
   
   def tmpdir( &block )
-    FunWith::Files::FilePath.tmpdir do |d|
+    FilePath.tmpdir do |d|
       @tmpdir = d
       yield
     end
   end
+  
+  def empty_temp_directory
+    tmp = FunWith::Files.root("test", "tmp")
+    tmp.empty!
+    assert_directory tmp
+    puts tmp.glob(:all)
+    assert_empty_directory tmp
+  end
 end

data/test/test_copying.rb

@@ -1,52 +1,4 @@
 require 'helper'
 
 class TestCopying < FunWith::Files::TestCase
-  context "inside a tmpdir" do
-    setup do
-      @dir = FilePath.tmpdir
-      assert @dir.exist?
-    end
-    
-    teardown do
-      @dir.rm
-      assert_equal false, @dir.directory?
-    end
-    
-    should "copy a single file" do
-      outdir = @dir.join( "down", "down", "down", "to", "the", "depths" )
-      assert !outdir.exist?
-      outdir.touch_dir
-      assert outdir.exist?
-      
-      infile = FunWith::Files.root( "test", "helper.rb" )
-      assert infile.exist?
-      
-      outfile = outdir.join("copy_of_helper.rb")
-      assert !outfile.exist?
-      
-      infile.cp( outdir )
-      assert outdir.join("helper.rb").exist?
-      
-      infile.cp( outfile )
-      assert outfile.exist?
-    end
-    
-    should "copy a directory structure" do
-      outdir = @dir.join( "down", "down", "abandon", "all", "hope" )
-      indir = FunWith::Files.root( "test" )
-      outdir.touch_dir
-      indir.cp( outdir )
-      
-      assert outdir.exist?
-      helper_file = outdir.join( "test", "helper.rb" )
-      assert helper_file.exist?
-      assert_equal indir.join( "helper.rb" ).grep( /FunWith::Files/ ).length, helper_file.grep( /FunWith::Files/ ).length
-      
-      assert_equal indir.glob(:all).length, outdir.join("test").glob(:all).length
-    end
-    
-    should "symlink masterfully" do
-      
-    end
-  end
 end

data/test/test_digest.rb

@@ -0,0 +1,31 @@
+require 'helper'
+
+class TestDigest < FunWith::Files::TestCase
+  context "inside a tmpdir" do
+    setup do
+      @dir = FilePath.tmpdir
+    end
+    
+    teardown do
+      @dir.rm
+      assert_equal false, @dir.directory?
+    end
+    
+    should "digest a blank file" do
+      blankfile = @dir.touch('blank.dat')
+      assert_empty_file blankfile
+      
+      results = { :md5    => "d41d8cd98f00b204e9800998ecf8427e",
+                  :sha1   => "da39a3ee5e6b4b0d3255bfef95601890afd80709",
+                  :sha2   => "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+                  :sha256 => "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+                  :sha384 => "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b",
+                  :sha512 => "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"
+                }
+                
+      for h in %w(md5 sha1 sha2 sha256 sha384 sha512).map(&:to_sym)
+        assert_equal( results[h], blankfile.send(h), "A blank file should have a #{h}() digest of #{results[h]}" )
+      end
+    end
+  end
+end

data/test/test_file_manipulation.rb

@@ -4,13 +4,18 @@ class TestFileManipulation < FunWith::Files::TestCase
   context "testing gsubs" do
     setup do
       @license = FunWith::Files.root("LICENSE.txt")
+      @tmp_dir = FunWith::Files.root("test", "tmp")
+    end
+    
+    teardown do
+      empty_temp_directory
     end
     
     should "copy LICENSE.txt" do
       copied = @license.cp( "test", "tmp" )
       assert_match /LICENSE\.txt/, copied.to_s
-      assert copied.exist?
-      assert copied.read.length > 0
+      assert_file copied
+      assert_file_has_content copied
     end
     
     should "gsub copy of license.txt" do
@@ -18,7 +23,77 @@ class TestFileManipulation < FunWith::Files::TestCase
       copied.file_gsub!( /Bryce Anderson/, "Wilford Brimley" )
       assert copied.size > 1000
       
-      assert_equal 1, copied.grep("Wilford Brimley").length
+      assert_file_contents copied, /Wilford Brimley/
+    end
+    
+    should "empty files and directories" do
+      license_copy = @license.cp( @tmp_dir )
+      assert_file( license_copy )
+      assert_equal( FunWith::Files.root("test", "tmp", "LICENSE.txt"), license_copy )
+      assert_file_has_content( license_copy )
+      license_copy.empty!
+      assert_empty_file( license_copy )
+      assert_zero( license_copy.read.length )
+      
+      
+    end
+  end
+  
+  context "inside a tmpdir" do
+    setup do
+      @dir = FilePath.tmpdir
+      assert_directory @dir
+    end
+    
+    teardown do
+      @dir.rm
+      assert_not_directory @dir
+    end
+    
+    should "copy a single file" do
+      outdir = @dir.join( "down", "down", "down", "to", "the", "depths" )
+      assert_no_file outdir
+      outdir.touch_dir
+      assert outdir.exist?
+      
+      infile = FunWith::Files.root( "test", "helper.rb" )
+      assert infile.exist?
+      
+      outfile = outdir.join("copy_of_helper.rb")
+      assert !outfile.exist?
+      
+      infile.cp( outdir )
+      assert outdir.join("helper.rb").exist?
+      
+      infile.cp( outfile )
+      assert outfile.exist?
+    end
+    
+    should "copy test directory structure to a temporary directory" do
+      outdir = @dir.join( "down", "down", "abandon", "all", "hope" )
+      indir = FunWith::Files.root( "test" )
+      outdir.touch_dir
+      indir.cp( outdir )
+      
+      assert outdir.exist?
+      helper_file = outdir.join( "test", "helper.rb" )
+      assert_file_has_content helper_file
+      assert_equal indir.join( "helper.rb" ).grep( /FunWith::Files/ ).length, helper_file.grep( /FunWith::Files/ ).length
+      
+      assert_equal indir.glob(:all).length, outdir.join("test").glob(:all).length
+    end
+    
+    should "symlink masterfully" do
+      file = @dir.join( "original.txt" )
+      file.write( "This is the original file" )
+      
+      clone = file.symlink( "clone.txt" )
+      clone_of_clone = clone.symlink( "clone_of_clone.txt" )
+      assert_false( clone_of_clone.original? )
+      assert( clone_of_clone.symlink? )
+      assert_equal( file, clone_of_clone.original )
+      
+      assert_file_contents( clone_of_clone, /This is the/ )
     end
   end
 end

data/test/test_file_path.rb

@@ -2,15 +2,25 @@ require 'helper'
 
 class TestFilePath < FunWith::Files::TestCase
   context "testing basics" do
-    setup do
-      
-    end
-    
     should "initialize kindly" do
       f1 = FilePath.new( "/", "bin", "bash" )
       f2 = "/".fwf_filepath( "bin", "bash" )
-      assert f1.exist?
-      assert f2.exist?
+      assert_file f1
+      assert_file f2
+    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 )
+    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 )
     end
 
     should "go up/down when asked" do
@@ -27,8 +37,8 @@ class TestFilePath < FunWith::Files::TestCase
       assert_equal f1, f2.down( "monkeylips" ).down( "ask_for_floyd" )
       assert_equal f1, f2.down( "monkeylips", "ask_for_floyd" )
       
-      #invoking down didn't change original
-      assert_no_match /ask_for_floyd/, f2.to_s
+      # invoking down didn't change original
+      refute_match( /ask_for_floyd/, f2.to_s )
     end
     
     should "convert from string" do
@@ -94,12 +104,12 @@ class TestFilePath < FunWith::Files::TestCase
         seqfile = seqfile.succ
       end
       
-      assert @tmp_dir.join("sequence.txt").exist?
-      assert @tmp_dir.join("sequence.000000.txt").exist?
-      assert @tmp_dir.join("sequence.000008.txt").exist?
+      assert_file @tmp_dir.join("sequence.txt")
+      assert_file @tmp_dir.join("sequence.000000.txt")
+      assert_file @tmp_dir.join("sequence.000008.txt")
       
-      assert_equal "0", @tmp_dir.join("sequence.txt").read
-      assert_equal "9", @tmp_dir.join("sequence.000008.txt").read
+      assert_file_contents @tmp_dir.join("sequence.txt"), "0"
+      assert_file_contents @tmp_dir.join("sequence.000008.txt"), "9"
     end
     
     should "sequence files with custom stamp length" do
@@ -110,12 +120,12 @@ class TestFilePath < FunWith::Files::TestCase
         seqfile = seqfile.succ( digit_count: 4 )
       end
       
-      assert @tmp_dir.join("sequence.txt").exist?
-      assert @tmp_dir.join("sequence.0000.txt").exist?
-      assert @tmp_dir.join("sequence.0008.txt").exist?
+      assert_file @tmp_dir.join("sequence.txt")
+      assert_file @tmp_dir.join("sequence.0000.txt")
+      assert_file @tmp_dir.join("sequence.0008.txt")
       
-      assert_equal "0", @tmp_dir.join("sequence.txt").read
-      assert_equal "9", @tmp_dir.join("sequence.0008.txt").read
+      assert_file_contents @tmp_dir.join("sequence.txt"), "0"
+      assert_file_contents @tmp_dir.join("sequence.0008.txt"), "9"
     end
     
     should "sequence files with datestamps" do
@@ -131,15 +141,26 @@ class TestFilePath < FunWith::Files::TestCase
       assert files.length == 10
       
       files.each_with_index do |file, i|
-        assert file.exist?
-        assert_equal i.to_s, file.read
+        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
   
+
+  
   context "test specify()" do
     should "just friggin' work" do
       fil = "resume.doc".fwf_filepath
@@ -163,7 +184,7 @@ class TestFilePath < FunWith::Files::TestCase
     end
     
     teardown do
-      `rm -rf #{@tmp_dir.join('*')}`
+      empty_temp_directory
     end
     
     should "md5hash a file" do
@@ -179,4 +200,18 @@ class TestFilePath < FunWith::Files::TestCase
       assert_equal( nilhashhash, file.md5 )
     end
   end
+
+  context "test access" do
+    should "receive an electric shock when it tries to touch an unwritable file" do
+      @read_only_file = "/bin/bash".fwf_filepath   # This usually exists. I don't know enough Windows to think of a similarly ubiquitous file.
+      
+      if @read_only_file.file? && ! @read_only_file.writable?
+        assert_raises( Errno::EACCES ) do
+          @read_only_file.touch
+        end
+      else
+        skip
+      end
+    end
+  end
 end

data/test/test_fun_with_files.rb

@@ -2,7 +2,7 @@ require 'helper'
 
 class TestFunWithFiles < FunWith::Files::TestCase
   context "testing basics" do
-    should "have core extensions working" do
+    should "have fwf_blank?() working" do
       assert [].fwf_blank?
       assert false.fwf_blank?
       assert Hash.new.fwf_blank?
@@ -11,5 +11,19 @@ class TestFunWithFiles < FunWith::Files::TestCase
       refute true.fwf_blank?
       refute Object.new.fwf_blank?
     end
+
+    should "have fwf_present?() working" do
+      refute [].fwf_present?
+      refute false.fwf_present?
+      refute Hash.new.fwf_present?
+      refute "".fwf_present?
+      refute "    ".fwf_present?
+      assert true.fwf_present?
+      assert Object.new.fwf_present?
+    end
+    
+    should "respond to api" do
+      assert_respond_to( FunWith::Files, :root )
+    end
   end
 end

data/test/test_globbing.rb

@@ -1,11 +1,37 @@
 require 'helper'
 
 class TestGlobbing < FunWith::Files::TestCase
-  should "glob some ruby files from the test/loadable_dir directory" do
-    assert FunWith::Files.respond_to?(:root)
-    @loadable_dir = FunWith::Files.root("test", "loadable_dir")
-    assert @loadable_dir.directory?
-    @globs = @loadable_dir.glob( :recursive => true, :ext => "rb" )
-    assert_equal 8, @globs.length
+  context "testing globbing" do
+    setup do
+      @loadable_dir = FunWith::Files.root("test", "loadable_dir")
+      assert @loadable_dir.directory?
+    
+    end
+  
+    should "glob some ruby files from the test/loadable_dir directory" do
+      globs = @loadable_dir.glob( :recursive => true, :ext => "rb" )
+      assert_equal 8, globs.length
+    end
+  
+    should "only glob the top-level when recurse is false" do
+      globs = @loadable_dir.glob( :recurse => false )
+      assert_equal( 5, globs.length )
+
+      globs = @loadable_dir.glob( :all, :recurse => false )
+      assert_equal( 5, globs.length )
+    end
+    
+    should "glob everything in the tree by default" do
+      globs = @loadable_dir.glob
+      assert_equal( 13, globs.length )
+
+      globs = @loadable_dir.glob(:all)
+      assert_equal( 13, globs.length )
+    end
+    
+    should "glob only files when an extension is given" do
+      globs = @loadable_dir.glob( :recurse => true, :ext => :rb )
+      assert_equal( 8, globs.length )
+    end
   end
 end

data/test/test_touching.rb

@@ -13,13 +13,14 @@ class TestTouching < FunWith::Files::TestCase
     
     should "touch a subdirectory" do
       @subdir = @dir.touch_dir( "Movies", "Basketball", "Shaquille" )
-      assert_kind_of FilePath, @subdir
-      assert @subdir.directory?
+      assert_fwf_filepath @subdir
+      assert_directory @subdir
       assert_equal @dir, @subdir.up.up.up
 
       @subdir_file = @dir.join( "Movies", "Basketball", "Shaquille", "JamNinja.m4v" ).touch
-      assert_kind_of FilePath, @subdir_file
-      assert @subdir_file.file?
+      
+      assert_fwf_filepath @subdir_file
+      assert_empty_file @subdir_file
       assert_equal @dir, @subdir_file.dirname.up.up.up
     end
     

metadata

@@ -1,85 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: fun_with_files
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Bryce Anderson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-04 00:00:00.000000000 Z
+date: 2014-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xdg
   requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: shoulda
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '3.5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '3.5'
-- !ruby/object:Gem::Dependency
-  name: rdoc
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '3.12'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.12'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.5'
-  type: :development
+        version: '2'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '2'
 - !ruby/object:Gem::Dependency
-  name: jeweler
+  name: fun_with_testing
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0.0'
 description: ! "  A more intuitive syntax for performing a variety of file actions.
   Examples:\n    \"/\".fwf_filepath.join('usr', 'bin', 'bash').touch\n    FunWith::Files::FilePath.home(\"Music\").glob(:ext
   => \"mp3\", :recurse => true)\n    home = FunWith::Files::FilePath.home\n    home.touch(
@@ -107,6 +65,7 @@ files:
 - ./lib/fun_with/files/file_manipulation_methods.rb
 - ./lib/fun_with/files/file_orderer.rb
 - ./lib/fun_with/files/file_path.rb
+- ./lib/fun_with/files/file_path_location_methods.rb
 - ./lib/fun_with/files/file_permission_methods.rb
 - ./lib/fun_with/files/pathname_extensions.rb
 - ./lib/fun_with/files/remote_path.rb
@@ -131,6 +90,7 @@ files:
 - ./test/loadable_dir/dir5/d.rb
 - ./test/test_copying.rb
 - ./test/test_descent.rb
+- ./test/test_digest.rb
 - ./test/test_directory_builder.rb
 - ./test/test_file_manipulation.rb
 - ./test/test_file_path.rb