upload_cache 1.4.1 → 2.2.0

data/Rakefile

@@ -29,7 +29,8 @@ def run_tests!(which = nil)
 
   test_rbs.each_with_index do |test_rb, index|
     testno = index + 1
-    command = "#{ This.ruby } -I ./lib -I ./test/lib #{ test_rb }"
+    test_rb.gsub!(/#{ Regexp.escape(This.dir) }/, '.')
+    command = "#{ File.basename(This.ruby) } -I./lib -I./test/lib #{ test_rb }"
 
     puts
     say(div, :color => :cyan, :bold => true)
@@ -59,9 +60,14 @@ end
 
 task :gemspec do
   ignore_extensions = ['git', 'svn', 'tmp', /sw./, 'bak', 'gem']
-  ignore_directories = ['pkg']
+  ignore_directories = ['pkg', 'test/tmp', 'tmp']
   ignore_files = ['test/log', 'a.rb'] + Dir['db/*'] + %w'db'
 
+  root = File.expand_path(File.dirname(__FILE__))
+
+  ignore_directories.map!{|_| File.join(root, _)}
+  ignore_files.map!{|_| File.join(root, _)}
+
   shiteless = 
     lambda do |list|
       list.delete_if do |entry|
@@ -69,16 +75,15 @@ task :gemspec do
         extension = File.basename(entry).split(%r/[.]/).last
         ignore_extensions.any?{|ext| ext === extension}
       end
-      list.delete_if do |entry|
-        next unless test(?d, entry)
-        dirname = File.expand_path(entry)
-        ignore_directories.any?{|dir| File.expand_path(dir) == dirname}
-      end
       list.delete_if do |entry|
         next unless test(?f, entry)
         filename = File.expand_path(entry)
         ignore_files.any?{|file| File.expand_path(file) == filename}
       end
+      list.delete_if do |entry|
+        dirname = File.expand_path(entry)
+        ignore_directories.any?{|dir| dirname[dir]}
+      end
     end
 
   lib         = This.lib

data/lib/upload_cache.rb

@@ -5,7 +5,7 @@ require 'tmpdir'
 require 'map'
 
 class UploadCache
-  Version = '1.4.1'
+  Version = '2.2.0'
 
   Readme = <<-__
     NAME
@@ -61,6 +61,7 @@ class UploadCache
       UploadCache::Version
     end
 
+
     def url
       @url ||= (
         if defined?(Rails.root) and Rails.root
@@ -128,7 +129,7 @@ class UploadCache
 
     def finalizer(object_id)
       if fd = IOs[object_id]
-        IO.for_fd(fd).close
+        ::IO.for_fd(fd).close rescue nil
         IOs.delete(object_id)
       end
     end
@@ -187,75 +188,160 @@ class UploadCache
       @prefix
     end
 
-    def prefix=(value)
-      @prefix = value
-    end
-
     def default
       @default ||= Map[:url, nil, :path, nil]
     end
 
-    def for(params, *args)
-      params = Map.for(params)
+    def prefix=(value)
+      @prefix = value
+    end
+
+    def cache(params, *args)
+      params_map = Map.for(params)
       options = Map.options_for!(args)
 
       key = Array(options[:key] || args).flatten.compact
       key = [:upload] if key.empty?
 
-      return(
-        currently_uploaded_file(params, key, options) or
-        previously_uploaded_file(params, key, options) or
-        default_uploaded_file(params, key, options)
+      upload_cache = (
+        current_upload_cache_for(params_map, key, options) or
+        previous_upload_cache_for(params_map, key, options) or
+        default_upload_cache_for(params_map, key, options)
       )
+
+      value = params_map.get(key)
+
+      update_params(params, key, value)
+
+      upload_cache
+    end
+    alias_method('for', 'cache')
+
+    def update_params(params, key, value)
+      key = Array(key).flatten
+
+      leaf = key.pop
+      path = key
+      node = params
+
+      until path.empty?
+        key = path.shift
+        case node
+          when Array
+            index = Integer(key)
+            break unless node[index]
+            node = node[index]
+          else
+            break unless node.has_key?(key)
+            node = node[key]
+        end
+      end
+
+      node[leaf] = value
     end
 
-    def currently_uploaded_file(params, key, options)
+    def current_upload_cache_for(params, key, options)
       upload = params.get(key)
+      if upload.respond_to?(:upload_cache) and upload.upload_cache
+        return upload.upload_cache
+      end
 
       if upload.respond_to?(:read)
         tmpdir do |tmp|
           original_basename =
             [:original_path, :original_filename, :path, :filename].
-            map{|msg| upload.send(msg) if upload.respond_to?(msg)}.compact.first
+              map{|msg| upload.send(msg) if upload.respond_to?(msg)}.compact.first
+
           basename = cleanname(original_basename)
 
           path = File.join(tmp, basename)
-          open(path, 'wb'){|fd| fd.write(upload.read)}
+
+          copied = false
+
+          rewind(upload) do
+            src = upload.path
+            dst = path
+
+            strategies = [
+              proc{ `ln -f #{ src.inspect } #{ dst.inspect } || cp -f #{ src.inspect } #{ dst.inspect }`},
+              proc{ FileUtils.ln(src, dst) },
+              proc{ FileUtils.cp(src, dst) },
+              proc{ 
+                open(dst, 'wb'){|fd| fd.write(upload.read)} 
+              }
+            ]
+
+            FileUtils.rm_f(dst)
+
+            strategies.each do |strategy|
+              strategy.call rescue nil
+              break if((copied = test(?e, dst)))
+            end
+          end
+
+          raise("failed to copy #{ upload.path.inspect } -> #{ path.inspect }") unless copied
+
           upload_cache = UploadCache.new(key, path, options)
           params.set(key, upload_cache.io)
           return upload_cache
         end
       end
 
-      false
+      nil
     end
 
-    def previously_uploaded_file(params, key, options)
-      cache_key = cache_key_for(key)
-      upload_cache = params.get(cache_key)
+    def previous_upload_cache_for(params, key, options)
+      upload = params.get(key)
+      if upload.respond_to?(:upload_cache) and upload.upload_cache
+        return upload.upload_cache
+      end
 
-      if upload_cache
-        dirname, basename = File.split(File.expand_path(upload_cache))
+      upload = params.get(cache_key_for(key))
+
+      if upload
+        dirname, basename = File.split(File.expand_path(upload))
         relative_dirname = File.basename(dirname)
         relative_basename = File.join(relative_dirname, basename)
         path = root + '/' + relative_basename
+
         upload_cache = UploadCache.new(key, path, options)
         params.set(key, upload_cache.io)
         return upload_cache
       end
 
-      false
+      nil
     end
 
-    def default_uploaded_file(params, key, options)
+    def default_upload_cache_for(params, key, options)
       upload_cache = UploadCache.new(key, options)
-      params.set(key, upload_cache.io) if upload_cache.io
+      params.set(key, upload_cache.io)
       return upload_cache
     end
+
+    def rewind(io, &block)
+      begin
+        pos = io.pos
+        io.flush
+        io.rewind
+      rescue
+        nil
+      end
+
+      begin
+        block.call
+      ensure
+        begin
+          io.pos = pos
+        rescue
+          nil
+        end
+      end
+    end
   end
 
   attr_accessor :key
   attr_accessor :cache_key
+  attr_accessor :options
   attr_accessor :name
   attr_accessor :path
   attr_accessor :dirname
@@ -268,18 +354,18 @@ class UploadCache
   IOs = {}
 
   def initialize(key, *args)
-    options = Map.options_for!(args)
+    @options = Map.options_for!(args)
 
     @key = key
     @cache_key = UploadCache.cache_key_for(@key)
     @name = UploadCache.name_for(@cache_key)
 
-    path = args.shift || options[:path]
+    path = args.shift || @options[:path]
 
-    default = Map.for(options[:default])
+    default = Map.for(@options[:default])
 
-    @default_url = default[:url] || options[:default_url] || UploadCache.default.url
-    @default_path = default[:path] || options[:default_path] || UploadCache.default.path
+    @default_url = default[:url] || @options[:default_url] || UploadCache.default.url
+    @default_path = default[:path] || @options[:default_path] || UploadCache.default.path
 
     if path
       @path = path
@@ -294,14 +380,46 @@ class UploadCache
       @io = open(@path || @default_path, 'rb')
       IOs[object_id] = @io.fileno
       ObjectSpace.define_finalizer(self, UploadCache.method(:finalizer).to_proc)
+      @io.send(:extend, WeakReference)
+      @io.upload_cache = self
+    end
+  end
+
+  module WeakReference
+    attr_accessor :upload_cache_object_id
+
+    def upload_cache
+      begin
+        ObjectSpace._id2ref(upload_cache_object_id)
+      rescue Object
+        nil
+      end
+    end
+
+    def upload_cache=(upload_cache)
+      self.upload_cache_object_id = upload_cache.object_id
     end
   end
 
+  def inspect
+    {
+      UploadCache.name =>
+        {
+          :key => key, :cache_key => key, :name => name, :path => path, :io => io
+        }
+    }.inspect
+  end
+
+  def blank?
+    @path.blank?
+  end
+
   def url
     if @value
       File.join(UploadCache.url, @value)
     else
       @default_url ? @default_url : nil
+      #defined?(@placeholder) ? @placeholder : nil
     end
   end
 
@@ -330,19 +448,24 @@ class UploadCache
     string.html_safe
   end
 
-  def clear!
-    return if UploadCache.turd?
+  def clear!(&block)
+    result = block ? block.call(@path) : nil 
 
-    begin
-      FileUtils.rm_rf(@dirname) if test(?d, @dirname)
-    rescue
-      nil
-    ensure
-      @io.close rescue nil
-      IOs.delete(object_id)
-      Thread.new{ UploadCache.clear! }
+    unless UploadCache.turd?
+      begin
+        FileUtils.rm_rf(@dirname) if test(?d, @dirname)
+      rescue
+        nil
+      ensure
+        @io.close rescue nil
+        IOs.delete(object_id)
+        Thread.new{ UploadCache.clear! }
+      end
     end
+
+    result
   end
+  alias_method('clear', 'clear!')
 end
 
 Upload_cache = UploadCache unless defined?(Upload_cache)

data/test/lib/testing.rb

@@ -0,0 +1,200 @@
+# -*- encoding : utf-8 -*-
+# simple testing support
+#
+# -*- encoding : utf-8 -*-
+#
+require 'test/unit'
+
+testdir = File.expand_path(File.dirname(__FILE__))
+rootdir = File.dirname(testdir)
+libdir = File.join(rootdir, 'lib')
+
+STDOUT.sync = true
+
+$:.unshift(testdir) unless $:.include?(testdir)
+$:.unshift(libdir) unless $:.include?(libdir)
+$:.unshift(rootdir) unless $:.include?(rootdir)
+
+class Testing
+  class Slug < ::String
+    def Slug.for(*args)
+      string = args.flatten.compact.join('-')
+      words = string.to_s.scan(%r/\w+/)
+      words.map!{|word| word.gsub %r/[^0-9a-zA-Z_-]/, ''}
+      words.delete_if{|word| word.nil? or word.strip.empty?}
+      new(words.join('-').downcase)
+    end
+  end
+  
+  class Context
+    attr_accessor :name
+
+    def initialize(name, *args)
+      @name = name
+    end
+
+    def to_s
+      Slug.for(name)
+    end
+  end
+end
+
+def Testing(*args, &block)
+  Class.new(::Test::Unit::TestCase) do
+
+  ## class methods
+  #
+    class << self
+      def contexts
+        @contexts ||= []
+      end
+
+      def context(*args, &block)
+        return contexts.last if(args.empty? and block.nil?)
+
+        context = Testing::Context.new(*args)
+        contexts.push(context)
+
+        begin
+          block.call(context)
+        ensure
+          contexts.pop
+        end
+      end
+
+      def slug_for(*args)
+        string = [context, args].flatten.compact.join('-')
+        words = string.to_s.scan(%r/\w+/)
+        words.map!{|word| word.gsub %r/[^0-9a-zA-Z_-]/, ''}
+        words.delete_if{|word| word.nil? or word.strip.empty?}
+        words.join('-').downcase.sub(/_$/, '')
+      end
+
+      def name() const_get(:Name) end
+
+      def testno()
+        '%05d' % (@testno ||= 0)
+      ensure
+        @testno += 1
+      end
+
+      def testing(*args, &block)
+        method = ["test", testno, slug_for(*args)].delete_if{|part| part.empty?}.join('_')
+        define_method(method, &block)
+      end
+
+      def test(*args, &block)
+        testing(*args, &block)
+      end
+
+      def setup(&block)
+        define_method(:setup, &block) if block
+      end
+
+      def teardown(&block)
+        define_method(:teardown, &block) if block
+      end
+
+      def prepare(&block)
+        @prepare ||= []
+        @prepare.push(block) if block
+        @prepare
+      end
+
+      def cleanup(&block)
+        @cleanup ||= []
+        @cleanup.push(block) if block
+        @cleanup
+      end
+    end
+
+  ## configure the subclass!
+  #
+    const_set(:Testno, '0')
+    slug = slug_for(*args).gsub(%r/-/,'_')
+    name = ['TESTING', '%03d' % const_get(:Testno), slug].delete_if{|part| part.empty?}.join('_')
+    name = name.upcase!
+    const_set(:Name, name)
+    const_set(:Missing, Object.new.freeze)
+
+  ## instance methods
+  #
+    alias_method('__assert__', 'assert')
+
+    def assert(*args, &block)
+      if args.size == 1 and args.first.is_a?(Hash)
+        options = args.first
+        expected = getopt(:expected, options){ missing }
+        actual = getopt(:actual, options){ missing }
+        if expected == missing and actual == missing
+          actual, expected, *ignored = options.to_a.flatten
+        end
+        expected = expected.call() if expected.respond_to?(:call)
+        actual = actual.call() if actual.respond_to?(:call)
+        assert_equal(expected, actual)
+      end
+
+      if block
+        label = "assert(#{ args.join(' ') })"
+        result = nil
+        assert_nothing_raised{ result = block.call }
+        __assert__(result, label)
+        result
+      else
+        result = args.shift
+        label = "assert(#{ args.join(' ') })"
+        __assert__(result, label)
+        result
+      end
+    end
+
+    def missing
+      self.class.const_get(:Missing)
+    end
+
+    def getopt(opt, hash, options = nil, &block)
+      [opt.to_s, opt.to_s.to_sym].each do |key|
+        return hash[key] if hash.has_key?(key)
+      end
+      default =
+        if block
+          block.call
+        else
+          options.is_a?(Hash) ? options[:default] : nil
+        end
+      return default
+    end
+
+    def subclass_of exception
+      class << exception
+        def ==(other) super or self > other end
+      end
+      exception
+    end
+
+  ##
+  #
+    module_eval(&block)
+
+    self.setup()
+    self.prepare.each{|b| b.call()}
+
+    at_exit{ 
+      self.teardown()
+      self.cleanup.each{|b| b.call()}
+    }
+
+    self
+  end
+end
+
+
+if $0 == __FILE__
+
+  Testing 'Testing' do
+    testing('foo'){ assert true }
+    test{ assert true }
+    p instance_methods.grep(/test/)
+  end
+
+end

data/test/upload_cache_test.rb

@@ -0,0 +1,173 @@
+# -*- encoding : utf-8 -*-
+require 'fileutils'
+require 'testing'
+require 'upload_cache'
+
+Testing UploadCache do
+
+##
+#
+  testing 'upload_cache will cache an upload and alter params to point to it' do
+    uploaded_file = new_uploaded_file
+
+    params = {
+      :key => uploaded_file
+    }
+
+    upload_cache = assert{ UploadCache.cache(params, :key) }
+
+    assert{ params[:key] }
+    assert{ params[:key].respond_to?(:upload_cache_object_id) }
+    assert{ params[:key].respond_to?(:upload_cache) }
+
+
+    assert{ upload_cache.io }
+    assert{ upload_cache.path }
+    assert{ IO.read(uploaded_file.path) == IO.read(upload_cache.io.path) }
+  end
+
+##
+#
+  testing 'upload_cache looks for previously uploaded files under a special key' do
+    uploaded_file_path = previously_uploaded_file_path
+
+    params = {
+      :key => nil,
+      :key_upload_cache => uploaded_file_path 
+    }
+
+    upload_cache = assert{ UploadCache.cache(params, :key) }
+
+    assert{ params[:key] }
+    assert{ params[:key].respond_to?(:upload_cache_object_id) }
+    assert{ params[:key].respond_to?(:upload_cache) }
+
+
+    assert{ upload_cache.io }
+    assert{ upload_cache.path }
+    assert{ IO.read(File.join(Public, uploaded_file_path)) == IO.read(upload_cache.io.path) }
+  end
+
+##
+#
+  testing 'upload_cache will return the same object iff nothing has changed' do
+    params = {
+      :key => new_uploaded_file
+    }
+
+    a = assert{ UploadCache.cache(params, :key) }
+    b = assert{ UploadCache.cache(params, :key) }
+    assert{ a.object_id == b.object_id }
+  end
+
+##
+#
+  testing 'upload_cache will *not* return the same object iff something has changed' do
+    params = {
+      :key => new_uploaded_file
+    }
+
+    a = assert{ UploadCache.cache(params, :key) }
+    b = assert{ UploadCache.cache(params, :key) }
+    assert{ a.object_id == b.object_id }
+
+    params[:key] = new_uploaded_file
+    c = assert{ UploadCache.cache(params, :key) }
+    assert{ a.object_id != c.object_id }
+    assert{ b.object_id != c.object_id }
+  end
+
+##
+#
+  testing 'upload_cache works on file handles that need flushing' do
+    uploaded_file = new_uploaded_file
+
+    params = {
+      :key => uploaded_file
+    }
+
+    uploaded_file.rewind
+    uploaded_file.sync = false
+    uploaded_file.write('a half baked write')
+
+    upload_cache = assert{ UploadCache.cache(params, :key) }
+
+    assert{ params[:key] }
+    assert{ params[:key].respond_to?(:upload_cache_object_id) }
+    assert{ params[:key].respond_to?(:upload_cache) }
+
+    assert{ upload_cache.io }
+    assert{ upload_cache.path }
+    assert{ IO.read(uploaded_file.path) == IO.read(upload_cache.io.path) }
+  end
+
+
+  TestDir                 = File.expand_path(File.dirname(__FILE__))
+  TestTmpDir              = File.join(TestDir,    'tmp')
+  Public                  = File.join(TestTmpDir, 'public')
+  PublicSystem            = File.join(TestTmpDir, 'public/system')
+  PublicSystemUploadCache = File.join(TestTmpDir, 'public/system/upload_cache')
+  PublicSystemUploads     = File.join(TestTmpDir, 'public/system/uploads')
+
+  FileUtils.mkdir_p(TestTmpDir)
+  FileUtils.mkdir_p(Public)
+  FileUtils.mkdir_p(PublicSystem)
+  FileUtils.mkdir_p(PublicSystemUploadCache)
+  FileUtils.mkdir_p(PublicSystemUploads)
+
+  setup do
+    assert{ UploadCache.root = PublicSystemUploadCache }
+  end
+
+  at_exit do
+    glob = File.join(TestTmpDir, '**/**')
+    Dir.glob(glob) do |entry|
+      #FileUtils.rm_rf(entry)
+    end
+  end
+
+  Count = '0'
+  def new_uploaded_file(&block)
+    path = File.join(PublicSystemUploads, Count)
+    at_exit{ FileUtils.rm_f(path) }
+    fd = open(path, 'w+')
+    fd.puts(Count)
+    #fd.flush
+    #fd.rewind
+    return fd unless block
+    begin
+      block.call(fd)
+    ensure
+      fd.close rescue nil
+    end
+  ensure
+    Count.succ!
+  end
+
+  def previously_uploaded_file_path
+    new_uploaded_file do |uploaded_file|
+      basename = File.basename(uploaded_file.path)
+      uuid = assert{ UploadCache.uuid }
+      dst = File.join(PublicSystemUploadCache, uuid, basename)
+      FileUtils.mkdir(File.dirname(dst))
+      open(dst, 'w') do |fd|
+        fd.write(uploaded_file.read)
+      end
+      "/system/upload_cache/#{ uuid }/#{ basename }"
+    end
+  end
+end
+
+
+
+
+
+
+BEGIN {
+  testdir = File.dirname(File.expand_path(__FILE__))
+  testlibdir = File.join(testdir, 'lib')
+  rootdir = File.dirname(testdir)
+  libdir = File.join(rootdir, 'lib')
+  $LOAD_PATH.push(libdir)
+  $LOAD_PATH.push(testlibdir)
+}

data/upload_cache.gemspec

@@ -3,13 +3,21 @@
 
 Gem::Specification::new do |spec|
   spec.name = "upload_cache"
-  spec.version = "1.4.1"
+  spec.version = "2.2.0"
   spec.platform = Gem::Platform::RUBY
   spec.summary = "upload_cache"
   spec.description = "description: upload_cache kicks the ass"
 
   spec.files =
-["README", "Rakefile", "lib", "lib/upload_cache.rb", "upload_cache.gemspec"]
+["README",
+ "Rakefile",
+ "lib",
+ "lib/upload_cache.rb",
+ "test",
+ "test/lib",
+ "test/lib/testing.rb",
+ "test/upload_cache_test.rb",
+ "upload_cache.gemspec"]
 
   spec.executables = []
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: upload_cache
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 2.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-06 00:00:00.000000000 Z
+date: 2012-02-18 00:00:00.000000000 Z
 dependencies: []
 description: ! 'description: upload_cache kicks the ass'
 email: ara.t.howard@gmail.com
@@ -20,6 +20,8 @@ files:
 - README
 - Rakefile
 - lib/upload_cache.rb
+- test/lib/testing.rb
+- test/upload_cache_test.rb
 - upload_cache.gemspec
 homepage: https://github.com/ahoward/upload_cache
 licenses: []