disk_store 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 93990471281e2c963748cbebdfc8856ae2959ade
+  data.tar.gz: ca3fd4505c2c65f150b55a8fcbe5d0356f11a4a0
+SHA512:
+  metadata.gz: 67b15e61229c63c442e53495e4ea82a4ac8034c457b6d5513896c8bf0c9319836871b3bb618316dc5adace98787cfe1f02f311875f300b0c5d27d34c009473a7
+  data.tar.gz: b361398d2d4f22802061480be065f8c1002ceb43e7dbafaa1cbc9946f55724336945ecb1052867bef378f0af6390ee8c1c3593bd6558ba84391d3eee6b60de9f

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,38 @@
+PATH
+  remote: .
+  specs:
+    disk_store (0.0.1)
+      rake
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.3.5)
+    crack (0.4.1)
+      safe_yaml (~> 0.9.0)
+    diff-lcs (1.2.5)
+    multi_json (1.8.4)
+    rake (10.1.1)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.5)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.5)
+    safe_yaml (0.9.7)
+    vcr (2.8.0)
+    webmock (1.13.0)
+      addressable (>= 2.2.7)
+      crack (>= 0.3.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  disk_store!
+  multi_json
+  rspec
+  vcr
+  webmock

data/README.md

@@ -0,0 +1,70 @@
+# DiskStore
+
+DiskStore is a way of caching large files to disk in Ruby. Unlike ActiveSupport::Cache::Store,
+which is designed primarily for storing values of strings, DiskStore is meant for
+caching files to disk.
+
+DiskStore stores the files on disk in a very similar way to Rails' [ActiveSupport::Cache::FileStore](http://api.rubyonrails.org/classes/ActiveSupport/Cache/FileStore.html).
+
+## Installation
+
+```ruby
+gem 'disk_store'
+```
+
+## Usage
+
+You should use this in a similar way that you would use most Ruby caching libraries. Instead
+of passing around string values to cache, you should pass around IO objects. Here are a few
+examples.
+
+### Setup
+
+DiskStore requires a directory to to store the files.
+
+It takes a single parameter, which is the directory at which to store the cached files.
+If no parameter is specified, it uses the current directory.
+
+```ruby
+cache = DiskStore.new("path/to/my/cache/directory")
+```
+
+### Reading
+
+```ruby
+cache = DiskStore.new
+cached_file = cache.read("my_cache_key") #=> File.open('somewhere_on_disk')
+```
+
+### Writing
+
+```ruby
+cache = DiskStore.new
+cache.write("my_cache_key", File.open('file.psd', 'rb'))
+```
+
+### Fetching
+
+```ruby
+cache = DiskStore.new
+cache.fetch("my_cache_key") do
+  File.open('file.psd', 'rb')
+end
+```
+
+This is where it gets cool. You can also feed it other IO classes.
+Here we cache the result of a file download onto disk.
+
+```ruby
+cache = DiskStore.new
+cache.fetch("my_other_cache_key") do
+  open("https://layervault.com/cats.gif")
+end
+```
+
+### Deleting
+
+```ruby
+cache = DiskStore.new
+cache.delete("my_cache_key") #=> true
+```

data/Rakefile

@@ -0,0 +1,7 @@
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'disk_store'
+  ARGV.clear
+  IRB.start
+end

data/disk_store.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'disk_store/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "disk_store"
+  gem.version       = DiskStore::VERSION
+  gem.authors       = ["Kelly Sutton"]
+  gem.email         = ["kelly@layervault.com"]
+  gem.description   = %q{Cache files the smart way.}
+  gem.summary       = %q{Cache fiels the smart way.}
+  gem.homepage      = "http://cosmos.layervault.com/cache.html"
+  gem.license       = 'MIT'
+
+  gem.files         = `git ls-files`.split($/).delete_if { |f| f.include?('examples/') }
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "rake"
+
+  gem.test_files = Dir.glob("spec/**/*")
+  gem.add_development_dependency "multi_json"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "vcr"
+  gem.add_development_dependency "webmock"
+end

data/lib/disk_store/version.rb

@@ -0,0 +1,3 @@
+class DiskStore
+  VERSION = "0.1.0"
+end

data/lib/disk_store.rb

@@ -0,0 +1,84 @@
+require 'open-uri'
+
+class DiskStore
+  DIR_FORMATTER = "%03X"
+  FILENAME_MAX_SIZE = 228 # max filename size on file system is 255, minus room for timestamp and random characters appended by Tempfile (used by atomic write)
+  EXCLUDED_DIRS = ['.', '..'].freeze
+
+  def initialize(path=nil)
+    path ||= "."
+    @root_path = File.expand_path path
+  end
+
+  def read(key)
+    File.open(key_file_path(key), 'rb')
+  end
+
+  def write(key, io)
+    file_path = key_file_path(key)
+    ensure_cache_path(File.dirname(file_path))
+    IO::copy_stream(io, File.open(file_path, 'wb'))
+  end
+
+  def exist?(key)
+    File.exist?(key_file_path(key))
+  end
+
+  def delete(key)
+    file_path = key_file_path(key)
+    if exist?(key)
+      File.delete(file_path)
+      delete_empty_directories(File.dirname(file_path))
+    end
+  end
+
+  def fetch(key)
+    if block_given?
+      if exist?(key)
+        read(key)
+      else
+        io = yield
+        write(key, io)
+        read(key)
+      end
+    else
+      read(key)
+    end
+  end
+
+private
+
+  # These methods were borrowed mostly from ActiveSupport::Cache::FileStore
+
+  # Translate a key into a file path.
+  def key_file_path(key)
+    fname = URI.encode_www_form_component(key)
+    hash = Zlib.adler32(fname)
+    hash, dir_1 = hash.divmod(0x1000)
+    dir_2 = hash.modulo(0x1000)
+    fname_paths = []
+
+    # Make sure file name doesn't exceed file system limits.
+    begin
+      fname_paths << fname[0, FILENAME_MAX_SIZE]
+      fname = fname[FILENAME_MAX_SIZE..-1]
+    end until fname.nil? || fname == ""
+
+    File.join(@root_path, DIR_FORMATTER % dir_1, DIR_FORMATTER % dir_2, *fname_paths)
+  end
+
+  # Make sure a file path's directories exist.
+  def ensure_cache_path(path)
+    FileUtils.makedirs(path) unless File.exist?(path)
+  end
+
+   # Delete empty directories in the cache.
+  def delete_empty_directories(dir)
+    return if File.realpath(dir) == File.realpath(@root_path)
+    if Dir.entries(dir).reject{ |f| EXCLUDED_DIRS.include?(f) }.empty?
+      Dir.delete(dir) rescue nil
+      delete_empty_directories(File.dirname(dir))
+    end
+  end
+
+end