fun_with_files 0.0.15 → 0.0.18

data/lib/fun_with/files/requirements/manager.rb

@@ -0,0 +1,104 @@
+module FunWith
+  module Files
+    module Requirements
+      class Manager
+        def self.require_files( path )
+          self.new( path ).require_files
+        end
+        
+        def initialize( path )
+          case path
+          when Array
+            @required_files = path
+          when FilePath
+            if path.directory?
+              @required_files = path.glob( :recursive => true, :ext => "rb" )
+            else
+              @required_files = [path]
+            end
+          end
+          
+          @required_files.map!{|f| f.expand.gsub( /\.rb$/, '' ) }
+          @successfully_required = []
+          @missing_constants = {}
+        end
+        
+        def require_files
+          while @required_files.length > 0
+            file = @required_files.shift
+            
+            if try_requiring_file( file )
+              check_for_needed_constants
+            end
+          end
+          
+          # Ran into a situation where it was failing because the missing constant was incorrectly being guessed
+          # to be M1::M2::M3::M4 instead of M1::M2::M4.  Had the file been required, it would have gone through.
+          # So I'm adding a last-chance round, using the ugly old approach of simply trying to require everything
+          # over and over again until it's clear no progress ins being made.
+          unless @missing_constants.fwf_blank?
+            unless require_files_messily( @missing_constants.values.flatten )
+              raise NameError.new( "The following constants could not be defined: #{@missing_constants.inspect}")
+            end
+          end
+        end
+        
+        # If it's not the sort of error we're looking for, re-raise the error
+        def uninitialized_constant_error( e, &block )
+          if e.message =~ /^uninitialized constant/
+            yield
+          else
+            raise e
+          end
+        end
+          
+        def try_requiring_file( file )
+          begin
+            require file
+            @successfully_required << file
+            true
+          rescue NameError => e
+            uninitialized_constant_error( e ) do
+              konst = e.message.split.last
+              
+              @missing_constants[konst] ||= []
+              @missing_constants[konst] << file
+              false
+            end
+          end
+        end
+        
+        def check_for_needed_constants
+          for konst, files in @missing_constants
+            if Object.const_defined?( konst )
+              @required_files = files + @required_files    
+              @missing_constants.delete( konst )
+            end
+          end
+        end
+        
+        # returns true if all the files given got required
+        def require_files_messily( files )
+          while true
+            files_remaining = files.length
+            return true if files_remaining == 0
+            
+            files.length.times do
+              begin
+                file = files.shift
+                require file
+                @successfully_required << file
+              rescue NameError => e
+                uninitialized_constant_error( e ) do
+                  files.push( file )
+                end
+              end
+            end
+            
+            return false if files.length == files_remaining
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/files/root_path.rb

@@ -1,12 +1,12 @@
 module FunWith
   module Files
     module RootPathExtensions
-      def root( *args )
+      def root( *args, &block )
         if args.length > 0
           args.unshift( @root_path )
-          FilePath.new( *args )
+          FilePath.new( *args, &block )
         else
-          FilePath.new( @root_path )
+          FilePath.new( @root_path, &block )
         end
       end
       

data/lib/fun_with/files/stat_methods.rb

@@ -0,0 +1,33 @@
+module FunWith
+  module Files
+    module StatMethods
+      def stat
+        File.stat( self )
+      end
+      
+      def inode
+        self.stat.ino
+      end
+      
+      # def older_than?( time, &block )
+      # end
+      #
+      # def newer_than?( time, &block )
+      # end
+      #
+      # def bigger_than?( sz, units = :B, &block )
+      # end
+      #
+      # def smaller_than?( sz, units = :B, &block )
+      # end
+      #
+      # def modified_before?( time, &block )
+      # end
+      #
+      # def modified_since?( time, &block )
+      # end
+      
+      
+    end
+  end
+end

data/lib/fun_with/files/string_behavior.rb

@@ -3,8 +3,12 @@
 module FunWith
   module Files
     module StringBehavior
-      def =~( rval )
-        @path =~ rval
+      def =~( rhs )
+        @path =~ rhs
+      end
+      
+      def !~( rhs )
+        @path !~ rhs
       end
       
       def match( *args )

data/lib/fun_with/files/utils/byte_size.rb

@@ -0,0 +1,143 @@
+module FunWith
+  module Files
+    module Utils
+      module ByteSize
+        "ideas"
+        "format:   %u - units (lowercase), %k - units (uppercase), %b - units (lower, with b), %B"
+        "          %3 - humanized value, three sigfigs, meaning that if it's under 10, you get '7.32'"
+        "               but if it's over 100, rounds to the nearest full number.  10-99, it goes"
+        "               down to the tenths prare"
+        "or just give an example: 7.32 kb"
+        
+        # format:   "your filesize is (%n.nn %u)"
+        
+        
+        UNITS = {
+          :B => 1,
+          :KB => 1_000,
+          :MB => 1_000_000,
+          :GB => 1_000_000_000,
+          :TB => 1_000_000_000_000,
+          :PB => 1_000_000_000_000_000,
+          :EB => 1_000_000_000_000_000_000,
+          :ZB => 1_000_000_000_000_000_000_000
+        }
+        
+        UNIT_STANDARDIZERS = { "" => :B, "B" => :B, "b" => :B }
+        
+        for s in %w(K M G T P E Z KB MB GB TB PB EB ZB)
+          unit_sym = s.length == 1 ? :"#{s}B" : :"#{s}"
+          UNIT_STANDARDIZERS[s]          = unit_sym
+          UNIT_STANDARDIZERS[s.downcase] = unit_sym
+          UNIT_STANDARDIZERS[s.to_sym]   = unit_sym
+        end
+        
+        def convert( expr, units = :B )
+          to_units( to_bytes( expr ), units )
+        end
+        
+        # Takes a string of the form "<NUMBER><UNIT>"
+        # and returns the number of bytes represented.
+        # See UNITS constant for valid constants
+        def to_bytes( expr )
+          regexp = /^\s*(?<num>\d+(\.\d+)?)\s*(?<unit>(k|m|g|t|p|z|)b?)\s*$/i
+          
+          if m = expr.upcase.match( regexp )
+            num   = m[:num].to_f
+            units = standardize_unit( m[:unit] )
+            # units = case units.length
+            #         when 0
+            #           :B
+            #         when 1
+            #           (units == "B" ? units : units + "B").to_sym
+            #         when 2
+            #           units.to_sym
+            #         end
+            debugger unless UNITS.has_key?(units)
+            (num * UNITS[units]).to_i
+          else
+            raise ArgumentError.new( "#{expr} is not in a format that to_bytes recognizes")
+          end
+        end
+        
+        # Looking for a human-friendly vibe more than accuracy.
+        # At most one unit of post-decimal precision, and only
+        # for small numbers.  If the tenths place is a zero,
+        # the trailing zero is dropped.
+        def to_units( byte_count, unit )
+          num = byte_count.to_f / UNITS[standardize_unit(unit)]
+          # the first comparison gets rid of leading zeros
+          # the second comparison prevents the decimal from being printed 
+          # when it doesn't make a big difference
+          if num == num.to_i || num >= 100        # 9.9k 10k
+            num_str = num.to_i.to_s
+          else
+            num_str = sprintf( "%0.01f", num )
+          end
+          
+          num_str = num_str[0..-3] if num_str[-2..-1] == ".0"
+          
+          num_str + unit.to_s
+        end
+          
+        def standardize_unit( unit )
+          # So the caller can add a space if desired, but ultimately it might be
+          # better to offer more flexible formatting options.
+          unit = unit.strip if unit.respond_to?(:strip)   
+          
+          if UNIT_STANDARDIZERS.has_key?( unit )
+            UNIT_STANDARDIZERS[unit]
+          else
+            raise ArgumentError.new( "ByteSize.to_units doesn't understand the unit #{unit.inspect}(unit.class)" )
+          end
+        end
+        
+        
+        def humanize_bytes( bytes )
+          return "?" unless bytes.is_a?( Integer ) && bytes >= 0
+    
+          bytes = bytes.to_f
+    
+          if bytes > 1_000_000_000
+            exp = "G"
+            amt = bytes / 1_000_000_000
+          elsif bytes > 1_000_000
+            exp = "M"
+            amt = bytes / 1_000_000
+          elsif bytes > 1_000
+            exp = "K"
+            amt = bytes / 1_000
+          else
+            exp = "B"
+            amt = bytes
+          end
+    
+          if amt > 10
+            digits = 0
+          elsif amt > 1
+            digits = 1
+          end
+    
+          sprintf( "%0.#{digits}f", amt ) + exp
+        end
+        
+        # returns a string of numbers, representing the float 
+        # d - number of figures after the zero (max)
+        def limited_precision_value( f, d )
+          # 4, 1234.5 -> 1234
+          # 4, 123.45 -> 123.4
+          # 4, 12.3423 -> 12.34
+          # 4, 0.0001  -> 0.0001 ->  - 1234.5, 123.45, 12.345, 1.2345 0.1234 0.0123
+          # 2 - 1234, 123, 12.3, 1.23, 0.12, 0.01
+          # 1 - 12.3, 12, 1
+          # 0 - 12, 1, 0
+          #
+          #
+          #
+          #
+          #
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/files/utils/opts.rb

@@ -0,0 +1,26 @@
+module FunWith
+  module Files
+    module Utils
+      class Opts
+        # It's tradition to pass an options hash as the last argument (creaky old tradition, named variables getting more popular)
+        # Separates out that last configuration hash, if it's been given.
+        def self.extract_opts_from_args( args )
+          if args.last.is_a?( Hash )
+            [args[0..-2], args.last ]
+          else
+            [args, {}]
+          end
+        end
+        
+        # Given a hash and a list of keys, return a hash that only includes the keys listed.
+        def self.narrow_options( opts, keys )
+          opts.keep_if{ |k,v| keys.include?( k ) }
+        end
+        
+        def self.narrow_file_utils_options( opts, cmd )
+          self.narrow_options( opts, FileUtils::OPT_TABLE[ cmd.to_s ] )
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/files/utils/succession.rb

@@ -0,0 +1,47 @@
+module FunWith
+  module Files
+    module Utils
+      class Succession
+        def self.get_successor_name( basename, digit_count )
+          pieces = basename.to_s.split(".")
+          
+          if pieces.length == 0
+            pieces = [ self.format_counter( 0, digit_count ) ]
+          elsif is_counter?( pieces.last, digit_count )
+            pieces = self.increment_position( pieces, pieces.length - 1 )
+          elsif is_counter?( pieces[-2], digit_count )
+            pieces = self.increment_position( pieces, pieces.length - 2 )
+          else
+            pieces = self.install_counter( pieces, digit_count )
+          end
+          
+          pieces.join(".")
+        end
+        
+        def self.is_counter?( str, digit_count )
+          return false if str.nil?
+          (str =~ /^\d{#{digit_count}}$/) != nil
+        end
+        
+        def self.format_counter( i, len )
+          sprintf( "%0#{len}i", i )
+        end
+        
+        def self.increment_position( arr, pos_to_increment )
+          arr.map.each_with_index do |str, i|
+            if i == pos_to_increment
+              self.format_counter( str.to_i + 1, str.length )
+            else
+              str
+            end
+          end
+        end
+        
+        def self.install_counter( arr, count )
+          counter = self.format_counter( 0, count )
+          arr[0..-2] + [counter] + [arr[-1]]
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/files/utils/timestamp.rb

@@ -0,0 +1,47 @@
+module FunWith
+  module Files
+    module Utils
+      class Timestamp
+        # Currently exactly one format is supported.  Laaaaame!
+        
+        def self.format( key )
+          @formats ||= {
+            :default => TimestampFormat.new.recognizer( /^\d{17}$/ ).strftime("%Y%m%d%H%M%S%L"),
+            :ymd     => TimestampFormat.new.recognizer( /^\d{4}-\d{2}-\d{2}$/ ).strftime("%Y-%m-%d"),
+            :ym      => TimestampFormat.new.recognizer( /^\d{4}-\d{2}$/ ).strftime("%Y-%m"),
+            :y       => TimestampFormat.new.recognizer( /^\d{4}$/ ).strftime("%Y"),
+            
+            # UNIX timestamp
+            :s       => TimestampFormat.new.recognizer( /^\d{10}$/ ).strftime("%s")
+          }
+          
+          if @formats.has_key?(key)
+            @formats[key]
+          else
+            raise Errors::TimestampFormatUnrecognized.new( "Unrecognized timestamp format (#{key.inspect}).  Choose from #{@formats.keys.inspect}" )
+          end
+        end
+        
+        def self.timestamp( basename, format: :default, splitter: ".", time: Time.now )
+          filename_chunks = basename.to_s.split( splitter )
+          format = format.is_a?( TimestampFormat ) ? format : self.format( format )
+          new_timestamp = format.format_time( time )
+          
+          timestamp_index = filename_chunks.map.each_with_index{ |str,i| 
+            format.matches?( str ) ? i : nil
+          }.compact.last
+          
+          if timestamp_index
+            filename_chunks[timestamp_index] = new_timestamp
+          elsif filename_chunks.length == 1
+            filename_chunks << new_timestamp
+          else
+            filename_chunks.insert( -2, new_timestamp )
+          end
+          
+          filename_chunks.join( splitter )
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/files/utils/timestamp_format.rb

@@ -0,0 +1,31 @@
+module FunWith
+  module Files
+    module Utils
+      class TimestampFormat
+        # the timestamp identifies a chunk of the filename
+        # to be its kind of timestamp by checking it against a 
+        # regular expression.  
+        def recognizer( regex )
+          @recognizer = regex
+          self
+        end
+        
+        # The strftime format used to output the timestamp
+        def strftime( s )
+          @strftime_format = s
+          self
+        end
+        
+        def format_time( t )
+          t.strftime( @strftime_format )
+        end
+        
+        # does the given chunk look like a timestamp using this format?
+        # returns true or false.  
+        def matches?( str, &block )
+          @recognizer.match( str ) != nil
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/files/watcher.rb

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

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

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