photo_folder 1.0

data/README.markdown

@@ -0,0 +1,2 @@
+PhotoFolder Gem
+===============

data/lib/models/photo.rb

@@ -0,0 +1,115 @@
+class Photo < ActiveRecord::Base
+  belongs_to :photo_collection
+  has_many :photo_taggings, :dependent => :destroy
+  has_many :photo_tags, :through => :photo_taggings
+  acts_as_list :scope => :photo_collection
+  before_create :set_exif_data, :set_last_modified, :set_guid, :set_nsfw
+  after_create :set_tags
+  
+  def self.guid(path,date)
+    Digest::MD5.hexdigest([
+      path,
+      date
+    ].join(''))
+  end
+  
+  def full_path
+    File.join(PhotoFolder.source_directory_location,path)
+  end
+  
+  def update_meta
+    set_exif_data
+    set_last_modified
+    set_guid
+    set_nsfw
+    save
+    set_tags
+  end
+  
+  def set_guid
+    self.guid = Photo.guid(path,date)
+  end
+  
+  def set_tags
+    #@tags was set by set_exif_data, which is always called first
+    self.photo_taggings.destroy_all
+    @tags.each do |str|
+      self.photo_taggings.create({
+        :photo_tag_id => (PhotoTag.find_by_tag(str) || PhotoTag.create(:tag => str)).id,
+        :photo_id => self.id
+      })
+    end
+  end
+  
+  def set_nsfw
+    self.nsfw = @tags.collect(&:downcase).include?('nsfw') ? 1 : 0
+  end
+  
+  def set_last_modified
+    self.last_modified = File.mtime(full_path)
+  end
+  
+  def set_exif_data
+    begin
+      exif = EXIFData.new(MiniExiftool.new(full_path),logger)
+      
+      [:focal_length,:iso,:shutter_speed,:f_stop,:camera,:caption,:location,:height,:width].each do |key|
+        self.send(key.to_s + '=',exif[key] || nil)
+      end
+      
+      #date,title,lens and tags are special cases
+      if exif[:date].is_a? Time
+        self.date = exif[:date]
+      else
+        date_match = (exif[:date] || '').match(/([\d]+):([\d]+):([\d]+) ([\d]+):([\d]+):([\d]+)/)
+        self.date = Time.mktime(date_match[1],date_match[2],date_match[3],date_match[4],date_match[5],date_match[6]) if date_match
+      end
+      self.name = exif[:title] || full_path.split('/').pop.gsub(/\.[a-zA-Z]{1,4}/,'')
+      self.lens = exif[:lens] ? exif[:lens] : nil
+      @tags = exif[:tags] || []
+    rescue
+      self.name = full_path.split('/').pop.gsub(/\.[a-zA-Z]{1,4}/,'')
+      @tags = []
+    end
+  end
+  
+  class EXIFData
+    EXIF_TRANSLATIONS = {
+      :title => ['Title','ObjectName'],
+      :focal_length => ['FocalLength'],
+      :iso => ['ISO'],
+      :height => ['ImageHeight'],
+      :width => ['ImageWidth'],
+      :shutter_speed => ['ShutterSpeedValue'],
+      :f_stop => ['ApertureValue'],
+      :lens => ['Lens','LensType'],
+      :camera => ['Model'],
+      :date => ['DateTimeOriginal'],
+      :caption => ['Description','ImageDescription','Caption-Abstract'],
+      :tags => ['Keywords','Subject'],
+      :location => ['Location'],
+    }
+    
+    EXIF_TRANSFORMATIONS = {
+      #:date => lambda{|exif_value| exif_value.to_s.split('-').shift},
+      :shutter_speed => lambda{|exif_value| exif_value.to_s.gsub(/1\//,'')},
+      :focal_length => lambda{|exif_value| exif_value.to_s.gsub(/\.([\d]{1,})?\s?.+$/,'')},
+      :tags => lambda{|exif_value| (exif_value.is_a?(Array) ? exif_value.join(',') : exif_value).gsub(/["']+/,'').gsub(/\s+?,\s+?/,',').split(',').collect(&:strip).collect(&:downcase)}
+    }
+    
+    def initialize(exif_data,logger)
+      @exif_data = exif_data
+      @logger = logger
+    end
+    
+    def [](key)
+      EXIF_TRANSLATIONS[key.to_sym].each do |exif_key_name|
+        exif_value = @exif_data[exif_key_name.to_s]
+        if !exif_value.nil? && exif_value != false && exif_value != '' && exif_value != 'false' && exif_value != 'nil'
+          return EXIF_TRANSFORMATIONS[key] ? EXIF_TRANSFORMATIONS[key].call(exif_value) : exif_value
+        end
+      end
+      false
+    end
+  end
+end

data/lib/models/photo_collection.rb

@@ -0,0 +1,96 @@
+class PhotoCollection < ActiveRecord::Base
+  has_many :photos, :order => 'position'  
+  acts_as_list :scope => :parent_id
+  acts_as_tree :order => :name
+  after_create :set_children_parent_id
+  before_create :set_name
+  
+  def self.set_correct_positions(collections,is_callback = false)
+    collections.sort_by(&:name).each_with_index do |collection,i|
+      collection.update_attribute :position, i
+      set_correct_positions(PhotoCollection.find_all_by_parent_id(collection.id),true)
+    end
+    if self.positions && !is_callback
+      self.positions.each_with_index do |file_name,i|
+        photo_collection = PhotoCollection.find_by_path(file_name,{
+          :conditions => {
+            :parent_id => 0
+          }
+        })
+        if photo_collection
+          photo_collection.insert_at i + 1
+        end
+      end
+    end
+  end
+  
+  def self.positions_file_path
+    File.join(PhotoFolder.source_directory_location,'positions.yml')
+  end
+  
+  def self.positions
+    return @positions if !@positions.nil?
+    if File.exists?(self.positions_file_path)
+      @positions = YAML.load(File.read(self.positions_file_path))
+    else
+      nil
+    end
+  end
+  
+  def set_children_parent_id
+    PhotoFolder::all_paths_in_database.select{|path| self.path.underscore.gsub(/\s/,'_') == path.gsub(/\/[^\/]+$/,'').underscore.gsub(/\s/,'_')}.each do |path|
+      Photo.update_all("photo_collection_id = #{self.id}","path = '#{path}'")
+    end
+  end
+  
+  def set_parent_id
+    update_attribute :parent_id, parent_from_path ? parent_from_path.id : 0
+  end
+  
+  def set_name
+    self.name = path.split('/').pop.gsub(/[\_\-]+/,' ').split(/\s+/).each(&:capitalize!).join(' ')
+  end
+  
+  def parent_from_path
+    self.path.count('/') > 0 ? PhotoCollection.find_by_path(self.path.gsub(/\/[^\/]+$/,'')) : false 
+  end
+  
+  def full_path
+    File.join(PhotoFolder.source_directory_location,path)
+  end
+  
+  def positions_file_path
+    File.join(full_path,'positions.yml')
+  end
+  
+  def positions
+    return @positions if !@positions.nil?
+    if File.exists?(positions_file_path)
+      @positions = YAML.load(File.read(positions_file_path))
+    else
+      nil
+    end
+  end
+  
+  def meta_file_path
+    File.join(full_path,'meta.json')
+  end
+  
+  def set_meta
+    meta_data = File.exists?(meta_file_path) ? File.read(meta_file_path) : false
+    write_attribute :meta, meta_data
+    meta_data
+  end
+  
+  def set_correct_positions
+    positions.each_with_index do |file_name,i|
+      photo = photos.find_by_path("#{path}/#{file_name}")
+      photo_collection = children.find_by_path("#{path}/#{file_name}")
+      if photo
+        photo.insert_at i + 1
+      elsif photo_collection
+        photo_collection.insert_at i + 1
+      end
+    end
+  end
+end

data/lib/models/photo_tag.rb

@@ -0,0 +1,3 @@
+class PhotoTag < ActiveRecord::Base
+  has_many :photos, :through => :photo_taggings
+end

data/lib/models/photo_tagging.rb

@@ -0,0 +1,4 @@
+class PhotoTagging < ActiveRecord::Base
+  belongs_to :photo_tag
+  belongs_to :photo
+end

data/lib/photo_folder.rb

@@ -0,0 +1,296 @@
+#external libraries
+require 'rubygems'
+gem 'sqlite3-ruby'
+gem 'activerecord'
+require 'activerecord'
+require 'fileutils'
+require 'tempfile'
+require 'pstore'
+require 'set'
+require 'ftools'
+require 'digest/md5'
+require 'yaml'
+
+#internal libraries
+require 'lib/vendor/acts_as_tree'
+require 'lib/vendor/acts_as_list'
+require 'lib/vendor/mini_exiftool'
+require 'lib/models/photo'
+require 'lib/models/photo_tag'
+require 'lib/models/photo_tagging'
+require 'lib/models/photo_collection'
+
+unless Numeric.instance_methods.include? 'to_a'
+  class Numeric
+    def to_a
+      [self]
+    end
+  end
+end
+
+module PhotoFolder
+  def self.setup_database(database_location)
+    ActiveRecord::Base.establish_connection(
+      :adapter  => "sqlite3",
+      :database => database_location,
+      :timeout => 5000
+    )
+    PhotoFolder::create_schema
+  end
+  
+  def self.create_schema
+    if !Photo.table_exists?
+      ActiveRecord::Base.connection.create_table("photos") do |t|
+        t.integer  "photo_collection_id"
+        t.integer  "position"
+        t.integer  "height"
+        t.integer  "width"
+        t.string   "guid"
+        t.string   "path"
+        t.string   "name"
+        t.datetime "date"
+        t.string   "location"
+        t.string   "f_stop"
+        t.string   "shutter_speed"
+        t.string   "focal_length"
+        t.string   "iso"
+        t.string   "camera"
+        t.string   "lens"
+        t.text     "caption"
+        t.datetime "last_modified"
+        t.integer  "nsfw"
+        t.integer  "featured"
+      end
+    end
+    
+    if !PhotoCollection.table_exists?
+      ActiveRecord::Base.connection.create_table("photo_collections") do |t|
+        t.string  "name"
+        t.string  "path"
+        t.integer "parent_id"
+        t.integer "position"
+        t.text "meta"
+      end
+    end
+    
+    if !PhotoTag.table_exists?
+      ActiveRecord::Base.connection.create_table("photo_tags") do |t|
+        t.string "tag"
+      end
+    end
+    
+    if !PhotoTagging.table_exists?
+      ActiveRecord::Base.connection.create_table("photo_taggings") do |t|
+        t.integer "photo_tag_id"
+        t.integer "photo_id"
+      end
+    end
+  end
+  
+  def self.photos_list
+    return @photos_list if !@photos_list.nil?
+    @photos_list = Dir[PhotoFolder.source_directory_location + '/**/*.{png,jpg}']
+  end
+  
+  def self.all_paths_in_database
+    return @all_paths_in_database if !@all_paths_in_database.nil?
+    @all_paths_in_database = Photo.find(:all).collect(&:path)
+  end
+  
+  def self.all_paths_in_filesystem
+    return @all_paths_in_filesystem if !@all_paths_in_filesystem.nil?
+    @all_paths_in_filesystem = PhotoFolder::photos_list.collect{|file| file.gsub(PhotoFolder.source_directory_location + '/','')}
+  end
+  
+  def self.flush_cached_path_information
+    @all_paths_in_filesystem = nil
+    @all_paths_in_database = nil
+  end
+  
+  def self.scan_photos
+    to_add = []
+    to_update = []
+    to_remove = []
+    
+    PhotoFolder::all_paths_in_filesystem.each do |path_in_filesystem|
+      to_add.push(path_in_filesystem) if !PhotoFolder::all_paths_in_database.select{|path_in_database| path_in_database == path_in_filesystem}[0]
+    end
+    
+    PhotoFolder::all_paths_in_database.each do |path_in_database|
+      to_remove.push(path_in_database) if !PhotoFolder::all_paths_in_filesystem.select{|path_in_filesystem| path_in_filesystem == path_in_database}[0]
+    end
+    
+    PhotoFolder::all_paths_in_filesystem.each do |path_in_filesystem|
+      if !to_add.include?(path_in_filesystem) && !to_remove.include?(path_in_filesystem)
+        entry = Photo.find_by_path(path_in_filesystem)
+        if entry && File.mtime(entry.full_path) > entry.last_modified
+          to_update.push(path_in_filesystem)
+        end
+      elsif to_add.include?(path_in_filesystem)
+        #cleaned = Photo.clean_filename(path_in_filesystem)
+        entry = Photo.find_by_path(path_in_filesystem)
+        if entry
+          to_update.push(path_in_filesystem)
+        end
+      end
+    end
+    
+    to_add.reject!{|item| to_update.include?(item)}
+    
+    [to_add,to_update,to_remove]
+  end
+  
+  def self.scan_photo_collections
+    collection_paths_in_database = PhotoCollection.find(:all).collect(&:path)
+    
+    collection_paths_in_filesystem = []
+    PhotoFolder::all_paths_in_database.each do |path|
+      collection = path.gsub(/\/[^\/]+$/,'')
+      collection_bits = collection.split('/')
+      collection_bits.each_with_index do |part,i|
+        joined = collection_bits[0,i].join('/')
+        collection_paths_in_filesystem.push(joined) if !collection_paths_in_filesystem.include?(joined) && joined != ''
+      end
+      collection_paths_in_filesystem.push(collection) if !collection_paths_in_filesystem.include?(collection)
+    end
+    
+    to_add = []
+    to_remove = []
+    
+    collection_paths_in_filesystem.each do |path_in_filesystem|
+      to_add.push(path_in_filesystem) if !collection_paths_in_database.include?(path_in_filesystem)
+    end
+    
+    collection_paths_in_database.each do |path_in_database|
+      to_remove.push(path_in_database) if !collection_paths_in_filesystem.include?(path_in_database)
+    end
+    
+    [to_add,to_remove]
+  end
+  
+  def self.hash_from_database
+    {
+      :photo_collections => PhotoCollection,
+      :photos => Photo,
+      :photo_tags => PhotoTag,
+      :photo_taggings => PhotoTagging
+    }.inject(Hash.new) do |result,key_name_and_model|
+      key_name = key_name_and_model[0]
+      model = key_name_and_model[1]
+      result[key_name] = model.find(:all).inject(Hash.new) do |inner_result,item|
+        inner_result[item.id.to_s] = item.attributes.inject(Hash.new) do |attribute_result,key_and_value|
+          key = key_and_value[0]
+          value = key_and_value[1]
+          attribute_result[key.to_s] = value.to_s
+          attribute_result
+        end
+        inner_result
+      end
+      result
+    end
+  end
+  
+  def self.write_database_to_file(path)
+    File.open(path,'w'){|f| f.write(PhotoFolder::hash_from_database.to_json) }
+  end
+  
+  def self.source_directory_location
+    @source_directory_location
+  end
+  
+  def self.generate(source_directory_location,database_location,json_location,include_nsfw = false,exif_tool_location = 'exiftool')
+    Photo.send(:with_scope, :find => {:conditions => include_nsfw ? "nsfw = 1 OR nsfw = 0" : "nsfw = 0"}) do
+      
+      @source_directory_location = source_directory_location
+      
+      begin
+        MiniExiftool.configure(exif_tool_location)
+      rescue
+        puts "WARNING: Could not configure MiniExifTool, EXIF data will not be parsed."
+      end
+      
+      puts "PhotoFolder Database Generator"
+      puts "=============================="
+      
+      PhotoFolder::setup_database(database_location)
+      photos_list = PhotoFolder::photos_list
+      puts "Scanning #{photos_list.length} photos in #{source_directory_location}"
+      
+      photos_to_add, photos_to_update, photos_to_remove = PhotoFolder::scan_photos
+      
+      Photo.transaction do
+        if photos_to_add.length > 0
+          photos_to_add.each do |path|
+            puts "Adding photo: #{path}"
+            Photo.create :path => path
+          end
+        else
+          puts "No photos to add."
+        end
+      
+        if photos_to_update.length > 0
+          photos_to_update.each do |path|
+            puts "Updating photo: #{path}"
+            photo = Photo.find_by_path(path)
+            photo.update_meta if photo
+          end
+        else
+          puts "No photos to update."
+        end
+      
+        if photos_to_remove.length > 0
+          photos_to_remove.each do |path|
+            puts "Removing photo: #{path}"
+            Photo.find_all_by_path(path).each(&:destroy)
+          end
+        else
+          puts "No photos to remove."
+        end
+      end
+      
+      PhotoFolder::flush_cached_path_information
+      collections_to_add, collections_to_remove = PhotoFolder::scan_photo_collections
+      
+      PhotoCollection.transaction do
+        if collections_to_add.length > 0
+          collections_to_add.sort_by{|path| path.split('/').pop}.each do |path|
+            puts "Adding collection: #{path}"
+            PhotoCollection.create :path => path
+          end
+        else
+          puts "No photo collections to add."
+        end
+      
+        if collections_to_remove.length > 0
+          collections_to_remove.each do |path|
+            puts "Removing collection: #{path}"
+            PhotoCollection.find_by_path(path).destroy if PhotoCollection.find_by_path(path)
+          end
+        else
+          puts "No photo collections to remove."
+        end
+      
+        puts "Ensuring correct tree structure of photo collections."
+        PhotoCollection.find(:all).each(&:set_parent_id)
+        
+        puts "Ensuring correct position of photos and photo collections."
+        if PhotoCollection.positions
+          puts "Setting positions for root collections from #{PhotoCollection.positions_file_path}"
+        end
+        PhotoCollection.set_correct_positions(PhotoCollection.find_all_by_parent_id(0))
+        PhotoCollection.find(:all).each do |photo_collection|
+          if photo_collection.positions
+            puts "Setting positions for #{photo_collection.name} from #{photo_collection.positions_file_path}"
+            photo_collection.set_correct_positions 
+          end
+          if photo_collection.set_meta
+            puts "Setting meta data for #{photo_collection.name} from #{photo_collection.meta_file_path}"
+          end
+        end
+      end
+      
+      puts "Writing database to #{json_location}"
+      PhotoFolder::write_database_to_file(json_location)
+    end
+  end
+end

data/photo_folder.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |s|
+  s.name     = "photo_folder"
+  s.version  = "1.0"
+  s.date     = "2010-05-11"
+  s.summary  = "JavaScript gallery"
+  s.email    = "ryan@syntacticx.com"
+  s.homepage = "http://photofolder.org/"
+  s.description = "JavaScript gallery"
+  s.has_rdoc = false
+  s.authors  = ["Ryan Johnson"]
+  s.files    = [
+    "README.markdown", 
+    "photo_folder.gemspec"] +
+    Dir['lib/**/*'] +
+    Dir['vendor/**/*']
+  s.autorequire = "lib/photo_folder.rb"
+  s.add_dependency("sqlite3-ruby", ["> 0.0.0"])
+  s.add_dependency("activerecord", ["> 0.0.0"])
+end

data/vendor/acts_as_list.rb

@@ -0,0 +1,257 @@
+module ActiveRecord
+  module Acts #:nodoc:
+    module List #:nodoc:
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # This +acts_as+ extension provides the capabilities for sorting and reordering a number of objects in a list.
+      # The class that has this specified needs to have a +position+ column defined as an integer on
+      # the mapped database table.
+      #
+      # Todo list example:
+      #
+      #   class TodoList < ActiveRecord::Base
+      #     has_many :todo_items, :order => "position"
+      #   end
+      #
+      #   class TodoItem < ActiveRecord::Base
+      #     belongs_to :todo_list
+      #     acts_as_list :scope => :todo_list
+      #   end
+      #
+      #   todo_list.first.move_to_bottom
+      #   todo_list.last.move_higher
+      module ClassMethods
+        # Configuration options are:
+        #
+        # * +column+ - specifies the column name to use for keeping the position integer (default: +position+)
+        # * +scope+ - restricts what is to be considered a list. Given a symbol, it'll attach <tt>_id</tt> 
+        #   (if it hasn't already been added) and use that as the foreign key restriction. It's also possible 
+        #   to give it an entire string that is interpolated if you need a tighter scope than just a foreign key.
+        #   Example: <tt>acts_as_list :scope => 'todo_list_id = #{todo_list_id} AND completed = 0'</tt>
+        def acts_as_list(options = {})
+          configuration = { :column => "position", :scope => "1 = 1" }
+          configuration.update(options) if options.is_a?(Hash)
+
+          configuration[:scope] = "#{configuration[:scope]}_id".intern if configuration[:scope].is_a?(Symbol) && configuration[:scope].to_s !~ /_id$/
+
+          if configuration[:scope].is_a?(Symbol)
+            scope_condition_method = %(
+              def scope_condition
+                if #{configuration[:scope].to_s}.nil?
+                  "#{configuration[:scope].to_s} IS NULL"
+                else
+                  "#{configuration[:scope].to_s} = \#{#{configuration[:scope].to_s}}"
+                end
+              end
+            )
+          else
+            scope_condition_method = "def scope_condition() \"#{configuration[:scope]}\" end"
+          end
+
+          class_eval <<-EOV
+            include ActiveRecord::Acts::List::InstanceMethods
+
+            def acts_as_list_class
+              ::#{self.name}
+            end
+
+            def position_column
+              '#{configuration[:column]}'
+            end
+
+            #{scope_condition_method}
+
+            before_destroy :remove_from_list
+            before_create  :add_to_list_bottom
+          EOV
+        end
+      end
+
+      # All the methods available to a record that has had <tt>acts_as_list</tt> specified. Each method works
+      # by assuming the object to be the item in the list, so <tt>chapter.move_lower</tt> would move that chapter
+      # lower in the list of all chapters. Likewise, <tt>chapter.first?</tt> would return +true+ if that chapter is
+      # the first in the list of all chapters.
+      module InstanceMethods
+        # Insert the item at the given position (defaults to the top position of 1).
+        def insert_at(position = 1)
+          insert_at_position(position)
+        end
+
+        # Swap positions with the next lower item, if one exists.
+        def move_lower
+          return unless lower_item
+
+          acts_as_list_class.transaction do
+            lower_item.decrement_position
+            increment_position
+          end
+        end
+
+        # Swap positions with the next higher item, if one exists.
+        def move_higher
+          return unless higher_item
+
+          acts_as_list_class.transaction do
+            higher_item.increment_position
+            decrement_position
+          end
+        end
+
+        # Move to the bottom of the list. If the item is already in the list, the items below it have their
+        # position adjusted accordingly.
+        def move_to_bottom
+          return unless in_list?
+          acts_as_list_class.transaction do
+            decrement_positions_on_lower_items
+            assume_bottom_position
+          end
+        end
+
+        # Move to the top of the list. If the item is already in the list, the items above it have their
+        # position adjusted accordingly.
+        def move_to_top
+          return unless in_list?
+          acts_as_list_class.transaction do
+            increment_positions_on_higher_items
+            assume_top_position
+          end
+        end
+
+        # Removes the item from the list.
+        def remove_from_list
+          if in_list?
+            decrement_positions_on_lower_items
+            update_attribute position_column, nil
+          end
+        end
+
+        # Increase the position of this item without adjusting the rest of the list.
+        def increment_position
+          return unless in_list?
+          update_attribute position_column, self.send(position_column).to_i + 1
+        end
+
+        # Decrease the position of this item without adjusting the rest of the list.
+        def decrement_position
+          return unless in_list?
+          update_attribute position_column, self.send(position_column).to_i - 1
+        end
+
+        # Return +true+ if this object is the first in the list.
+        def first?
+          return false unless in_list?
+          self.send(position_column) == 1
+        end
+
+        # Return +true+ if this object is the last in the list.
+        def last?
+          return false unless in_list?
+          self.send(position_column) == bottom_position_in_list
+        end
+
+        # Return the next higher item in the list.
+        def higher_item
+          return nil unless in_list?
+          acts_as_list_class.find(:first, :conditions =>
+            "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i - 1).to_s}"
+          )
+        end
+
+        # Return the next lower item in the list.
+        def lower_item
+          return nil unless in_list?
+          acts_as_list_class.find(:first, :conditions =>
+            "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i + 1).to_s}"
+          )
+        end
+
+        # Test if this record is in a list
+        def in_list?
+          !send(position_column).nil?
+        end
+
+        private
+          def add_to_list_top
+            increment_positions_on_all_items
+          end
+
+          def add_to_list_bottom
+            self[position_column] = bottom_position_in_list.to_i + 1
+          end
+
+          # Overwrite this method to define the scope of the list changes
+          def scope_condition() "1" end
+
+          # Returns the bottom position number in the list.
+          #   bottom_position_in_list    # => 2
+          def bottom_position_in_list(except = nil)
+            item = bottom_item(except)
+            item ? item.send(position_column) : 0
+          end
+
+          # Returns the bottom item
+          def bottom_item(except = nil)
+            conditions = scope_condition
+            conditions = "#{conditions} AND #{self.class.primary_key} != #{except.id}" if except
+            acts_as_list_class.find(:first, :conditions => conditions, :order => "#{position_column} DESC")
+          end
+
+          # Forces item to assume the bottom position in the list.
+          def assume_bottom_position
+            update_attribute(position_column, bottom_position_in_list(self).to_i + 1)
+          end
+
+          # Forces item to assume the top position in the list.
+          def assume_top_position
+            update_attribute(position_column, 1)
+          end
+
+          # This has the effect of moving all the higher items up one.
+          def decrement_positions_on_higher_items(position)
+            acts_as_list_class.update_all(
+              "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} <= #{position}"
+            )
+          end
+
+          # This has the effect of moving all the lower items up one.
+          def decrement_positions_on_lower_items
+            return unless in_list?
+            acts_as_list_class.update_all(
+              "#{position_column} = (#{position_column} - 1)", "#{scope_condition} AND #{position_column} > #{send(position_column).to_i}"
+            )
+          end
+
+          # This has the effect of moving all the higher items down one.
+          def increment_positions_on_higher_items
+            return unless in_list?
+            acts_as_list_class.update_all(
+              "#{position_column} = (#{position_column} + 1)", "#{scope_condition} AND #{position_column} < #{send(position_column).to_i}"
+            )
+          end
+
+          # This has the effect of moving all the lower items down one.
+          def increment_positions_on_lower_items(position)
+            acts_as_list_class.update_all(
+              "#{position_column} = (#{position_column} + 1)", "#{scope_condition} AND #{position_column} >= #{position}"
+           )
+          end
+
+          # Increments position (<tt>position_column</tt>) of all items in the list.
+          def increment_positions_on_all_items
+            acts_as_list_class.update_all(
+              "#{position_column} = (#{position_column} + 1)",  "#{scope_condition}"
+            )
+          end
+
+          def insert_at_position(position)
+            remove_from_list
+            increment_positions_on_lower_items(position)
+            self.update_attribute(position_column, position)
+          end
+      end 
+    end
+  end
+end
+ActiveRecord::Base.class_eval { include ActiveRecord::Acts::List }

data/vendor/acts_as_tree.rb

@@ -0,0 +1,97 @@
+module ActiveRecord
+  module Acts
+    module Tree
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Specify this +acts_as+ extension if you want to model a tree structure by providing a parent association and a children
+      # association. This requires that you have a foreign key column, which by default is called +parent_id+.
+      #
+      #   class Category < ActiveRecord::Base
+      #     acts_as_tree :order => "name"
+      #   end
+      #
+      #   Example:
+      #   root
+      #    \_ child1
+      #         \_ subchild1
+      #         \_ subchild2
+      #
+      #   root      = Category.create("name" => "root")
+      #   child1    = root.children.create("name" => "child1")
+      #   subchild1 = child1.children.create("name" => "subchild1")
+      #
+      #   root.parent   # => nil
+      #   child1.parent # => root
+      #   root.children # => [child1]
+      #   root.children.first.children.first # => subchild1
+      #
+      # In addition to the parent and children associations, the following instance methods are added to the class
+      # after calling <tt>acts_as_tree</tt>:
+      # * <tt>siblings</tt> - Returns all the children of the parent, excluding the current node (<tt>[subchild2]</tt> when called on <tt>subchild1</tt>)
+      # * <tt>self_and_siblings</tt> - Returns all the children of the parent, including the current node (<tt>[subchild1, subchild2]</tt> when called on <tt>subchild1</tt>)
+      # * <tt>ancestors</tt> - Returns all the ancestors of the current node (<tt>[child1, root]</tt> when called on <tt>subchild2</tt>)
+      # * <tt>root</tt> - Returns the root of the current node (<tt>root</tt> when called on <tt>subchild2</tt>)
+      module ClassMethods
+        # Configuration options are:
+        #
+        # * <tt>foreign_key</tt> - specifies the column name to use for tracking of the tree (default: +parent_id+)
+        # * <tt>order</tt> - makes it possible to sort the children according to this SQL snippet.
+        # * <tt>counter_cache</tt> - keeps a count in a +children_count+ column if set to +true+ (default: +false+).
+        def acts_as_tree(options = {})
+          configuration = { :foreign_key => "parent_id", :order => nil, :counter_cache => nil }
+          configuration.update(options) if options.is_a?(Hash)
+
+          belongs_to :parent, :class_name => name, :foreign_key => configuration[:foreign_key], :counter_cache => configuration[:counter_cache]
+          has_many :children, :class_name => name, :foreign_key => configuration[:foreign_key], :order => configuration[:order], :dependent => :destroy
+
+          class_eval <<-EOV
+            include ActiveRecord::Acts::Tree::InstanceMethods
+
+            def self.roots
+              find(:all, :conditions => "#{configuration[:foreign_key]} IS NULL", :order => #{configuration[:order].nil? ? "nil" : %Q{"#{configuration[:order]}"}})
+            end
+
+            def self.root
+              find(:first, :conditions => "#{configuration[:foreign_key]} IS NULL", :order => #{configuration[:order].nil? ? "nil" : %Q{"#{configuration[:order]}"}})
+            end
+          EOV
+        end
+      end
+
+      module InstanceMethods
+        # Returns list of ancestors, starting from parent until root.
+        #
+        #   subchild1.ancestors # => [child1, root]
+        def ancestors
+          node, nodes = self, []
+          nodes << node = node.parent while node.parent
+          nodes
+        end
+
+        # Returns the root node of the tree.
+        def root
+          node = self
+          node = node.parent while node.parent
+          node
+        end
+
+        # Returns all siblings of the current node.
+        #
+        #   subchild1.siblings # => [subchild2]
+        def siblings
+          self_and_siblings - [self]
+        end
+
+        # Returns all siblings and a reference to the current node.
+        #
+        #   subchild1.self_and_siblings # => [subchild1, subchild2]
+        def self_and_siblings
+          parent ? parent.children : self.class.roots
+        end
+      end
+    end
+  end
+end
+ActiveRecord::Base.send :include, ActiveRecord::Acts::Tree

data/vendor/mini_exiftool.rb

@@ -0,0 +1,416 @@
+class MiniExiftool
+
+  def self.configure(exif_tool_location)
+    MiniExiftool.cmd = exif_tool_location
+    if Float(exiftool_version) < 7.41
+      @@separator = ', '
+      @@sep_op = ''
+    else
+      @@separator = '@@'
+      @@sep_op = '-sep @@'
+    end
+  end
+
+  # Name of the Exiftool command-line application
+  @@cmd = nil
+  cattr_accessor :cmd
+  
+  # Hash of the standard options used when call MiniExiftool.new
+  @@opts = { :numerical => false, :composite => true, :convert_encoding => false, :timestamps => Time }
+
+  attr_reader :filename
+  attr_accessor :numerical, :composite, :convert_encoding, :errors, :timestamps
+
+  VERSION = '1.0.1'
+
+  # +opts+ support at the moment
+  # * <code>:numerical</code> for numerical values, default is +false+
+  # * <code>:composite</code> for including composite tags while loading,
+  #   default is +true+
+  # * <code>:convert_encoding</code> convert encoding (See -L-option of 
+  #   the exiftool command-line application, default is +false+
+  # * <code>:timestamps</code> generating DateTime objects instead of
+  #   Time objects if set to <code>DateTime</code>, default is +Time+
+  #
+  #   <b>ATTENTION:</b> Time objects are created using <code>Time.local</code>
+  #   therefore they use <em>your local timezone</em>, DateTime objects instead
+  #   are created <em>without timezone</em>!
+  def initialize filename=nil, opts={}
+    opts = @@opts.merge opts
+    @numerical = opts[:numerical]
+    @composite = opts[:composite]
+    @convert_encoding = opts[:convert_encoding]
+    @timestamps = opts[:timestamps]
+    @values = TagHash.new
+    @tag_names = TagHash.new
+    @changed_values = TagHash.new
+    @errors = TagHash.new
+    load filename unless filename.nil?
+  end
+
+  def initialize_from_hash hash # :nodoc: 
+    hash.each_pair do |tag,value|
+      set_value tag, value
+    end
+    set_attributes_by_heuristic
+    self
+  end
+
+  # Load the tags of filename.
+  def load filename
+    unless filename && File.exist?(filename)
+      raise MiniExiftool::Error.new("File '#{filename}' does not exist.")
+    end
+    if File.directory?(filename)
+      raise MiniExiftool::Error.new("'#{filename}' is a directory.")
+    end
+    @filename = filename
+    @values.clear
+    @tag_names.clear
+    @changed_values.clear
+    opt_params = ''
+    opt_params << (@numerical ? '-n ' : '')
+    opt_params << (@composite ? '' : '-e ')
+    opt_params << (@convert_encoding ? '-L ' : '')
+    cmd = %Q(#@@cmd -q -q -s -t #{opt_params} #{@@sep_op} "#{filename}")
+    if run(cmd)
+      parse_output
+    else
+      raise MiniExiftool::Error.new(@error_text)
+    end
+    self
+  end
+
+  # Reload the tags of an already readed file.
+  def reload
+    load @filename
+  end
+
+  # Returns the value of a tag.
+  def [] tag
+    @changed_values[tag] || @values[tag]
+  end
+
+  # Set the value of a tag.
+  def []=(tag, val)
+    @changed_values[tag] = val
+  end
+
+  # Returns true if any tag value is changed or if the value of a
+  # given tag is changed.
+  def changed? tag=false
+    if tag
+      @changed_values.include? tag
+    else
+      !@changed_values.empty?
+    end
+  end
+
+  # Revert all changes or the change of a given tag.
+  def revert tag=nil
+    if tag
+      val = @changed_values.delete(tag)
+      res = val != nil
+    else
+      res = @changed_values.size > 0
+      @changed_values.clear
+    end
+    res
+  end
+
+  # Returns an array of the tags (original tag names) of the readed file.
+  def tags
+    @values.keys.map { |key| @tag_names[key] }
+  end
+
+  # Returns an array of all changed tags.
+  def changed_tags
+    @changed_values.keys.map { |key| MiniExiftool.original_tag(key) }
+  end
+
+  # Save the changes to the file.
+  def save
+    return false if @changed_values.empty?
+    @errors.clear
+    temp_file = Tempfile.new('mini_exiftool')
+    temp_file.close
+    temp_filename = temp_file.path
+    FileUtils.cp filename, temp_filename
+    all_ok = true
+    @changed_values.each do |tag, val|
+      original_tag = MiniExiftool.original_tag(tag)
+      arr_val = val.kind_of?(Array) ? val : [val]
+      arr_val.map! {|e| convert e}
+      tag_params = ''
+      arr_val.each do |v|
+        tag_params << %Q(-#{original_tag}="#{v}" )
+      end
+      opt_params = ''
+      opt_params << (arr_val.detect {|x| x.kind_of?(Numeric)} ? '-n ' : '')
+      opt_params << (@convert_encoding ? '-L ' : '')
+      cmd = %Q(#@@cmd -q -P -overwrite_original #{opt_params} #{tag_params} "#{temp_filename}")
+      result = run(cmd)
+      unless result
+        all_ok = false
+        @errors[tag] = @error_text.gsub(/Nothing to do.\n\z/, '').chomp
+      end
+    end
+    if all_ok
+      FileUtils.cp temp_filename, filename
+      reload
+    end
+    temp_file.delete
+    all_ok
+  end
+
+  # Returns a hash of the original loaded values of the MiniExiftool
+  # instance.
+  def to_hash
+    result = {}
+    @values.each do |k,v|
+      result[@tag_names[k]] = v
+    end
+    result
+  end 
+
+  # Returns a YAML representation of the original loaded values of the 
+  # MiniExiftool instance.
+  def to_yaml
+    to_hash.to_yaml
+  end
+
+  # Create a MiniExiftool instance from a hash
+  def self.from_hash hash
+    instance = MiniExiftool.new
+    instance.initialize_from_hash hash
+    instance
+  end
+
+  # Create a MiniExiftool instance from YAML data created with
+  # MiniExiftool#to_yaml
+  def self.from_yaml yaml
+    MiniExiftool.from_hash YAML.load(yaml)
+  end
+
+  # Returns the command name of the called Exiftool application.
+  def self.command
+    @@cmd
+  end
+
+  # Setting the command name of the called Exiftool application.
+  def self.command= cmd
+    @@cmd = cmd
+  end
+
+  # Returns the options hash.
+  def self.opts
+    @@opts
+  end
+
+  # Returns a set of all known tags of Exiftool.
+  def self.all_tags
+    unless defined? @@all_tags
+      @@all_tags = pstore_get :all_tags
+    end
+    @@all_tags
+  end
+
+  # Returns a set of all possible writable tags of Exiftool.
+  def self.writable_tags
+    unless defined? @@writable_tags
+      @@writable_tags = pstore_get :writable_tags
+    end
+    @@writable_tags
+  end
+
+  # Returns the original Exiftool name of the given tag
+  def self.original_tag tag
+    unless defined? @@all_tags_map
+      @@all_tags_map = pstore_get :all_tags_map
+    end
+    @@all_tags_map[tag]
+  end
+
+  # Returns the version of the Exiftool command-line application.
+  def self.exiftool_version
+    output = `#{MiniExiftool.command} -ver 2>&1`
+    unless $?.exitstatus == 0
+      raise MiniExiftool::Error.new("Command '#{MiniExiftool.command}' not found")
+    end
+    output.chomp!
+  end
+
+  def self.unify tag
+    tag.gsub(/[-_]/,'').downcase
+  end
+
+  # Exception class
+  class MiniExiftool::Error < StandardError; end
+  
+  ############################################################################
+  private
+  ############################################################################
+
+  @@error_file = Tempfile.new 'errors'
+  @@error_file.close
+
+  def run cmd
+    if $DEBUG
+      $stderr.puts cmd
+    end
+    @output = `#{cmd} 2>#{@@error_file.path}`
+    @status = $?
+    unless @status.exitstatus == 0
+      @error_text = File.readlines(@@error_file.path).join
+      return false
+    else
+      @error_text = ''
+      return true
+    end
+  end
+
+  def convert val
+    case val
+    when Time
+      val = val.strftime('%Y:%m:%d %H:%M:%S')
+    end
+    val
+  end
+
+  def method_missing symbol, *args
+    tag_name = symbol.id2name
+    if tag_name.sub!(/=$/, '')
+      self[tag_name] = args.first
+    else
+      self[tag_name]
+    end
+  end
+
+  def parse_output
+    @output.each_line do |line|
+      tag, value = parse_line line
+      set_value tag, value
+    end
+  end
+
+  def parse_line line
+    if line =~ /^([^\t]+)\t(.*)$/
+      tag, value = $1, $2
+      case value
+      when /^\d{4}:\d\d:\d\d \d\d:\d\d:\d\d$/
+        arr = value.split /[: ]/
+        arr.map! {|elem| elem.to_i}
+        begin
+          if @timestamps == Time
+            value = Time.local *arr
+          elsif @timestamps == DateTime
+            value = DateTime.strptime(value,'%Y:%m:%d %H:%M:%S') 
+          else
+            raise MiniExiftool::Error.new("Value #@timestamps not allowed for option timestamps.")
+          end
+        rescue ArgumentError
+          value = false
+        end
+      when /^\d+\.\d+$/
+        value = value.to_f
+      when /^0+[1-9]+$/
+        # nothing => String
+      when /^-?\d+$/
+        value = value.to_i
+      when /^[\d ]+$/
+        # nothing => String
+      when /#{@@separator}/
+        value = value.split @@separator
+      end
+    else
+      raise MiniExiftool::Error.new("Malformed line #{line.inspect} of exiftool output.")
+    end
+    unless value.respond_to?('to_a')
+      class << value
+        def to_a
+          [self]
+        end
+      end
+    end
+    return [tag, value]
+  end
+
+  def set_value tag, value
+    @tag_names[tag] = tag
+    @values[tag] = value
+  end
+
+  def set_attributes_by_heuristic
+    self.composite = tags.include?('ImageSize') ? true : false
+    self.numerical = self.file_size.kind_of?(Integer) ? true : false
+    # TODO: Is there a heuristic to determine @convert_encoding?
+    self.timestamps = self.FileModifyDate.kind_of?(DateTime) ? DateTime : Time
+  end
+
+  def temp_filename
+    unless @temp_filename
+      temp_file = Tempfile.new('mini-exiftool')
+      temp_file.close
+      FileUtils.cp(@filename, temp_file.path)
+      @temp_filename = temp_file.path
+    end
+    @temp_filename
+  end
+
+  def self.pstore_get attribute
+    load_or_create_pstore unless defined? @@pstore
+    result = nil
+    @@pstore.transaction(true) do |ps|
+      result = ps[attribute]
+    end
+    result
+  end
+
+  def self.load_or_create_pstore
+    # This will hopefully work on *NIX and Windows systems
+    home = ENV['HOME'] || ENV['HOMEDRIVE'] + ENV['HOMEPATH'] || ENV['USERPROFILE']
+    subdir = RUBY_PLATFORM =~ /win/i ? '_mini_exiftool' : '.mini_exiftool'
+    FileUtils.mkdir_p(File.join(home, subdir))
+    filename = File.join(home, subdir, 'exiftool_tags_' << exiftool_version.gsub('.', '_') << '.pstore')
+    @@pstore = PStore.new filename
+    if !File.exist?(filename) || File.size(filename) == 0
+      @@pstore.transaction do |ps|
+        ps[:all_tags] = all_tags = determine_tags('list')
+        ps[:writable_tags] = determine_tags('listw')
+        map = {}
+        all_tags.each { |k| map[unify(k)] = k }
+        ps[:all_tags_map] = map
+      end
+    end
+  end
+
+  def self.determine_tags arg
+    output = `#{@@cmd} -#{arg}`
+    lines = output.split /\n/
+    tags = Set.new
+    lines.each do |line|
+      next unless line =~ /^\s/
+      tags |= line.chomp.split
+    end
+    tags
+  end
+
+
+  # Hash with indifferent access: 
+  # DateTimeOriginal == datetimeoriginal == date_time_original
+  class TagHash < Hash # :nodoc:
+    def[] k
+      super(unify(k))
+    end
+    def []= k, v
+      super(unify(k), v)
+    end
+    def delete k
+      super(unify(k))
+    end
+
+    def unify tag
+      MiniExiftool.unify tag
+    end
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: photo_folder
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+platform: ruby
+authors: 
+- Ryan Johnson
+autorequire: lib/photo_folder.rb
+bindir: bin
+cert_chain: []
+
+date: 2010-05-11 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+description: JavaScript gallery
+email: ryan@syntacticx.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.markdown
+- photo_folder.gemspec
+- lib/models/photo.rb
+- lib/models/photo_collection.rb
+- lib/models/photo_tag.rb
+- lib/models/photo_tagging.rb
+- lib/photo_folder.rb
+- vendor/acts_as_list.rb
+- vendor/acts_as_tree.rb
+- vendor/mini_exiftool.rb
+has_rdoc: true
+homepage: http://photofolder.org/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: JavaScript gallery
+test_files: []
+