Class: Utopia::Tags::Gallery

Inherits:

Object

• Object
• Utopia::Tags::Gallery

Defined in:

lib/utopia/tags/gallery.rb

Defined Under Namespace

Modules: Processes Classes: ImagePath

Constant Summary

CACHE_DIR =

"_cache"

PROCESSES =

{
	:pdf_thumbnail => Processes::DocumentThumbnail.new([300, 300]),
	:photo_thumbnail => Processes::PhotoThumbnail.new([300, 300]),
	:large => Processes::Thumbnail.new([800, 800])
}

Class Method Summary

• .call(transaction, state) ⇒ Object

Instance Method Summary

• #images(options = {}) ⇒ Object
• #initialize(node, path) ⇒ Gallery constructor

  A new instance of Gallery.

• #metadata ⇒ Object
• #processed_image(image_path, processes) ⇒ Object

Constructor Details

#initialize(node, path) ⇒ Gallery

Returns a new instance of Gallery.

# File 'lib/utopia/tags/gallery.rb', line 130

def initialize(node, path)
	@node = node
	@path = path
end

Class Method Details

.call(transaction, state) ⇒ Object

# File 'lib/utopia/tags/gallery.rb', line 207

def self.call(transaction, state)
	gallery = new(transaction.end_tags[-2].node, Utopia::Path.create(state["path"] || "./"))
	metadata = gallery.metadata
	metadata.default = {}

	tag_name = state["tag"] || "img"

	options = {}
	options[:process] = state["process"]
	options[:filter] = Regexp.new("(#{state["filetypes"]})$", "i") if state["filetypes"]
	
	filter = Regexp.new(state["filter"], Regexp::IGNORECASE) if state["filter"]

	transaction.tag("div", "class" => "gallery") do |node|
		images = gallery.images(options).sort do |a, b|
			if (metadata[a.original.basename]["order"] && metadata[b.original.basename]["order"])
				metadata[a.original.basename]["order"] <=> metadata[b.original.basename]["order"]
			else
				a.original.basename <=> b.original.basename
			end
		end

		images.each do |path|
			next if filter and !filter.match(path.original.basename)

			alt_text = metadata[path.original.basename]["caption"]
			transaction.tag(tag_name, "src" => path, "alt" => alt_text)
		end
	end
end

Instance Method Details

#images(options = {}) ⇒ Object

# File 'lib/utopia/tags/gallery.rb', line 145

def images(options = {})
	options[:filter] ||= /(jpg|png)$/i

	paths = []
	local_path = @node.local_path(@path)

	Dir.entries(local_path).each do |filename|
		next unless filename.match(options[:filter])

		fullpath = File.join(local_path, filename)

		paths << ImagePath.new(@path + filename)
	end

	if options[:process]
		paths.each do |path|
			processed_image(path, options[:process])
		end
	end

	return paths
end

#metadata ⇒ Object

# File 'lib/utopia/tags/gallery.rb', line 135

def metadata
	metadata_path = @node.local_path(@path + "gallery.yaml")
	
	if File.exist? metadata_path
		return YAML::load(File.read(metadata_path))
	else
		return {}
	end
end

#processed_image(image_path, processes) ⇒ Object

# File 'lib/utopia/tags/gallery.rb', line 168

def processed_image(image_path, processes)
	# Create the local cache directory if it doesn't exist already
	local_cache_path = @node.local_path(image_path.cache_root)
	
	unless File.exist? local_cache_path
		FileUtils.mkdir local_cache_path
	end
	
	# Calculate the new name for the processed image
	local_original_path = @node.local_path(image_path.original)
	
	if processes.kind_of? String
		processes = processes.split(",").collect{|p| p.split(":")}
	end
	
	processes.each do |process_name, extension|
		process_name = process_name.to_sym
		
		process = PROCESSES[process_name]
		extension ||= process.default_extension(image_path)
		
		image_path.extensions[process_name] = extension if extension
		
		local_processed_path = @node.local_path(image_path.processed(process_name))
		
		unless File.exists? local_processed_path
			image = Magick::ImageList.new(local_original_path)
			image.scene = 0
			
			processed_image = process.call(image)
			processed_image.write(local_processed_path)
			
			# Run GC to free up any memory.
			processed_image = nil
			GC.start if defined? GC
		end
	end
end