galleruby 0.1

data/.gitignore

@@ -0,0 +1,6 @@
+/output/
+config.yml
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in galleruby.gemspec
+gemspec

data/README.md

@@ -0,0 +1,124 @@
+Galleruby
+=========
+
+Galleruby is a simple Ruby script to automatically generate a static HTML
+gallery (series of different albums) for your local photo collection. It's
+written to publish my personal photos on Amazon S3. I just run this script then
+s3sync.rb the resulting output to my S3 bucket.
+
+You can see an example setup of Galleruby running on Amazon S3 here:
+
+[http://galleruby.devsoft.no](http://galleruby.devsoft.no)
+
+It's not very configurable, and it makes some assumptions that might not be true
+for your picture setup. I'm aware of the following ones:
+
+* All photos need the EXIF DateTime tag set.
+* Files need to have jpg or jpeg as their extension (case insensitive).
+* Your albums are sorted into directories in a common source directory, and albums do not have sub-directories.
+
+If you remove any of these limitations, or find others, please let me know! :-)
+
+As an example of the layout, this is what
+[http://galleruby.devsoft.no](http://galleruby.devsoft.no) has locally:
+    ~/Pictures/Albums/
+        Hiking at Daley Ranch/
+            IMG_0832.JPG
+            IMG_0855.JPG
+            IMG_0864.JPG
+            IMG_0868.JPG
+            IMG_0877.JPG
+            IMG_0890.JPG
+        Joshua Tree Climbing/
+            IMG_4420.JPG
+            IMG_4425.JPG
+            IMG_4428.JPG
+            IMG_4429.JPG
+            IMG_4437.JPG
+            IMG_4450.JPG
+            IMG_4455.JPG
+            IMG_4458.JPG
+            IMG_4460.JPG
+            IMG_4461.JPG
+            IMG_4467.JPG
+
+Galleruby isn't very user-friendly, but it gets the job done for me - and maybe
+it'll get the job done for you too! (or maybe some day grow into something more
+general, if I get some user feedback)
+
+Dependencies
+============
+
+Galleruby has two external gem dependencies:
+
+* RMagick
+* HAML
+
+You can install these using:
+    gem install rmagick haml
+
+Using Galleruby
+===============
+
+First, Galleruby identifies albums eligible for upload by looking for a
+.galleruby.yml file in the album directory. This file is expected to initially
+contain the user-displayed title of the album (e.g. "Birthday party!") and the
+shortname of the album, which is what the server-side output directory will be
+called (e.g.  "birthdayparty").
+
+So, to get started, you need to generate these files using the make_titles.rb
+script. It will suggest defaults you can use by pressing enter - and if you
+don't want a directory included, press ctrl+D and it'll forever skip this
+directory when you run make_titles.rb (and not create a .galleruby.yml). To
+revert this behavior for a directory, delete the .galleruby.skip file.
+    ./make_titles.rb ~/Pictures/Albums
+
+Second, you just need to run gallerubify - but copy config.yml.dist to
+config.yml and edit it first. Running gallerubify will take some time, as it's
+generating three resized versions of your files for publishing. You can change
+what these sizes are by editing config.yml.
+    ./gallerubify.rb ~/Pictures/Albums
+
+Third, you need to put the static directory in your output dir:
+    cp -r static output/
+
+Example
+=======
+
+Here's how you'd get started, assuming the above layout. Notice that defaults
+were accepted for most values except the title of the birthday party album, and
+that we skipped publishing "Very private photos" by pressing ctrl-D.
+
+    $ ./make_titles.rb ~/Pictures/Albums
+    > Directory Hiking at Daley Ranch, 6 files
+       What should the title be? [Hiking at Daley Ranch]
+
+       What should the link name be? [hikingatdaleyranch]
+
+    > Directory Joshua Tree Climbing, 11 files
+       What should the title be? [Joshua Tree Climbing]
+
+       What should the link name be? [joshuatreeclimbing]
+
+    > Directory Very Private Album, 1 files
+       What should the title be? [Very Private Album]
+    ^D
+       Skipping album
+
+    $ ./gallerubify.rb ~/Pictures/Albums
+    Hiking at Daley Ranch: Processing album
+    Hiking at Daley Ranch: Rendering HTML
+    Joshua Tree Climbing: Processing album
+    Joshua Tree Climbing: Rendering HTML
+    All done! Generating index.
+
+    $ cp -vr static output/
+    static -> output/static
+    static/close.png -> output/static/close.png
+    static/galleruby.css -> output/static/galleruby.css
+    static/galleruby.js -> output/static/galleruby.js
+    static/jquery-1.5.min.js -> output/static/jquery-1.5.min.js
+    static/next.png -> output/static/next.png
+    static/previous.png -> output/static/previous.png
+
+    $ s3sync.rb -vrp output/ my_gallery_bucket:

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/gallerubify

@@ -0,0 +1,163 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+require 'yaml'
+require 'optparse'
+
+require 'galleruby'
+
+def main
+    # These are the default options
+    default_config = {
+        :title => 'My Gallery',
+        :thumb => [320, 256],
+        :medium => [800, 600],
+        :large => [1280, 1024],
+        :templates => "#{File.dirname(__FILE__)}/../templates",
+        :static => "#{File.dirname(__FILE__)}/../static",
+        :output => 'output',
+        :verbose => false,
+        :force => false
+    }
+
+    config_file = nil
+    config = {}
+    parser = OptionParser.new do |opts|
+      opts.banner = "Usage: gallerubify [OPTION] ... DIR"
+      opts.program_name = 'gallerubify'
+      opts.version = Galleruby::VERSION
+
+      opts.on("-c", "--config FILE", "Read configuration options from FILE.") do |c|
+        config_file = c
+      end
+
+      opts.on("-o", "--output DIRECTORY", "Generates output gallery in DIRECTORY instead of the default 'output'") do |d|
+        config[:output] = d
+      end
+
+      opts.on("-t", "--title TITLE", "Set gallery title to TITLE") do |t|
+        config[:title] = t
+      end
+
+      opts.on("--templates DIRECTORY", "Read templates from DIRECTORY.") do |d|
+        config[:templates] = d
+      end
+
+      opts.on("-s", "--static DIRECTORY", "Read static files from DIRECTORY.") do |d|
+        config[:static] = d
+      end
+
+      opts.on("-f", "--[no-]force", "Force regeneration of HTML.") do |f|
+        config[:force] = f
+      end
+
+      opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+        config[:verbose] = v
+      end
+
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts opts
+        return 0
+      end
+
+      opts.on_tail("--version", "Show version") do
+        puts opts.ver
+        return 0
+      end
+    end
+
+    begin
+      parser.parse!
+    rescue OptionParser::ParseError
+      parser.warn $!
+      return 1
+    end
+
+    if ARGV.empty? then
+      puts parser
+      return 1
+    end
+
+    directory = ARGV[0]
+
+    if not config_file.nil? then
+      loaded_config = YAML.load(File.read(config_file)) || {}
+      loaded_config.keys.each do |key|
+        loaded_config[key.to_sym] = loaded_config[key]
+        loaded_config.delete(key)
+      end
+    else
+      loaded_config = {}
+    end
+
+    # This sets the right order of precedence of default config, config file and
+    # command-line options. Commandline options are the most important, then
+    # loaded options, and at last it falls back to the default config.
+    config = default_config.merge(loaded_config.merge(config))
+
+    # We make sure to copy all the static resources.
+    puts "Copying static resources to output."
+    Dir["#{config[:static]}/*"].each do |path|
+      output_path = "#{config[:output]}/static/#{File.basename(path)}"
+      FileUtils.cp(path, output_path)
+      puts "cp #{path} #{output_path}" if config[:verbose]
+    end
+
+    puts "Done! Enumerating albums."
+
+    # This dynamically generates a list of all the HAML templates referenced during
+    # a render of album.haml, which we use to figure out if any of them have been
+    # modified since last we generated.
+    deps = Galleruby::TemplateDependencyCalculator.new('album', config)
+    templates_modified = deps.files.collect { |file|
+        path = deps.template_path(file)
+        File.exist?(path) ? File.mtime(path) : Time.now
+    }
+    templates_modified = templates_modified.max
+
+    encountered_links = {}
+
+    # We iterate over each directory inside the directory passed on the commandline,
+    # checking if any of them are considered valid albums (have .galleruby.yml etc,
+    # see Album#valid?) and regenerate thumbnails & HTML if its needed.
+    albums_by_year = Hash.new { |hash, key| hash[key] = [] }
+    Dir.new(directory).each do |album|
+        album = Galleruby::Album.new(directory, album)
+
+        next if not album.valid?
+
+        if encountered_links.has_key?(album.link) then
+          puts "#{album.name}: WARNING! This album has the same link name as '#{encountered_links[album.link]}', skipping."
+          next
+        end
+
+        encountered_links[album.link] = album.name
+
+        if config[:force] or album.needs_updating?(config[:output], templates_modified) then
+            puts "#{album.name}: Processing album"
+            if not album.process(config, config[:output]) then
+                puts "#{album.name}: WARNING! No images to process, skipping"
+                next
+            end
+
+            puts "#{album.name}: Rendering HTML"
+            album.render_to(config, config[:output])
+        else
+            puts "#{album.name}: No update needed, skipping"
+        end
+
+        albums_by_year[album.year] << album
+    end
+
+    puts "All done! Generating index."
+
+    # Finally we generate the index unconditionally, since it's a really cheap
+    # operation. It's possible that we should not do this unless neeed, so that
+    # index.html's mtime will have some value.
+    albums_by_year = albums_by_year.sort_by { |e| e[0] }.reverse.map {|year, albums| {:year => year, :albums => albums.map {|album| album.template_info }.sort_by {|album| album[:first]}.reverse } }
+    Galleruby::Template.new('index', config).render_to("#{config[:output]}/index.html", {:albums_by_year => albums_by_year}, config[:output])
+
+    return 0
+end
+
+exit main

data/bin/make_titles

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+
+require 'ftools'
+require 'fileutils'
+require 'yaml'
+
+if ARGV.empty? then
+    puts "Syntax: #{$0} <directory>"
+    exit(1);
+end
+
+directory = ARGV[0]
+Dir.new(directory).each { |album|
+    settings_file = "#{directory}/#{album}/.galleruby.yml"
+    skip_file = "#{directory}/#{album}/.galleruby.skip"
+
+    next if album.start_with? '.'
+    next if not File.directory? "#{directory}/#{album}"
+    next if File.exist? skip_file
+
+    info = {}
+    if File.exist? settings_file then
+        info = YAML::load(File.read(settings_file))
+    end
+
+    next if info.has_key? 'link' and info.has_key? 'title'
+
+    puts "> Directory #{album}, #{Dir.entries(directory + "/" + album).length - 2} files"
+
+    if not info.has_key? 'title' then
+        default_title = album.sub(/^\d+-\d+-\d+( - \d+)?/, '').strip
+        puts "   What should the title be? [#{default_title}]"
+        title = STDIN.gets
+        if title.nil?
+            FileUtils.touch skip_file
+            puts "   Skipping album"
+            next
+        else
+            title = title.chomp
+        end
+
+        if title.empty? then
+            title = default_title
+        end
+
+        info['title'] = title
+    end
+
+    if not info.has_key? 'link' then
+        default_link = info['title'].sub(/^\d+-\d+-\d+( - \d+)?/, '').downcase
+        default_link = default_link.sub('ø', 'oe').sub('å', 'aa').sub('æ', 'ae')
+        default_link.gsub!(/[^a-z0-9_-]/, '')
+        puts "   What should the link name be? [#{default_link}]"
+        link = STDIN.gets
+        if link.nil?
+            FileUtils.touch skip_file
+            puts "   Skipping album"
+            next
+        else
+            link = link.chomp
+        end
+
+        if link.empty? then
+            link = default_link
+        end
+
+        info['link'] = link
+    end
+
+    File.open(settings_file, 'w') {|file| file.write(YAML.dump(info)) }
+}

data/config.yml.dist

@@ -0,0 +1,4 @@
+title: Cool Joe's Gallery
+thumb: [320, 256]
+medium: [800, 600]
+large: [1280, 1024]

data/galleruby.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "galleruby/version"
+
+Gem::Specification.new do |s|
+  s.name        = "galleruby"
+  s.version     = Galleruby::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jørgen P. Tjernø"]
+  s.email       = ["jorgenpt@gmail.com"]
+  s.homepage    = "https://github.com/jorgenpt/galleruby"
+  s.summary     = %q{A tool to automatically generate a static HTML gallery}
+  s.description = %q{Galleruby allows you to automatically generate a static HTML gallery from a set of directories containing photos - each directory an album.
+  It is indended to allow you to publish this on static file hosts like Amazon S3.}
+
+  s.rubyforge_project = "galleruby"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'haml'
+  s.add_dependency 'rmagick'
+end

data/lib/galleruby.rb

@@ -0,0 +1,6 @@
+module Galleruby
+  require 'galleruby/version'
+  require 'galleruby/utilities'
+  require 'galleruby/template'
+  require 'galleruby/album'
+end

data/lib/galleruby/album.rb

@@ -0,0 +1,246 @@
+require 'fileutils'
+require 'yaml'
+require 'rmagick'
+
+module Galleruby
+  TRACK_ALLOCATIONS = false
+  EXIF_DATE_FORMAT = '%Y:%m:%d %H:%M:%S'
+
+  class Album
+      attr_reader :name
+
+      # Album representing the passed in name in the passed in directory.
+      def initialize(directory, name)
+          @name = name
+          @path = "#{directory}/#{name}"
+          @settings_file = "#{@path}/.galleruby.yml"
+          @skip_file = "#{@path}/.galleruby.skip"
+
+
+          skiplist_file = "#{@skip_file}list"
+          if File.exist? skiplist_file then
+              @skiplist = YAML::load(File.read(skiplist_file))
+          end
+          @skiplist ||= []
+
+          if valid? then
+              @info = YAML::load(File.read(@settings_file))
+              # YAML serializes DateTime as Time, so we convert back.
+              @info['first'] = @info['first'].to_datetime if @info.has_key?('first')
+          end
+
+          @info ||= {}
+
+          @images_by_date = nil
+      end
+
+      # Whether or not the input directory is considered a valid Galleruby album,
+      # i.e. if it has the metadata-file, is not a 'hidden' directory and does not
+      # have a blacklist (.galleruby.skip) file.
+      def valid?
+          return false if @name.start_with? '.'
+          return false if not File.directory? @path
+          return false if not File.exist? @settings_file
+          return false if File.exist? @skip_file
+
+          return true
+      end
+
+      # When the output HTML was last generated.
+      def last_updated output_directory
+          output_file = "#{output_directory}/#{@info['link']}/index.html"
+          if File.exist? output_file then
+              File.mtime output_file
+          else
+              Time.at(0)
+          end
+      end
+
+      # Whether or not the album needs to update the generated HTML file and
+      # possibly the resized images, based on when the input images were modified
+      # and when the input HAML templates were last modified.
+      def needs_updating?(output_directory, templates_modified)
+          updated = last_updated output_directory
+
+          # If the template is more recent, we need to update.
+          return true if templates_modified > updated
+
+          # If any of the images are more recent, we need to update.
+          Dir.new(@path).each do |entry|
+              next if not entry.match /\.jpe?g$/i
+              return true if updated < File.mtime("#{@path}/#{entry}")
+          end
+
+          return false
+      end
+
+      # Whether or not the passed in filename needs to be generated from its
+      # input, given when the input was last updated.
+      def file_needs_updating?(output_filename, original_mtime)
+          return true if not File.exist? output_filename
+          return true if File.mtime(output_filename) < original_mtime
+
+          # TODO: Check for 'first' etc in @info.
+
+          return false
+      end
+
+      # Process generates any resized images for the album as needed, and also
+      # generates metadata about the album that's cached in .galleruby.yml inside
+      # the albums source directory
+      def process(config, output_directory)
+          to_process = []
+          Dir.new(@path).each { |entry|
+              next if not entry.match /\.jpe?g$/i
+              next if @skiplist.include? entry
+
+              to_process << entry
+          }
+
+          return false if to_process.empty?
+
+          output_album = "#{output_directory}/#{@info['link']}"
+          output_thumb = "#{output_album}/small"
+          output_medium = "#{output_album}/medium"
+          output_large = "#{output_album}/large"
+
+          FileUtils.mkdir_p [output_thumb, output_medium, output_large]
+
+          @images_by_date = Hash.new {|hash, key| hash[key] = [] }
+          first_taken, last_taken = nil, nil
+
+          # We go over each (loosely defined) valid image in the directory, and
+          # generate any thumbnail, medium or large versions needed. In addition, we
+          # find the range of the EXIF DateTime header for the album, so that we
+          # can store that as metadata for the album.
+          to_process.each do |entry|
+              filename = "#{@path}/#{entry}"
+              thumb_filename = "#{output_thumb}/#{entry}"
+              medium_filename = "#{output_medium}/#{entry}"
+              large_filename = "#{output_large}/#{entry}"
+
+              image = LazyObject.new { o = Magick::Image.read(filename).first; o.auto_orient!; o }
+              original_mtime = File.mtime filename
+
+              if file_needs_updating?(large_filename, original_mtime) then
+                  new_image = image.resize_to_fit(*config[:large])
+                  new_image.write(large_filename)
+                  image.destroy!
+
+                  image = new_image
+              end
+
+              if file_needs_updating?(medium_filename, original_mtime) then
+                  medium_image = image.resize_to_fit(*config[:medium])
+                  medium_image.write(medium_filename)
+                  medium_image.destroy!
+              end
+
+              if file_needs_updating?(thumb_filename, original_mtime) then
+                  thumb_image = image.resize_to_fit(*config[:thumb])
+                  thumb_image.write(thumb_filename)
+              else
+                  thumb_image = Magick::Image.ping(thumb_filename).first
+              end
+
+              taken = thumb_image.get_exif_by_entry('DateTimeOriginal').first[1]
+              taken = DateTime.strptime(taken, EXIF_DATE_FORMAT)
+
+              if last_taken.nil? then
+                  last_taken = taken
+              else
+                  last_taken = taken if taken > last_taken
+              end
+
+              if first_taken.nil? then
+                  first_taken = taken
+              else
+                  first_taken = taken if taken < first_taken
+              end
+
+              @images_by_date[taken.strftime('%F')] << {
+                  :taken => taken,
+                  :data => {
+                      :filename => entry,
+                      :thumb_width => thumb_image.columns,
+                      :thumb_height => thumb_image.rows
+                  }
+              }
+
+              thumb_image.destroy!
+              if not image.nil? and (image.is_a?(LazyObject) and image.was_initialized?) then
+                  image.destroy!
+              end
+
+              if TRACK_ALLOCATIONS and num_allocated > 0 then
+                  puts "#{name}: Num allocated: #{num_allocated}"
+              end
+          end
+
+          @info['first'] = first_taken
+          if first_taken.strftime('%F') == last_taken.strftime('%F') then
+              @info['date'] = first_taken.strftime('%e. %b, %Y').lstrip
+          else
+              range_start = first_taken.strftime('%e').lstrip
+              if first_taken.year == last_taken.year then
+                  if first_taken.month != last_taken.month then
+                      range_start << first_taken.strftime('. %b')
+                  end
+              else
+                  range_start << first_taken.strftime('. %b, %Y')
+              end
+
+              date_range = "#{range_start} - #{last_taken.strftime('%e. %b, %Y').lstrip}"
+              @info['date'] = date_range
+          end
+
+          # Here we write out the original metadata + the EXIF date range we've
+          # identified.
+          File.open(@settings_file, 'w') { |file| file.write(YAML.dump(@info)) }
+
+          return true
+      end
+
+      # Create a HTML-file for the album.
+      def render_to(config, output_directory)
+          images_by_date = @images_by_date.sort.map do |day, images|
+              {
+                  :date => Date.strptime(day),
+                  :images => images.sort_by {|image| image[:taken]}.map {|image| image[:data]}
+              }
+          end
+
+          output_file = "#{output_directory}/#{@info['link']}/index.html"
+          Template.new('album', config).render_to(output_file, {:title => @info['title'], :images_by_date => images_by_date}, output_directory)
+      end
+
+      # The year that the first photo was taken in.
+      def year
+          @info['first'].strftime('%Y')
+      end
+
+      def link
+        @info['link']
+      end
+
+      # Data needed for generation of the index document.
+      def template_info
+          {:name => @info['title'], :link => @info['link'], :date => @info['date'], :first => @info['first']}
+      end
+  end
+
+  # If we TRACK_ALLOCATIONS, we keep a count of "currently allocated images", so
+  # that we can identify memory leaks.
+  num_allocated = 0
+  if TRACK_ALLOCATIONS then
+      Magick.trace_proc = Proc.new do |which, description, id, method|
+          if which == :c then
+              num_allocated += 1
+          elsif which == :d then
+              num_allocated -= 1
+          else
+              puts "#{which} #{id} #{description} (from #{method})"
+          end
+      end
+  end
+end