fun_with_files 0.0.15 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6d1ccc274aea1937c63f81c2fe7897349aadbdc9
-  data.tar.gz: 5ae174de323cfa4aba42d459b5848416c173bcfa
+SHA256:
+  metadata.gz: d22de5c44faf70d934da05efbd93f17373e8317bbc6304c5674c2f79183d45b2
+  data.tar.gz: 89d022cd00c4e14be9c82fc62045e82db6095e9a16239e29c085a605c0c0cde9
 SHA512:
-  metadata.gz: 8125f7794e66f690c5180e88f6d827463d251878417e1689e2360bac84ad9d9909530a2c299409468558320817763a2d66ac4bf45308e6cacdca26363a63eda4
-  data.tar.gz: 13c43cb5c978693715ffa1a21c72c07c464eaab0deb4260826b49d120748967ed7fd20c65234888347a2a96ab59529a6517a10c304dc99d9cf0bae33046661c1
+  metadata.gz: b8fb4d70f1bc7c29439b7237e38e79f5661334fd7c8c3457f5ae1bde20b053eb95dccd5d8c5ad3bf3a4f16443375ace9f889822116680b136d154e53ab118411
+  data.tar.gz: fdd5d8bc41b89c5e0a4f3c83580f4f45679cb3bc38ee9539f332f1a26572cf68ffd549b7118787f6068d1247711cafe175cf7389a0aff1532cf6407c96384ba7

data/CHANGELOG.markdown

@@ -1,13 +1,25 @@
 CHANGELOG
 =========
 
+v0.0.18
+-------
+
+* restricted the use of the file.succ() method, and removed timestamp functionality from it.  Now it only works if the initial file has an extension (no trailing counter, like file.000001 ).  Still fills in
+
+v0.0.17
+-------
+
+* `.without_ext()` now takes an argument, will only strip that extension.
+* updated `fun_with_testing` dependency, moved FunWith::Files-related stuff from that gem to this one.
+
+
 v0.0.14
-=======
+-------
 
-Make symlinking actually work in a sensible way.
+???
 
 v0.0.12
-=======
+-------
 
 FilePath.touch() takes same options as FileUtils.touch()
 FilePath.glob() now takes a block (yields files one at a time)

data/Gemfile

@@ -7,12 +7,22 @@ source "http://rubygems.org"
 # Include everything needed to run rake, tests, features, etc.
 
 group :development do
-  # gem "shoulda", "~> 3", ">= 3.5"
-  # gem "rdoc", "~> 3.12"
-  # gem "bundler", "~> 1.5"
-  # gem "juwelier", "~> 2.0"
-  # gem "debugger", "~> 1.6"
-  gem "fun_with_testing", "~> 0.0", ">= 0.0.5"
+  gem "debug"
+  gem "fun_with_testing", "~> 0.0", ">= 0.0.7"
 end
 
-gem "xdg", "~> 2"
+
+xdg_version = case RUBY_VERSION
+              when /^2\.7/
+                3
+              when /^3\.0/
+                5
+              when /^3\.2/
+                7
+              end
+
+
+              
+gem "xdg", "~> #{xdg_version}"
+
+

data/{README.rdoc → README.markdown}

@@ -1,4 +1,7 @@
-= fun_with_files =
+# `fun_with_files` 
+
+
+
 
 FunWith::Files adds a bit of whimsy to your file manipulations, if that's what you're looking for.
 
@@ -36,18 +39,17 @@ To the code!
     
 
 
-=== Linking files ===
+### Linking files ###
 
 While fwf.symlink and fwf.link are both backed by FileUtils.ln / FileUtils.ln_s, the defaults are somewhat different
 
 
 
-== DirectoryBuilder ==
+## DirectoryBuilder ##
 
 DirectoryBuilder is a class for defining and populating a file hierarchy with relative ease.  DirectoryBuilder is probably most easily demonstrated by example.  Sample code:
 
-    # starts by creating directory.  If parent 
-    # directories don't exist, they will soon.
+    # starts by creating directory.  If parent directories don't exist, they will soon.
     DirectoryBuilder.create( '~/project' ) do |b|
       b.dir("images") do                      # creates subdirectory "images", which gets populated within the block
         for img in src_dir.entries.select{|img| img.extension == ".png"}
@@ -60,7 +62,7 @@ DirectoryBuilder is a class for defining and populating a file hierarchy with re
 
       b.dir("text", "scenes") do   # creates ~/project/text/scenes subdir (creating two new directories text/ and text/scene/)
         b.file( "adventure_time.txt" ) do |f|
-          f << "Fill this in later"
+          f << "Fill this in later"             # text is written to the file
         end
 
         # calling .file without feeding it a block leaves it open for writing,
@@ -106,7 +108,7 @@ DirectoryBuilder is a class for defining and populating a file hierarchy with re
     
 
 
-== Contributing to fun_with_files
+## Contributing to fun_with_files ##
 
 Boilerplate from Juwelier, but seems to make sense.
 
@@ -118,8 +120,7 @@ Boilerplate from Juwelier, but seems to make sense.
 * Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
 * Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
 
-== Copyright
+## Copyright ##
 
-Copyright (c) 2013 Bryce Anderson. See LICENSE.txt for
-further details.
+Copyright (c) 2020 Bryce Anderson. See LICENSE.txt for further details.
 

data/VERSION

@@ -1 +1 @@
-0.0.15
+0.0.18

data/lib/fun_with/files/bootstrapper.rb

@@ -0,0 +1,87 @@
+module FunWith
+  module Files
+    class Bootstrapper
+      def self.bootstrap
+        self.new.bootstrap
+      end
+      
+      def bootstrap
+        load_core_extensions
+        install_minimal_requir_functionality
+        run_requir
+        rootify
+        add_filepath_class_methods
+        extend_gem_api
+      end
+      
+      protected
+      # gets all the core-extending modules from fun_with/files/core_extensions and uses them to
+      # beef up the core classes
+      def load_core_extensions
+        for file in Dir.glob( File.join( __dir__, "core_extensions", "*.rb" ) )
+          # remove trailing extension to make it require-friendly.
+          file = file.gsub(/\.rb$/,'')
+          
+          require_relative file
+          
+          # convert filename into class name
+          target_class_str = filename_to_class_name( file )
+          
+          # get the core class that needs extending, and the 
+          target_class = Kernel.const_get( target_class_str )
+          mixin_class  = Kernel.const_get( "FunWith::Files::CoreExtensions::#{target_class_str}" )
+          
+          target_class.send( :include, mixin_class )
+        end
+      end
+      
+      def install_minimal_requir_functionality
+        for fil in %w( file_path
+                       string_behavior
+                       file_manipulation_methods
+                       file_permission_methods
+                       digest_methods
+                       file_requirements
+                       requirements/manager
+                       stat_methods )
+          require_relative 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::StatMethods ]
+          FunWith::Files::FilePath.send( :include, mod )
+        end
+      end
+      
+      def run_requir
+        lib_dir = __dir__.fwf_filepath.up
+        
+        # And requir() everything else
+        lib_dir.requir
+      end
+      
+      def rootify
+        root_dir = __dir__.fwf_filepath.up.up.up
+        FunWith::Files::RootPath.rootify( FunWith::Files, root_dir )
+      end
+      
+      def add_filepath_class_methods
+        FunWith::Files::FilePath.extend( FunWith::Files::FilePathClassMethods )
+      end
+      
+      def extend_gem_api
+        FunWith::Files.extend( FunWith::Files::GemAPI )
+      end
+      
+      
+      def filename_to_class_name( str )
+        File.basename( str ).split( "_" ).map(&:capitalize).join("")
+      end
+    end
+  end
+end

data/lib/fun_with/files/digest_methods.rb

@@ -3,36 +3,47 @@ module FunWith
     DIGEST_METHODS = [:md5, :sha1, :sha2, :sha224, :sha256, :sha384, :sha512]
     
     module DigestMethods
-      def md5
-        digest( Digest::MD5 )
+      def md5( bytes = :all, offset = 0 )
+        digest( Digest::MD5, bytes, offset )
       end
       
-      def sha1
-        digest( Digest::SHA1 )
+      def sha1( bytes = :all, offset = 0 )
+        digest( Digest::SHA1, bytes, offset )
       end
       
-      def sha2
-        digest( Digest::SHA2 )
+      def sha2( bytes = :all, offset = 0 )
+        digest( Digest::SHA2, bytes, offset )
       end
 
-      def sha224
-        digest( Digest::SHA224 )
+      def sha224( bytes = :all, offset = 0 )
+        digest( Digest::SHA224, bytes, offset )
       end
 
-      def sha256
-        digest( Digest::SHA256 )
+      def sha256( bytes = :all, offset = 0 )
+        digest( Digest::SHA256, bytes, offset )
       end
 
-      def sha384
-        digest( Digest::SHA384 )
+      def sha384( bytes = :all, offset = 0 )
+        digest( Digest::SHA384, bytes, offset )
       end
       
-      def sha512
-        digest( Digest::SHA512 )
+      def sha512( bytes = :all, offset = 0 )
+        digest( Digest::SHA512, bytes, offset )
       end
       
-      def digest( digest_class = Digest::MD5 )
-        self.file? ? digest_class.hexdigest( self.read ) : ""
+      def digest( digest_class = Digest::MD5, bytes = :all, offset = 0  )
+        if self.file? && self.readable?
+          if bytes == :all
+            digest_class.hexdigest( self.read )
+          elsif bytes.is_a?( Integer )
+            digest_class.hexdigest( self.read( bytes, offset ) )
+          else
+            raise ArgumentError.new( "FunWith::Files::DigestMethods.digest() error: bytes argument must be an integer or :all")
+          end
+        else
+          raise IOError.new( "Not a file: #{self.path}" ) unless self.file?
+          raise IOError.new( "Not readable: #{self.path}" ) unless self.readable?
+        end
       end
       
       # Takes any of the above-named digest functions, determines
@@ -43,6 +54,9 @@ module FunWith
       # TODO: how to get around the :md6 problem?  That is, where the
       # user is sending the wrong key, and hence not getting false back
       def valid_digest?( opts )
+        digest_opts = Utils::Opts.narrow_options( opts, DIGEST_METHODS )
+        
+        
         for method, digest in opts
           if DIGEST_METHODS.include?( method )
             return false unless self.send( method ) == digest

data/lib/fun_with/files/directory_builder.rb

@@ -41,6 +41,9 @@ module FunWith
       
       # Copies the given source file into a file in the current_path.
       # If a dest_name is given, the new file will be given that name.
+      #
+      # TODO: Improve testing, explain behavior better, need a way to distinguish between 
+      # forceful and gentle copying
       def copy( src_filepath, dst_name = nil )
         dst_filepath = dst_name ? @current_path.join( dst_name ) : @current_path
         FileUtils.copy( src_filepath, dst_filepath )
@@ -96,6 +99,7 @@ module FunWith
         end
       end
       
+      # The actual method is installed by 'fun_with_templates'
       def template( *args )
         raise "DirectoryBuilder cannot use template() function.  require 'fun_with_templates' to enable."
       end

data/lib/fun_with/files/downloader.rb

@@ -22,7 +22,7 @@ module FunWith
         @uri = URI.parse( url )
         @io  = io
 
-        open( url ) do |f|
+        URI.open( url ) do |f|
           @io << f.read
         end
         
@@ -40,26 +40,10 @@ module FunWith
           warn( "File did not download correctly, or was deleted: #{io_path}")
           false
         end
-        
-        # @io << Net::HTTP.get( @uri )
-
-        # Net::HTTP.start( @uri.host, @uri.port ) do |http| 
-        #   http.request_get( @uri.path ) do |request| 
-        #     request.read_body do |seg|
-        #       puts "==============================  #{seg} ============================="
-        #       io << seg
-        #       #hack -- adjust to suit:
-        #       sleep 0.005 
-        #     end
-        #   end
-        # end
-        
-        
-        
-        
-      rescue Exception => e
+      rescue StandardError => e
         handle_network_errors( e )
       end
+      
 
       def handle_network_errors( e )
         raise e

data/lib/fun_with/files/errors.rb

@@ -1,5 +1,13 @@
 module FunWith
   module Files
-    class NoSuchFile < Exception; end
+    # Useful... why, exactly?
+    module Errors
+      class Error < StandardError; end
+      class SuccessionFormattingError < Error; end
+      class TimestampFormatUnrecognized < Error; end
+      class FileNotEmpty < Error; end
+      class NotADirectory < Error; end
+      class NotAFile < Error; end
+    end
   end
 end

data/lib/fun_with/files/file_manipulation_methods.rb

@@ -15,6 +15,12 @@ module FunWith
       # ln_s(list, destdir, options)
       # ln_sf(src, dest, options)
       
+      # 
+      
+      
+     # => [:alias_method, :ancestors, :attr, :attr_accessor, :attr_reader, :attr_writer, :autoload, :autoload?, :cd, :chdir, :chmod, :chmod_R, :chown, :chown_R, :class_eval, :class_exec, :class_variable_defined?, :class_variable_get, :class_variable_set, :class_variables, :cmp, :collect_method, :commands, :compare_file, :compare_stream, :const_defined?, :const_get, :const_missing, :const_set, :constants, :copy, :copy_entry, :copy_file, :copy_stream, :cp, :cp_r, :define_method, :deprecate_constant, :getwd, :have_option?, :identical?, :include, :include?, :included_modules, :install, :instance_method, :instance_methods, :link, :ln, :ln_s, :ln_sf, :makedirs, :method_defined?, :mkdir, :mkdir_p, :mkpath, :module_eval, :module_exec, :move, :mv, :name, :options, :options_of, :prepend, :private_class_method, :private_constant, :private_instance_methods, :private_method_defined?, :private_module_function, :protected_instance_methods, :protected_method_defined?, :public_class_method, :public_constant, :public_instance_method, :public_instance_methods, :public_method_defined?, :pwd, :remove, :remove_class_variable, :remove_dir, :remove_entry, :remove_entry_secure, :remove_file, :remove_method, :rm, :rm_f, :rm_r, :rm_rf, :rmdir, :rmtree, :safe_unlink, :singleton_class?, :symlink, :touch, :undef_method, :uptodate?] 
+      
+      
       # opts are the last argument, and are passed to FileUtils.cp_r
       # returns the destination path.
       # How to detect failure?  What to return on failure?
@@ -22,16 +28,22 @@ module FunWith
       # 
       def cp( *args )
         destination_and_options( args ) do |dest, opts|
-          FileUtils.cp_r( self, dest, narrow_options( opts, FileUtils::OPT_TABLE["cp_r"] ) )
+          FileUtils.cp_r( self, dest, ** Utils::Opts.narrow_file_utils_options( opts, :cp_r ) )
           dest.fwf_filepath
         end
       end
       
       alias :copy :cp
       
-      # Treat as a copy then a delete?  Nah, that's a lot slower in some cases.  Should be much more in tune with what the command line program does
-      def mv( *args )
-        
+      # Treat as a copy then a delete?  Nah, that's a lot slower especially for larger files.  Should be much more in tune with what the command line program does.
+      # Treat it as syntactic sugar for FileUtils.mv?
+      # Also want to update the path to the new location - not implemented yet
+      #
+      # 
+      def mv( dst, options = {} )
+        # what does FileUtils.rm actually return?  Glancing an the source, it
+        # seems to only throw errors.
+        FileUtils.mv( self, dst, **options )
       end
       
       alias :move :mv
@@ -45,13 +57,11 @@ module FunWith
       def link *args
         self.destination_and_options( args ) do |lnk, opts|
           symlink_requested = self.directory? || opts[:symbolic] || opts[:sym] || opts[:soft]
-        
+          
           if symlink_requested
             self.symlink lnk, opts
           else
-            opts = narrow_options opts, FileUtils::OPT_TABLE["ln"]
-            
-            FileUtils.ln self, lnk, opts
+            FileUtils.ln self, lnk, ** Utils::Opts.narrow_file_utils_options( opts, :ln )
           end
           
           lnk.fwf_filepath
@@ -78,7 +88,7 @@ module FunWith
           lnk = lnk.fwf_filepath
         end
         
-        FileUtils.ln_s( self, lnk, narrow_options( opts, FileUtils::OPT_TABLE["ln_s"] ) )
+        FileUtils.ln_s( self, lnk, ** Utils::Opts.narrow_file_utils_options( opts, :ln_s ) )
         lnk.fwf_filepath
       end
       
@@ -86,7 +96,7 @@ module FunWith
       
       
       def file_gsub( *args, &block )
-        _must_be_a_file
+        must_be_file
         
         lines = []
         self.each_line do |line|
@@ -97,8 +107,8 @@ module FunWith
       end
       
       def file_gsub!( *args, &block )
-        _must_be_a_file      # raises error
-        _must_be_writable    # raises error
+        must_be_file      # raises error
+        must_be_writable    # raises error
         
         self.write( self.file_gsub( *args, &block ) )
       end
@@ -113,9 +123,9 @@ module FunWith
       
       # TODO: If it's truncated to a longer length than the original file,
       # pad with zeros?  That's how the UNIX truncate command works.
-      def truncate( len )
-        _must_be_a_file     # raises error
-        _must_be_writable   # raises error
+      def truncate( len = 0 )
+        must_be_file     # raises error
+        must_be_writable   # raises error
         
         old_size = self.size
         padding = len > old_size ? "\0" * (len - old_size) : ""