Permalink
Fetching contributors…
Cannot retrieve contributors at this time
233 lines (209 sloc) 7.81 KB
require 'find'
require 'time'
require 'set'
class Cloudinary::Static
IGNORE_FILES = [".svn", "CVS", "RCS", ".git", ".hg"]
DEFAULT_IMAGE_DIRS = ["app/assets/images", "lib/assets/images", "vendor/assets/images", "public/images"]
DEFAULT_IMAGE_EXTENSION_MASK = 'gif|jpe?g|png|bmp|ico|webp|wdp|jxr|jp2|svg|pdf'
METADATA_FILE = ".cloudinary.static"
METADATA_TRASH_FILE = ".cloudinary.static.trash"
class << self
def sync(options={})
options = options.clone
delete_missing = options.delete(:delete_missing)
found_paths = Set.new
found_public_paths = {}
found_public_ids = Set.new
metadata = build_metadata
metadata_lines = []
counts = { :not_changed => 0, :uploaded => 0, :deleted => 0, :not_found => 0}
discover_all do |path, public_path|
next if found_paths.include?(path)
if found_public_paths[public_path]
print "Warning: duplicate #{public_path} in #{path} - already taken from #{found_public_paths[public_path]}\n"
next
end
found_paths << path
found_public_paths[public_path] = path
data = root.join(path).read(:mode=>"rb")
ext = path.extname
format = ext[1..-1]
md5 = Digest::MD5.hexdigest(data)
public_id = "#{public_path.basename(ext)}-#{md5}"
found_public_ids << public_id
item_metadata = metadata.delete(public_path.to_s)
if item_metadata && item_metadata["public_id"] == public_id # Signature match
counts[:not_changed] += 1
print "#{public_path} - #{public_id} - Not changed\n"
result = item_metadata
else
counts[:uploaded] += 1
print "#{public_path} - #{public_id} - Uploading\n"
result = Cloudinary::Uploader.upload(Cloudinary::Blob.new(data, :original_filename=>path.to_s),
options.merge(:format=>format, :public_id=>public_id, :type=>:asset, :resource_type=>resource_type(path.to_s))
).merge("upload_time"=>Time.now)
end
metadata_lines << [public_path, public_id, result["upload_time"].to_i, result["version"], result["width"], result["height"]].join("\t")+"\n"
end
File.open(metadata_file_path, "w"){|f| f.print(metadata_lines.join)}
metadata.to_a.each do |path, info|
counts[:not_found] += 1
print "#{path} - #{info["public_id"]} - Not found\n"
end
# Files no longer needed
trash = metadata.to_a + build_metadata(metadata_trash_file_path, false).reject{|public_path, info| found_public_ids.include?(info["public_id"])}
if delete_missing
trash.each do
|path, info|
counts[:deleted] += 1
print "#{path} - #{info["public_id"]} - Deleting\n"
Cloudinary::Uploader.destroy(info["public_id"], options.merge(:type=>:asset))
end
FileUtils.rm_f(metadata_trash_file_path)
else
# Add current removed file to the trash file.
metadata_lines = trash.map do
|public_path, info|
[public_path, info["public_id"], info["upload_time"].to_i, info["version"], info["width"], info["height"]].join("\t")+"\n"
end
File.open(metadata_trash_file_path, "w"){|f| f.print(metadata_lines.join)}
end
print "\nCompleted syncing static resources to Cloudinary\n"
print counts.sort.reject{|k,v| v == 0}.map{|k,v| "#{v} #{k.to_s.gsub('_', ' ').capitalize}"}.join(", ") + "\n"
end
# ## Cloudinary::Utils support ###
def public_id_and_resource_type_from_path(path)
@metadata ||= build_metadata
path = path.sub(/^\//, '')
prefix = public_prefixes.find {|prefix| @metadata[File.join(prefix, path)]}
if prefix
[@metadata[File.join(prefix, path)]['public_id'], resource_type(path)]
else
nil
end
end
private
def root
Cloudinary.app_root
end
def metadata_file_path
root.join(METADATA_FILE)
end
def metadata_trash_file_path
root.join(METADATA_TRASH_FILE)
end
def build_metadata(metadata_file = metadata_file_path, hash = true)
metadata = []
if File.exist?(metadata_file)
IO.foreach(metadata_file) do
|line|
line.strip!
next if line.blank?
path, public_id, upload_time, version, width, height = line.split("\t")
metadata << [path, {
"public_id" => public_id,
"upload_time" => Time.at(upload_time.to_i).getutc,
"version" => version,
"width" => width.to_i,
"height" => height.to_i
}]
end
end
hash ? Hash[*metadata.flatten] : metadata
end
def discover_all(&block)
static_file_config.each do |group, data|
print "-> Syncing #{group}...\n"
discover(absolutize(data['dirs']), extension_matcher_for(group), &block)
print "=========================\n"
end
end
def discover(dirs, matcher)
return unless matcher
dirs.each do |dir|
print "Scanning #{dir.relative_path_from(root)}...\n"
dir.find do |path|
file = path.basename.to_s
if ignore_file?(file)
Find.prune
next
elsif path.directory? || !matcher.call(path.to_s)
next
else
relative_path = path.relative_path_from(root)
public_path = path.relative_path_from(dir.dirname)
yield(relative_path, public_path)
end
end
end
end
def ignore_file?(file)
matches?(file, Cloudinary.config.ignore_files || IGNORE_FILES)
end
# Test for matching either strings or regexps
def matches?(target, patterns)
Array(patterns).any? {|pattern| pattern.is_a?(String) ? pattern == target : target.match(pattern)}
end
def extension_matcher_for(group)
group = group.to_s
return unless static_file_config[group]
@matchers = {}
@matchers[group] ||= ->(target) do
!!target.match(extension_mask_to_regex(static_file_config[group]['file_mask']))
end
end
def static_file_config
@static_file_config ||= begin
config = Cloudinary.config.static_files || {}
# Default
config['images'] ||= {}
config['images']['dirs'] ||= Cloudinary.config.static_image_dirs # Backwards compatibility
config['images']['dirs'] ||= DEFAULT_IMAGE_DIRS
config['images']['file_mask'] ||= DEFAULT_IMAGE_EXTENSION_MASK
# Validate
config.each do |group, data|
unless data && data['dirs'] && data['file_mask']
print "In config, static_files group '#{group}' needs to have both 'dirs' and 'file_mask' defined.\n"
exit
end
end
config
end
end
def reset_static_file_config!
@static_file_config = nil
end
def image?(path)
extension_matcher_for(:images).call(path)
end
def resource_type(path)
if image?(path)
:image
else
:raw
end
end
def extension_mask_to_regex(extension_mask)
extension_mask && /\.(?:#{extension_mask})$/i
end
def public_prefixes
@public_prefixes ||= static_file_config.reduce([]) do |result, (group, data)|
result << data['dirs'].map { |dir| Pathname.new(dir).basename.to_s }
end.flatten.uniq
end
def absolutize(dirs)
dirs.map do |relative_dir|
absolute_dir = root.join(relative_dir)
if absolute_dir.exist?
absolute_dir
else
print "Skipping #{relative_dir} (does not exist)\n"
nil
end
end.compact
end
def print(s)
$stderr.print(s)
end
end
end