fun_with_files 0.0.14 → 0.0.18

data/lib/fun_with/files/file_requirements.rb

@@ -1,22 +1,78 @@
 module FunWith
   module Files
     module FileRequirements
-      def _raise_error_if_not test, msg, error_class
-        if test
-          raise error_class.new( msg + "(file: #{self})" )
-        end
+      def needs_to_exist error_msg = "Path does not exist"
+        _raise_error_if_not self.exist?, error_msg, Errno::ENOENT
       end
       
       def needs_to_be_a_file error_msg = "Path is not a file"
+        self.needs_to_exist( error_msg + " (does not exist)" )
         _raise_error_if_not self.file?, error_msg, Errno::ENOENT
       end
       
+      def needs_to_be_readable error_msg = "Path is not readable"
+        self.needs_to_exist( error_msg + " (does not exist)" )
+        _raise_error_if_not self.writable?, error_msg, Errno::EPERM
+      end
+      
       def needs_to_be_writable error_msg = "Path is not writable"
-        _raise_error_if_not self.writable?, error_msg, Errno::ENOENT
+        self.needs_to_exist( error_msg + " (does not exist)" )
+        _raise_error_if_not self.writable?, error_msg, Errno::EPERM
       end
       
-      def needs_to_be_empty error_msg = "Path needs to point to"
-        _raise_error_if_not self.empty?, error_msg, Errno::ENOENT
+      def needs_to_be_executable error_msg = "Path is not executable"
+        self.needs_to_exist( error_msg + " (does not exist)" )
+        _raise_error_if_not self.executable?, error_msg, Errno::ENOEXEC
+      end
+      
+      # returns a different code depending on whether the path is a file
+      # or a directory.
+      def needs_to_be_empty error_msg = "Path needs to be empty"
+        self.needs_to_exist( error_msg + " (does not exist)" )
+        error_class = Errno::EOWNERDEAD                         # it's as good a code as any
+        error_class = Errno::ENOTEMPTY       if self.directory?
+        error_class = Errors::FileNotEmpty   if self.file?      # there's no libc error for "file oughta be empty"
+        
+        _raise_error_if_not self.empty?, error_msg, error_class
+      end
+      
+      def needs_to_be_a_directory error_msg = "Path is not a directory"
+        self.needs_to_exist( error_msg + " (does not exist)" )
+        _raise_error_if_not self.directory?, error_msg, Errno::ENOTDIR
+      end
+      
+      def needs_to_be( *requirements )
+        for requirement in requirements
+          case requirement
+          when :exist
+            self.needs_to_exist
+          when :readable
+            self.needs_to_be_readable
+          when :writable
+            self.needs_to_be_writable
+          when :executable
+            self.needs_to_be_executable
+          when :empty
+            self.needs_to_be_empty
+          when :directory
+            self.needs_to_be_a_directory
+          when :file
+            self.needs_to_be_a_file
+          else
+            warn "Did not understand file.needs_to_be constraint: #{arg}"
+          end
+        end
+      end
+      
+      protected
+      def _raise_error_if test, msg, error_class
+        if test
+          raise error_class.new( msg + "(file: #{self})" )
+        end
+      end
+      
+      def _raise_error_if_not test, msg, error_class
+        _raise_error_if !test, msg, error_class
       end
     end
   end

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