photo_folder 1.0.1 → 1.0.2

data/photo_folder.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name     = "photo_folder"
-  s.version  = "1.0.1"
+  s.version  = "1.0.2"
   s.date     = "2010-05-11"
   s.summary  = "JavaScript gallery"
   s.email    = "ryan@syntacticx.com"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: photo_folder
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: false
   segments: 
   - 1
   - 0
-  - 1
-  version: 1.0.1
+  - 2
+  version: 1.0.2
 platform: ruby
 authors: 
 - Ryan Johnson
@@ -61,11 +61,6 @@ 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

data/lib/models/photo.rb

@@ -1,115 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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

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

data/lib/models/photo_tagging.rb

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

data/lib/photo_folder.rb

@@ -1,296 +0,0 @@
-#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 '../vendor/acts_as_tree'
-require '../vendor/acts_as_list'
-require '../vendor/mini_exiftool'
-require 'models/photo'
-require 'models/photo_tag'
-require 'models/photo_tagging'
-require '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