fun_with_files 0.0.14 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: cf6595c5de6273e8d7fb668ddc70d161a1354c4c
-  data.tar.gz: 4938516e5ad413f8ffa722985d963fcb6eb1f039
+SHA256:
+  metadata.gz: d22de5c44faf70d934da05efbd93f17373e8317bbc6304c5674c2f79183d45b2
+  data.tar.gz: 89d022cd00c4e14be9c82fc62045e82db6095e9a16239e29c085a605c0c0cde9
 SHA512:
-  metadata.gz: 09db56d93b3cde0407d1f0e7d8691ab0373158301828ee5af974c1cb259369c2f8a5c43c79eb37352760bede2d5d4d4f310887b9129aba917100109643138787
-  data.tar.gz: 06690ccc56d90230e7d8c55a9f9372cc74dc9f6ff1104fe7f8ea26c1efdb601b5ff221a0c4250630d40ab7e2a065cc71ff124545de1ed1a66405fc591ffbc49a
+  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 "jeweler", "~> 2.0"
-  # gem "debugger", "~> 1.6"
-  gem "fun_with_testing", "~> 0.0"
+  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,9 +108,9 @@ 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 Jeweler, but seems to make sense.
+Boilerplate from Juwelier, but seems to make sense.
 
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
 * Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
@@ -118,8 +120,7 @@ Boilerplate from Jeweler, 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/Rakefile

@@ -14,8 +14,8 @@ end
 
 require 'rake'
 
-# require 'jeweler'
-Jeweler::Tasks.new do |gem|
+# require 'juwelier'
+Juwelier::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"
   gem.homepage = "http://github.com/darthschmoo/fun_with_files"
@@ -50,7 +50,7 @@ DESC
               ]
 end
 
-Jeweler::RubygemsDotOrgTasks.new
+Juwelier::RubygemsDotOrgTasks.new
 
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|

data/VERSION

@@ -1 +1 @@
-0.0.14
+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/core_extensions/file.rb

@@ -1,5 +1,17 @@
-class File < IO
-  def fwf_filepath( *args )
-    FunWith::Files::FilePath.new( self.path, *args )
+module FunWith
+  module Files
+    module CoreExtensions
+      module File
+        def fwf_filepath( *args )
+          FunWith::Files::FilePath.new( self.path, *args )
+        end
+        
+        # I'm not sure this is the most intuitive meaning, but it seems better than
+        # delegating to Object.
+        def fwf_blank?
+          ! self.fwf_filepath.exist?
+        end
+      end
+    end
   end
 end

data/lib/fun_with/files/core_extensions/set.rb

@@ -0,0 +1,12 @@
+module FunWith
+  module Files
+    module CoreExtensions
+      module Set
+        def fwf_blank?
+          self.length == 0
+        end
+      end
+    end
+  end
+end
+

data/lib/fun_with/files/core_extensions/true_class.rb

@@ -0,0 +1,11 @@
+module FunWith
+  module Files
+    module CoreExtensions
+      module TrueClass
+        def fwf_blank?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/files/digest_methods.rb

@@ -1,37 +1,70 @@
 module FunWith
   module Files
+    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
+      # whether the file matches a given digest string.
+      # 
+      # Multiple digests can be given simultaneously.  All must pass.
+      #
+      # 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
+          end
+        end
+        
+        return true
+      end 
     end
   end
 end

data/lib/fun_with/files/directory_builder.rb

@@ -9,6 +9,7 @@ module FunWith
       def initialize( path )
         @paths = []
         @current_path = path.fwf_filepath
+        @current_file = nil
         make_path
       end
       
@@ -40,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 )
@@ -79,7 +83,7 @@ module FunWith
       # end
       
       # if file not given, the result is appended to the current file.
-      def download( url, file = nil )
+      def download( url, file = nil, opts = {} )
         if file
           if file.fwf_filepath.relative?
             file = FunWith::Files::FilePath.new( @current_path, file )
@@ -89,12 +93,13 @@ module FunWith
             download_to_target( url, f )
           end
         elsif @current_file
-          download_to_target( url, @current_file )
+          download_to_target( url, @current_file, opts )
         else
           puts "No current file to append #{url} to."
         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
@@ -132,8 +137,8 @@ module FunWith
         @current_file = nil
       end
       
-      def download_to_target( url, file )
-        Downloader.new.download( url, file )
+      def download_to_target( url, file, signatures = {} )
+        Downloader.new.download( url, file, signatures )
       end
     end
   end

data/lib/fun_with/files/downloader.rb

@@ -1,36 +1,49 @@
 require 'open-uri'            # needed by Utils::Downloader
 require 'net/http'
+require 'net/https'
+require 'openssl'
 require 'timeout'
 
 
 module FunWith
   module Files
     class Downloader
+      def self.download( *args )
+        self.new.download( *args )
+      end
+      
       # stolen from:
       # http://stackoverflow.com/questions/2263540/how-do-i-download-a-binary-file-over-http-using-ruby
-      def download( url, io )
+      
+      # options:
+      #    :md5 => <digest>  :  Running md5 on the downloaded file should result in an error
+      #    :sha256 => <digest> : 
+      def download( url, io, opts = {} )
         @uri = URI.parse( url )
         @io  = io
 
-        open( url ) do |f|
+        URI.open( url ) do |f|
           @io << f.read
         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
+        
+        io_path = @io.fwf_filepath
+        
+        if io_path.file?
+          if io_path.valid_digest?( opts )
+            true
+          else
+            warn( "File may not have downloaded correctly, or is validating against a bad hash #{io_path} #{opts.inspect}")
+            false
+          
+          end
+        else
+          warn( "File did not download correctly, or was deleted: #{io_path}")
+          false
+        end
+      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) : ""

data/lib/fun_with/files/file_orderer.rb

@@ -38,6 +38,8 @@ module FunWith
           
           collector
         end
+        
+        ordered_files
       end
     end
   end