amp 0.5.2 → 0.5.3

data/lib/amp/repository/mercurial/repo_format/staging_area.rb

@@ -0,0 +1,367 @@
+module Amp
+  module Repositories
+    module Mercurial
+      class StagingArea < AbstractStagingArea
+        
+        attr_reader :dirstate
+        attr_reader :repo
+        alias_method :repository, :repo
+        attr_accessor :vcs_dir
+        
+        def initialize(repo)
+          @ignore_all = nil
+          @repo = repo
+          @check_exec = false
+          @vcs_dir = '.hg'
+        end
+        
+        ######### API Methods #################################################
+        
+        ##
+        # Adds a list of file paths to the repository for the next commit.
+        # 
+        # @api
+        # @param [String, Array<String>] paths the paths of the files we need to
+        #   add to the next commit
+        # @return [Array<String>] which files WEREN'T added
+        def add(*files)
+          rejected = []
+          files.flatten!
+          
+          repo.lock_working do
+            files.each do |file|
+              path = repo.working_join file
+              stat = File.exist?(path) && File.lstat(path)
+              
+              if !stat
+                UI.warn "#{file} does not exist!"
+                rejected << file
+              elsif File.ftype(path) != 'file' && File.ftype(path) != 'link'
+                UI.warn "#{file} not added: only files and symlinks supported. Type is #{File.ftype path}"
+                rejected << path
+              else
+                if stat.size > 10.mb
+                  UI.warn "#{file}: files over 10MB may cause memory and performance problems\n" +
+                              "(use 'amp revert #{file}' to unadd the file)\n"
+                end
+                dirstate.add file
+              end
+            end
+            dirstate.write unless rejected.size == files.size
+          end
+          rejected
+        end
+        
+        ##
+        # Removes the file (or files) from the repository. Marks them as removed
+        # in the DirState, and if the :unlink option is provided, the files are
+        # deleted from the filesystem.
+        #
+        # @api
+        # @param list the list of files. Could also just be 1 file as a string.
+        #   should be paths.
+        # @param opts the options for this removal.
+        # @option [Boolean] opts :unlink (false) whether or not to delete the
+        #   files from the filesystem after marking them as removed from the
+        #   DirState.
+        # @return [Boolean] success?
+        def remove(*args)
+          list = args.last.is_a?(Hash) ? args[0..-2].flatten : args[0..-1].flatten
+          opts = args.last.is_a?(Hash) ? args.last : {}
+          # Should we delete the filez?
+          if opts[:unlink]
+              FileUtils.safe_unlink list.map {|f| repo.working_join(f)}
+          end
+          
+          repo.lock_working do
+            # Save ourselves a dirstate write
+            successful = list.any? do |f|
+              if opts[:unlink] && File.exists?(repo.working_join(f))
+                # Uh, why is the file still there? Don't remove it from the dirstate
+                UI.warn("#{f} still exists!")
+                false # no success
+              else
+                dirstate.remove f
+              end
+            end
+            
+            # Write 'em out boss
+            dirstate.write if successful
+          end
+          
+          true
+        end
+        
+        ##
+        # Set +file+ as normal and clean. Un-removes any files marked as removed, and
+        # un-adds any files marked as added.
+        # 
+        # @param  [Array<String>] files the name of the files to mark as normal
+        # @return [Boolean] success marker
+        def normal(*files)
+          files.each do |file|
+            dirstate.normal(file)
+          end
+          dirstate.write
+        end
+        
+        ##
+        # Copies a file from +source+ to +destination+, while being careful of the
+        # specified options. This method will perform all necessary file manipulation
+        # and dirstate changes and so forth. Just give 'er a source and a destination.
+        #
+        # @api
+        # @param [String] source the path to the source file
+        # @param [String] destination the path to the destination file
+        # @param [Hash] opts the options for the copy
+        # @option [Boolean] opts :after (false) should the file be deleted?
+        # @return [Boolean] success?
+        def copy(source, destination, opts)
+          # Traverse repository subdirectories
+          src    = repo.relative_join source
+          target = repo.relative_join destination
+          
+          # Is there a tracked file at our destination? If so, get its state.
+          state = dirstate[target].status
+          # abstarget is the full path to the target. Needed for system calls
+          # (just to be safe)
+          abstarget = repo.working_join target
+          
+          # If true, we're copying into a directory, so be smart about it.
+          if File.directory? abstarget
+            abstarget = File.join abstarget, File.basename(src)
+            target    = File.join target, File.basename(src)
+          end
+          abssrc = repo.working_join(src)
+          
+          
+          exists = File.exist? abstarget
+          # If the file's there, and we aren't forcing the copy, then we should let
+          # the user know they might overwrite an existing file in the repo.
+          if (!opts[:after] && exists || opts[:after] && [:merged, :normal].include?(state))
+            unless opts[:force]
+              Amp::UI.warn "#{target} not overwriting, file exists"
+              return false
+            end
+          end
+          
+          return if opts[:after] && !exists
+          unless opts[:"dry-run"]
+            # Performs actual file copy from one locatino to another.
+            # Overwrites file if it's there.
+            begin
+              File.safe_unlink(abstarget) if exists
+              
+              target_dir = File.dirname abstarget
+              File.makedirs target_dir unless File.directory? target_dir
+              File.copy(abssrc, abstarget)
+            rescue Errno::ENOENT
+              # This happens if the file has been deleted between the check up above
+              # (exists = File.exist? abstarget) and the call to File.safe_unlink.
+              Amp::UI.warn("#{target}: deleted in working copy in the last 2 microseconds")
+            rescue StandardError => e
+              Amp::UI.warn("#{target} - cannot copy: #{e}")
+              return false
+            end
+          end
+          
+          # Be nice and give the user some output
+          if opts[:verbose] || opts[:"dry-run"]
+            action = opts[:rename] ? "moving" : "copying"
+            Amp::UI.status("#{action} #{src} to #{target}")
+          end
+          return false if opts[:"dry-run"]
+          
+          # in case the source of the copy is marked as the destination of a 
+          # different copy (that hasn't yet been committed either), we should
+          # do some extra handling
+          origsrc = dirstate.copy_map[src] || src
+          if target == origsrc
+            # We're copying back to our original location! D'oh.
+            unless [:merged, :normal].include?(state)
+              dirstate.maybe_dirty target
+            end
+          else
+            if dirstate[origsrc].added? && origsrc == src
+              # we copying an added (but uncommitted) file?
+              UI.warn("#{origsrc} has not been committed yet, so no copy data" +
+                      "will be stored for #{target}")
+              if [:untracked, :removed].include?(dirstate[target].status)
+                add target
+              end
+            else
+              dirstate_copy src, target
+            end
+          end
+          
+          # Clean up if we're doing a move, and not a copy.
+          remove(src, :unlink => !(opts[:after])) if opts[:rename]
+        end
+        
+        ##
+        # Copy a file from +source+ to +dest+. Really simple, peeps.
+        # The reason this shit is even *slightly* complicated because
+        # it deals with file types. Otherwise I could write this
+        # in, what, 3 lines?
+        # 
+        # @param [String] source the from
+        # @param [String] dest the to
+        def dirstate_copy(source, dest)
+          path = repo.working_join dest
+          
+          if !File.exist?(path) || File.ftype(path) == 'link'
+            UI::warn "#{dest} doesn't exist!"
+          elsif not (File.ftype(path) == 'file' || File.ftype(path) == 'link')
+            UI::warn "copy failed: #{dest} is neither a file nor a symlink"
+          else
+            repo.lock_working do
+              # HOME FREE!!!!!!! i love getting out of school before noon :-D
+              # add it if it makes sense (like it was previously removed or untracked)
+              # and then copy da hoe
+              state  = dirstate[dest].status
+              dirstate.add dest if [:untracked, :removed].include?(state)
+              dirstate.copy source => dest
+              dirstate.write
+              
+              #Amp::Logger.info("copy #{source} -> #{dest}")
+            end
+          end
+        end
+        
+        ##
+        # Marks a modified file to be included in the next commit.
+        # If your VCS does this implicitly, this should be defined as a no-op.
+        #
+        # Mercurial: This is a no-op unless the specified files are not already
+        # in the repository, so we should add them to the repo in that case.
+        # 
+        # @api
+        # @param [[String]] filenames a list of files to include for committing
+        # @return [Boolean] true for success, false for failure
+        def include(*filenames)
+          to_add = []
+          
+          filenames.each do |filename|
+            unless dirstate[filename]
+              to_add << filename
+            end
+          end
+          
+          add to_add if to_add.any?
+        end
+        
+        ##
+        # Returns a Symbol.
+        # Possible results:
+        # :added (subset of :included)
+        # :removed
+        # :untracked
+        # :included
+        # :normal
+        #
+        def file_status(filename)
+          dirstate[filename].status
+        end
+        
+        ##
+        # Returns whether or not the repository is tracking the given file.
+        #
+        # @param [String] filename the file to look up
+        # @return [Boolean] are we tracking the given file?
+        def tracking?(filename)
+          dirstate.tracking? filename
+        end
+        
+        ##
+        # Returns all files tracked by the repository *for the working directory* - not
+        # to be confused with the most recent changeset.
+        #
+        # @return [Array<String>] all files tracked by the repository at this moment in
+        #   time, including just-added files (for example) that haven't been committed yet.
+        def all_files
+          dirstate.all_files
+        end
+        
+        ######### Optional API Methods ########################################
+        
+        ##
+        # Returns whether the given directory is being ignored. Optional method - defaults to
+        # +false+ at all times.
+        #
+        # @api-optional
+        # @param [String] directory the directory to check against ignoring rules
+        # @return [Boolean] are we ignoring this directory?
+        def ignoring_directory?(directory)
+          return true  if @ignore_all
+          return false if @ignore_all == false
+          dirstate.ignoring_directory? directory
+        end
+
+        ##
+        # Returns whether the given file is being ignored. Optional method - defaults to
+        # +false+ at all times.
+        #
+        # @api-optional
+        # @param [String] file the file to check against ignoring rules
+        # @return [Boolean] are we ignoring this file?
+        def ignoring_file?(file)
+          return true  if @ignore_all
+          return false if @ignore_all == false
+          dirstate.ignore file
+        end
+        
+        ##
+        # Retrives the dirstate from the staging_area. The staging area is reponsible
+        # for properly maintaining the dirstate.
+        #
+        # @return [DirState]
+        def dirstate
+          return @dirstate if @dirstate ||= nil # the "||= nil" kills undefined ivar warning 
+          
+          opener = Amp::Opener.new repo.root
+          opener.default = :open_hg
+          
+          @dirstate = DirState.new(repo.root, repo.config, opener)
+          @dirstate.read!
+        end
+        
+        ##
+        # Calculates the difference (in bytes) between a file and its last tracked state.
+        #
+        # Supplements the built-in #status method so that its output will include deltas.
+        #
+        # @apioptional
+        # @param [String] file the filename to look up
+        # @param [File::Stats] st the current results of File.lstat(file)
+        # @return [Fixnum] the number of bytes difference between the file and
+        #  its last tracked state.
+        def calculate_delta(file, st)
+          state, mode, size, time = dirstate.files[file].to_a
+          st && size >= 0 ? (size - st.size).abs : 0 # increase the delta, but don't forget to check that it's not nil
+        end
+        
+        ##
+        # Does a detailed look at a file, to see if it is clean, modified, or needs to have its
+        # content checked precisely.
+        #
+        # Supplements the built-in #status method so that its output will be more
+        # accurate.
+        #
+        # @param [String] file the filename to look up
+        # @param [File::Stats] st the current results of File.lstat(file)
+        # @return [Symbol] a symbol representing the current file's status
+        def file_precise_status(file, st)
+          state, mode, size, time = dirstate.files[file].to_a
+          if (size >= 0 && (size != st.size || ((mode ^ st.mode) & 0100 and @check_exec))) || size == -2 || dirstate.copy_map[file]
+            return :modified
+          elsif time != st.mtime.to_i # DOH - we have to remember that times are stored as fixnums
+            return :lookup
+          else
+            return :clean
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/amp/repository/mercurial/repo_format/store.rb

@@ -0,0 +1,487 @@
+module Amp
+  module Repositories
+    module Mercurial
+      module Stores
+        extend self
+        class StoreError < StandardError; end
+        # Picks which store to use, given a list of requirements.
+        def pick(requirements, path, opener, pathjoiner=nil)
+          pathjoiner ||= proc {|*args| File.join(args) }
+          if requirements.include? 'store'
+            if requirements.include? 'fncache'
+              return FilenameCacheStore.new(path, opener, pathjoiner)
+            else
+              return EncodedStore.new(path, EncodedOpener, pathjoiner)
+            end
+          else
+            return BasicStore.new(path, opener, pathjoiner)
+          end
+        end
+        
+        ##
+        # = BasicStore
+        # This class is the one from which all other stores derive. It implements
+        # basic methods #walk, #join, #datafiles, and #copy_list which are the
+        # public methods for all stores. All others are basically internal.
+        class BasicStore
+          BASIC_DATA_FILES = %W(data 00manifest.d 00manifest.i 00changelog.d  00changelog.i)
+          
+          attr_accessor :path_joiner
+          attr_reader :path
+          attr_reader :opener
+          attr_reader :create_mode
+          
+          def initialize(path, openerklass, pathjoiner)
+            @path_joiner, @path = pathjoiner, path
+            @create_mode = calculate_mode path
+            @opener = openerklass.new(@path)
+            @opener.create_mode = @create_mode
+            #@opener.default = :open_hg
+          end
+          
+          ##
+          # Joins the file _f_ to the store's base path using the path-joiner.
+          # 
+          # @param [String] f the filename to join to the store's base path
+          # @return the combined base path and file path
+          def join(f)
+            @path_joiner.call(@path, f)
+          end
+          
+          ##
+          # Iterates over every file tracked in the store and yield it.
+          # 
+          # @yield [file] every file in the store
+          # @yieldparam [String] file the filepath to an entry in the store
+          def walk
+            datafiles do |x|
+              yield x
+            end
+            
+            meta = do_walk '', false
+            meta.reverse.each do |x|
+              yield x
+            end
+          end
+          
+          ##
+          # Returns all the data files in the store.
+          def datafiles
+            do_walk('data', true)
+          end
+          
+          ##
+          # Basic walker that is not very smart at all. It can recursively search
+          # for data files, but it actually uses a queue to do its searching.
+          # 
+          # @param [String] relpath the base path to search
+          # @param [Boolean] recurse (false) whether or not to recursively
+          #   search each discovered directory.
+          # @return [(String, String, Fixnum)] Each entry is returned in the form
+          #   [filepath, filepath, filesize]
+          def do_walk(relpath, recurse=false)
+            path = join relpath
+            stripped_len = path.size + File::SEPARATOR.size - 1
+            list = []
+            if File.directory?(path)
+              to_visit = [path]
+              while to_visit.any?
+                p = to_visit.shift
+                Dir.stat_list(p, true) do |file, kind, stat|
+                  fp = join(file)
+                  if kind =~ /file/ && ['.d','.i'].include?(file[-2..-1])
+                    n = fp[stripped_len..-1]
+                    list << [n, n, stat.size]
+                  elsif kind =~ /directory/ && recurse
+                    to_visit << fp
+                  end
+                end
+              end
+            end
+            list.sort
+          end
+          
+          ##
+          # Calculates the mode for the user on the file at the given path.
+          # I guess this saves some wasted chmods.
+          # 
+          # @param [String] path the path to calculate the mode for
+          # @return [Fixnum] the mode to use for chmod. Octal, like 0777
+          def calculate_mode(path)
+            begin
+              mode = File.stat(path).mode
+              if (0777 & ~Amp::Support.UMASK) == (0777 & mode)
+                mode = nil
+              end
+            rescue
+              mode = nil
+            end
+            mode
+          end
+          
+          ##
+          # Returns the list of basic files that are crucial for the store to
+          # function.
+          #
+          # @return [Array<String>] the list of basic files crucial to this class
+          def copy_list
+            ['requires'] + BASIC_DATA_FILES
+          end
+        end
+        
+        ##
+        # = EncodedOpener
+        # This opener uses the Stores' encoding function to modify the filename
+        # before it is loaded.
+        class EncodedOpener < Amp::Opener
+          
+          ##
+          # Overrides the normal opener method to use encoded filenames.
+          def open(f, mode="r", &block)
+            super(Stores.encode_filename(f), mode, &block)
+          end
+        end
+        
+        ##
+        # = EncodedStore
+        # This version of the store uses encoded file paths to preserve
+        # consistency across platforms.
+        class EncodedStore < BasicStore
+          
+          ##
+          # over-ride the datafiles block so that it decodes filenames before
+          # it returns them.
+          # 
+          # @see BasicStore
+          def datafiles
+            do_walk('data', true) do |a, b, size|
+              a = decode_filename(a) || nil
+              yield [a, b, size] if block_given?
+            end
+          end
+          
+          ##
+          # Encode the filename before joining
+          def join
+            @path_joiner.call @path, encode_filename(f)
+          end
+          
+          ##
+          # We've got a new required file so let's include it
+          def copy_list
+            BASIC_DATA_FILES.inject ['requires', '00changelog.i'] do |a, f|
+              a + @path_joiner.call('store', f)
+            end
+          end
+        end
+        
+        ##
+        # = FilenameCache
+        # This module handles dealing with Filename Caches - namely, parsing
+        # them.
+        module FilenameCache
+          
+          ##
+          # Parses the filename cache, given an object capable of opening
+          # a file relative to the right directory.
+          # 
+          # @param [Amp::Opener] opener An opener initialized to the repo's
+          #   directory.
+          def self.parse(opener)
+            return unless File.exist? opener.join("fncache")
+            opener.open 'fncache', 'r' do |fp|
+              # error handling?
+              i = 0
+              fp.each_line do |line| #this is how we parse it
+                if line.size < 2 || line[-1,1] != "\n"
+                  raise StoreError.new("invalid fncache entry, line #{i}")
+                end
+                yield line.chomp
+              end
+            end
+          end
+          
+          ##
+          # = FilenameCacheOpener
+          # This opener handles a cache of filenames that we are currently
+          # tracking. This way we don't need to recursively walk though
+          # the folders every single time. To use this class, you pass in
+          # the real Opener object (that responds to #open and returns a file
+          # pointer). then just treat it like any other opener. It will handle
+          # the behind-the-scenes work itself.
+          class FilenameCacheOpener < Amp::Opener
+            
+            ##
+            # Initializes a new FNCacheOpener. Requires a normal object capable
+            # of opening files.
+            # 
+            # @param [Amp::Opener] opener an opener object initialized to the
+            #   appropriate root directory.
+            def initialize(opener)
+              @opener = opener
+              @entries = nil
+            end
+            
+            def path; @opener.path; end
+            alias_method :root, :path
+            
+            ##
+            # Parses the filename cache and loads it into an ivar.
+            def load_filename_cache
+              @entries = {}
+              FilenameCache.parse @opener do |f|
+                @entries[f] = true
+              end
+            end
+            
+            ##
+            # Opens a file while being sure to write the filename if we haven't
+            # seen it before. Just like the normal Opener's open() method.
+            # 
+            # @param [String] path the path to the file
+            # @param [Fixnum] mode the read/write/append mode
+            # @param block the block to pass to it (optional)
+            def open(path, mode='r', &block)
+              
+              if mode !~ /r/ && path =~ /data\//
+                load_filename_cache if @entries.nil?
+                if @entries[path].nil?
+                  @opener.open('fncache','ab') {|f| f.puts path }
+                  @entries[path] = true
+                end
+              end
+              
+              begin
+                @opener.open(Stores.hybrid_encode(path), mode, &block)
+              rescue Errno::ENOENT
+                raise
+              rescue
+                raise unless mode == 'r'
+              end
+            rescue
+              raise
+            end
+      
+          end
+        end
+        
+        ##
+        # = FilenameCacheStore
+        # This version of the store uses a "Filename Cache", which is just a file
+        # that names all the tracked files in the store. It also uses an even more
+        # advanced "hybrid" encoding for filenames that again ensure consistency across
+        # platforms. However, this encoding is non-reversible - but since we're just
+        # doing file lookups anyway, that's just ducky.
+        class FilenameCacheStore < BasicStore
+          
+          ##
+          # Initializes the store. Sets up the cache right away.
+          # 
+          # @see BasicStore
+          def initialize(path, openerklass, pathjoiner)
+            @path_joiner = pathjoiner
+            @path = pathjoiner.call(path, 'store')
+            @create_mode = calculate_mode @path
+            @_op = openerklass.new(@path)
+            @_op.create_mode = @create_mode
+            @_op.default = :open_file
+            
+            @opener = FilenameCache::FilenameCacheOpener.new(@_op)
+          end
+          
+          ##
+          # Properly joins the path, but hybrid-encodes the file's path
+          # first.
+          def join(f)
+            @path_joiner.call(@path, Stores.hybrid_encode(f))
+          end
+          
+          ##
+          # Here's how we walk through the files now. Oh, look, we don't need
+          # to do annoying directory traversal anymore! But we do have to
+          # maintain a consistent fnstore file. I think I can live with that.
+          def datafiles
+            rewrite = false
+            existing = []
+            pjoin = @path_joiner
+            spath = @path
+            result = []
+            FilenameCache.parse(@_op) do |f|
+              
+              ef = Stores.hybrid_encode f
+              begin
+                st = File.stat(@path_joiner.call(spath, ef))
+                yield [f, ef, st.size] if block_given?
+                result << [f, ef, st.size] unless block_given?
+                existing << f
+              rescue Errno::ENOENT
+                rewrite = true
+              end
+            end
+            if rewrite
+              fp = @_op.open('fncache', 'wb')
+              existing.each do |p|
+                fp.write(p + "\n")
+              end
+              fp.close
+            end
+            result
+          end
+          
+          ##
+          # A more advanced list of files we need, properly joined and whatnot.
+          def copy_list
+            d = BASIC_DATA_FILES + ['dh', 'fncache']
+            d.inject ['requires', '00changelog.i'] do |a, f|
+              a + @path_joiner.call('store', f)
+            end
+            result
+          end
+          
+        end
+        
+        
+        #############################################
+        ############ Encoding formats ###############
+        #############################################
+        
+        ##
+        # Gets the basic character map that maps disallowed letters to
+        # allowable substitutes.
+        #
+        # @param [Boolean] underscore Should underscores be inserted in front of
+        #   capital letters before we downcase them? (e.g. if true, "A" => "_a")
+        def illegal_character_map(underscore=true)
+          e = '_'
+          win_reserved = "\\:*?\"<>|".split("").map {|x| x.ord}
+          cmap = {}; 0.upto(126) {|x| cmap[x.chr] = x.chr}
+          ((0..31).to_a + (126..255).to_a + win_reserved).each do |x|
+            cmap[x.chr] = "~%02x" % x
+          end
+          ((("A".ord)..("Z".ord)).to_a + [e.ord]).each do |x|
+            cmap[x.chr] = e + x.chr.downcase if underscore
+            cmap[x.chr] = x.chr.downcase     unless underscore
+          end
+          cmap
+        end
+        memoize_method :illegal_character_map, true
+        
+        ##
+        # Reversible encoding of the filename
+        #
+        # @param [String] s a file's path you wish to encode
+        # @param [Boolean] underscore should we insert underscores when
+        #   downcasing letters? (e.g. if true, "A" => "_a")
+        # @return [String] an encoded file path
+        def encode_filename(s, underscore=true)
+          cmap = illegal_character_map underscore
+          s.split("").map {|c| cmap[c]}.join
+        end
+        
+        ##
+        # Decodes an encoding performed by encode_filename
+        #
+        # @param [String] s an encoded file path
+        # @param [String] the decoded file path
+        def decode_filename(s)
+          cmap = illegal_character_map true
+          dmap = {}
+          cmap.each do |k, v|
+            dmap[v] = k
+          end
+          
+          i = 0
+          result = []
+          while i < s.size
+            1.upto(3) do |l|
+              if dmap[s[i..(i+l-1)]]
+                result << dmap[s[i..(i+l-1)]]
+                i += l
+                break
+              end
+            end
+          end
+          result.join
+        end
+        
+        # can't name a file one of these on windows, apparently
+        WINDOWS_RESERVED_FILENAMES = %w(con prn aux nul com1
+        com2 com3 com4 com5 com6 com7 com8 com8 lpt1 lpt2
+        lpt3 lpt4 lpt5 lpt6 lpt7 lpt8 lpt9)
+        
+        ##
+        # Copypasta
+        def auxilliary_encode(path)
+          res = []
+          path.split('/').each do |n|
+            if n.any?
+              base = n.split('.')[0]
+              if !(base.nil?) && base.any? && WINDOWS_RESERVED_FILENAMES.include?(base)
+                ec = "~%02x" % n[2,1].ord
+                n = n[0..1] + ec + n[3..-1]
+              end
+              if ['.',' '].include? n[-1,1]
+                n = n[0..-2] + ("~%02x" % n[-1,1].ord)
+              end
+            end
+            res << n
+          end
+          res.join("/")
+        end
+        
+        ##
+        # Normal encoding, but without extra underscores in the filenames.
+        def lower_encode(s)
+          encode_filename s, false
+        end
+        
+        MAX_PATH_LEN_IN_HGSTORE = 120
+        DIR_PREFIX_LEN = 8
+        MAX_SHORTENED_DIRS_LEN = 8 * (DIR_PREFIX_LEN + 1) - 4
+        
+        ##
+        # uber encoding that's straight up crazy.
+        # Max length of 120 means we have a non-reversible encoding,
+        # but since the FilenameCache only cares about name lookups, one-way
+        # is really all that matters!
+        # 
+        # @param [String] path the path to encode
+        # @return [String] an encoded path, with a maximum length of 120.
+        def hybrid_encode(path)
+          return path unless path =~ /data\//
+          ndpath = path["data/".size..-1]
+          res = "data/" + auxilliary_encode(encode_filename(ndpath))
+          if res.size > MAX_PATH_LEN_IN_HGSTORE
+            digest = path.sha1.hexdigest
+            aep = auxilliary_encode(lower_encode(ndpath))
+            root, ext = File.amp_split_extension aep
+            parts = aep.split('/')
+            basename = File.basename aep
+            sdirs = []
+            parts[0..-2].each do |p|
+              d = p[0..(DIR_PREFIX_LEN-1)]
+              
+              d = d[0..-2] + "_" if " .".include?(d[-1,1])
+              
+              t = sdirs.join("/") + "/" + d
+              break if t.size > MAX_SHORTENED_DIRS_LEN
+      
+              sdirs << d
+            end
+            dirs = sdirs.join("/")
+            dirs += "/" if dirs.size > 0
+            
+            res = "dh/" + dirs + digest + ext
+            space_left = MAX_PATH_LEN_IN_HGSTORE - res.size
+            if space_left > 0
+              filler = basename[0..(space_left-1)]
+              res = "dh/" + dirs + filler + digest + ext
+            end
+          end
+          return res
+              
+        end
+      end
+    end
+  end
+end