piccle 0.1.0.rc1 → 0.1.1.pre

data/db/migrations/006_create_people_and_join_table.rb

@@ -0,0 +1,14 @@
+Sequel.migration do
+  change do
+    create_table(:people) do
+      primary_key :id
+      String :name, null: false, unique: true
+    end
+
+    create_table(:people_photos) do
+      Integer :person_id, null: false
+      Integer :photo_id, null: false
+      primary_key [:person_id, :photo_id], name: :people_photos_pk
+    end
+  end
+end

data/db/migrations/007_add_indexes.rb

@@ -0,0 +1,14 @@
+Sequel.migration do
+  change do
+    alter_table(:photos) do
+      add_index :md5, unique: true
+      add_index :file_name
+      add_index :path
+      add_index [:path, :file_name], unique: true
+    end
+
+    # Keywords and people are case-insensitive, enforce that in the DB
+    alter_table(:keywords) { add_index Sequel.function(:lower, :name), unique: true }
+    alter_table(:people) { add_index Sequel.function(:lower, :name), unique: true }
+  end
+end

data/lib/piccle.rb

@@ -13,6 +13,7 @@ require "piccle/streams/date_stream"
 require "piccle/streams/event_stream"
 require "piccle/streams/keyword_stream"
 require "piccle/streams/location_stream"
+require "piccle/streams/person_stream"
 require "piccle/template_helpers"
 require "piccle/version"
 
@@ -38,9 +39,9 @@ module Piccle
   def Piccle.const_missing(name)
     Sequel::Model.db = Piccle.config.db
 
-    if %i[Photo Keyword Location].include?(name)
+    if %i[Keyword Location Person Photo].include?(name)
       Dir[Piccle.config.gem_root_join("lib", "piccle", "models", "*.rb")].each { |f| require f.delete_prefix("lib/").delete_suffix(".rb") }
-      models = [Piccle::Photo, Piccle::Keyword, Piccle::Location]
+      models = [Piccle::Keyword, Piccle::Location, Piccle::Person, Piccle::Photo]
       models.each(&:finalize_associations)
       models.each(&:freeze)
     end

data/lib/piccle/extractor.rb

@@ -51,7 +51,7 @@ module Piccle
 
       index = hashes.index(photo_hash)
       if index && index > 0
-        "#{(selector + [hashes[index-1]]).join("/")}.html"
+        "#{hashes[index-1]}.html"
       else
         nil
       end
@@ -64,22 +64,31 @@ module Piccle
 
       index = hashes.index(photo_hash)
       if index && index < (hashes.length - 1)
-        "#{(selector + [hashes[index + 1]]).join("/")}.html"
+        "#{hashes[index + 1]}.html"
       else
         nil
       end
     end
 
+    # Gets the photos to show on the main index page. This is everything, except for photos within a collapsed event.
+    # We keep the first photo, but this is typically rendererd as a quilt tile rather than the photo itself.
+    def main_index_photos
+      all_photos = @parser.data[:photos]
+      collapsed_events = @parser.data[:events].select { |ev| ev[:collapsed] }
+      removable_hashes = collapsed_events.flat_map { |ev| @parser.subsection_photo_hashes(ev[:selector]).drop(1) }
+      all_photos.reject { |k, _v| removable_hashes.include?(k) }
+    end
+
     # Gets a (currently top-level only) navigation structure. All entries have at least one photo.
     def navigation
       navigation_entries = @parser.faceted_data.map do |k, v|
                              { friendly_name: v[:friendly_name],
-                               entries: entries_for(v, k)
+                               min_for_nav: v[:min_for_nav],
+                               entries: entries_for(v, k),
                              }
                            end
-      # A hack, to only show keywords that have more than one image.
       navigation_entries.each do |nav_entry|
-        nav_entry[:entries].keep_if { |entry| entry[:photo_count] > 1 } if "By Topic" == nav_entry[:friendly_name]
+        nav_entry[:entries].keep_if { |entry| entry[:photo_count] >= nav_entry[:min_for_nav] } if nav_entry[:min_for_nav]
       end
     end
 

data/lib/piccle/js_renderer.rb

@@ -9,11 +9,13 @@ module Piccle
     end
 
     def render_main_index
-      call_nodejs("index", render_main_index_template_vars)
+      template_vars = paginate(render_main_index_template_vars)
+      template_vars.map { |page_template_vars| call_nodejs("index", page_template_vars) }
     end
 
     def render_index(selector)
-      call_nodejs("index", render_index_template_vars(selector))
+      template_vars = paginate(render_index_template_vars(selector))
+      template_vars.map { |page_template_vars| call_nodejs("index", page_template_vars) }
     end
 
     def render_photo(hash, selector = [])

data/lib/piccle/models/person.rb

@@ -0,0 +1,6 @@
+require 'sequel'
+
+# Represents a real-life person. Uses the IPTC4 "PersonInImage" field in XMP data.
+class Piccle::Person < Sequel::Model
+  many_to_many :photos
+end

data/lib/piccle/models/photo.rb

@@ -8,6 +8,7 @@ require 'json'
 # Represents an image in the system. Reading info from an image? Inferring something based on the data? Put it here.
 class Piccle::Photo < Sequel::Model
   many_to_many :keywords
+  many_to_many :people
   attr_accessor :changed_hash # Has this file been modified?
   attr_accessor :freshly_created # Have we just generated this file?
 
@@ -29,7 +30,10 @@ class Piccle::Photo < Sequel::Model
     photo.freshly_created = freshly_created
 
     # Pull out keywords for this file, if it's new or changed.
-    photo.generate_keywords if freshly_created || photo.changed_hash?
+    if freshly_created || photo.changed_hash?
+      photo.sync_keywords
+      photo.sync_people
+    end
 
     photo
   end
@@ -183,16 +187,36 @@ class Piccle::Photo < Sequel::Model
   end
 
   # Read the keywords from the photo file, and ensure they're included in the DB.
-  # TODO: remove any keywords that aren't currently in the file.
-  def generate_keywords
+  def sync_keywords
     exif_info = EXIFR::JPEG.new(original_photo_path)
     xmp = XMP.parse(exif_info)
 
     if xmp && xmp.namespaces && xmp.namespaces.include?("dc") && xmp.dc.attributes.include?("subject")
-      xmp.dc.subject.each do |keyword|
+      # Add new keywords
+      downcased_keywords = xmp.dc.subject.map(&:downcase)
+      downcased_keywords.each do |keyword|
         keyword = Piccle::Keyword.find_or_create(name: keyword)
         add_keyword(keyword) unless keywords.include?(keyword)
       end
+
+      # Remove old keywords
+      keywords.each { |keyword| remove_keyword(keyword) unless downcased_keywords.include?(keyword.name.downcase) }
+    end
+  end
+
+  def sync_people
+    exif_info = EXIFR::JPEG.new(original_photo_path)
+    xmp = XMP.parse(exif_info)
+
+    if xmp && xmp.namespaces && xmp.namespaces.include?("Iptc4xmpExt") && xmp.Iptc4xmpExt.attributes.include?("PersonInImage")
+      people_names = xmp.Iptc4xmpExt.PersonInImage
+      people_names.each do |name|
+        person = Piccle::Person.find(Sequel.ilike(:name, name)) || Piccle::Person.create(name: name)
+        add_person(person) unless people.include?(person)
+      end
+
+      downcased_names = people_names.map(&:downcase)
+      people.each { |person| remove_person(person) unless downcased_names.include?(person.name.downcase) }
     end
   end
 

data/lib/piccle/parser.rb

@@ -120,7 +120,8 @@ module Piccle
 
     # Get photo hashes in a given subsection, given a diggable path.
     def subsection_photo_hashes(subsection_path)
-      @data.dig(*subsection_path).fetch(:photos, [])
+      subsection = @data.dig(*subsection_path)
+      subsection ? subsection.fetch(:photos, []) : []
     end
 
     # Gets the actual photo objects for a given subsection.
@@ -132,6 +133,11 @@ module Piccle
       end
     end
 
+    # Determines whether the given subsection is marked as "collapsed". This is currently specific to event streams.
+    def subsection_collapsed?(subsection_path)
+      @data.dig(*subsection_path).fetch(:collapsed, false)
+    end
+
     # Given an MD5 hash, returns an array of arrays. Each array is a set of strings that, combined with the MD5, gives a link to the photo.
     # So for instance, with a date stream parser, if a photo was taken on 2016-04-19 you'll get back:
     # [["by-date", "2016"], ["by-date", "2016", "4"], ["by-date", "2016", "4", "19"]]

data/lib/piccle/renderer.rb

@@ -12,12 +12,14 @@ module Piccle
     # For instance, if selector was ["by-date", "2015"] you'd get an index page of photos
     # for 2015 based on the data held by the parser.
     def render_index(selector)
-      Piccle::TemplateHelpers.render("index", render_index_template_vars(selector))
+      template_vars = paginate(render_index_template_vars(selector))
+      template_vars.map { |page_template_vars| Piccle::TemplateHelpers.render("index", page_template_vars) }
     end
 
     # Renders the "main" index – the front page of our site.
     def render_main_index
-      Piccle::TemplateHelpers.render("index", render_main_index_template_vars)
+      template_vars = paginate(render_main_index_template_vars)
+      template_vars.map { |page_template_vars| Piccle::TemplateHelpers.render("index", page_template_vars) }
     end
 
     # Renders an Atom feed of the given subsection.
@@ -41,22 +43,30 @@ module Piccle
       Piccle::TemplateHelpers.render("show", render_photo_template_vars(hash, selector))
     end
 
+    # What should we call this index page? The first page is "index" (ie. index.html), later ones have a number
+    # (eg. "index-02"). NB! Our indexes are 0 based, but our pages are 1 based. (0 → index, 1 → index-02, 2 → index-03).
+    def index_page_name_for(index)
+      index.zero? ? "index" : "index-#{sprintf("%02d", index + 1)}"
+    end
+
     protected
 
     # Returns all the data we pass into the main index to render.
     def render_main_index_template_vars
+      page_description = "A gallery of photos by #{Piccle.config.author_name}"
       template_vars = {
-        photos: @parser.data[:photos],
+        photos: @extractor.main_index_photos,
         event_starts: @parser.data[:event_starts],
         event_ends: @parser.data[:event_ends],
         nav_items: @extractor.navigation,
-        site_metadata: site_metadata
+        site_metadata: site_metadata,
+        page_description: page_description
       }
 
       if Piccle.config.open_graph?
         width, height = Piccle::QuiltGenerator.dimensions_for(@parser.data[:photos].length)
         template_vars[:open_graph] = open_graph_for(title: site_title(),
-                                                    description: "A gallery of photos by #{Piccle.config.author_name}",
+                                                    description: page_description,
                                                     image_url: "#{Piccle.config.home_url}quilt.jpg",
                                                     image_alt: "A quilt of the most recent images in this gallery.",
                                                     width: width,
@@ -70,6 +80,7 @@ module Piccle
     def render_index_template_vars(selector)
       breadcrumbs = @extractor.breadcrumbs_for(selector)
       selector_path = "#{selector.join('/')}/"
+      page_description = "A gallery of photos by #{Piccle.config.author_name}"
       template_vars = {
         photos: @parser.subsection_photos(selector),
         event_starts: [],
@@ -80,13 +91,14 @@ module Piccle
         breadcrumbs: breadcrumbs,
         site_url: Piccle.config.home_url,
         include_prefix: Piccle::TemplateHelpers.include_prefix(selector),
-        site_metadata: site_metadata
+        site_metadata: site_metadata,
+        page_description: page_description
       }
 
       if Piccle.config.open_graph?
         width, height = Piccle::QuiltGenerator.dimensions_for(@parser.subsection_photo_hashes(selector).length)
         template_vars[:open_graph] = open_graph_for(title: site_title(breadcrumbs),
-                                                    description: "A gallery of photos by #{Piccle.config.author_name}",
+                                                    description: page_description,
                                                     image_url: "#{Piccle.config.home_url}#{selector_path}quilt.jpg",
                                                     image_alt: "A quilt of the most recent images in this gallery.",
                                                     width: width,
@@ -97,10 +109,48 @@ module Piccle
       template_vars
     end
 
+    # Given a set of template variables, paginate them. Specifically:
+    # - Take the :photos key, and break it into chunks
+    # - Add a :pagination key with details of all the pages
+    # - Returns an array of template vars.
+    def paginate(template_vars)
+      slices = template_vars[:photos].each_slice(100)
+      if slices.count > 1
+        pages = (0...slices.count).map { |i| { label: i + 1, page_name: index_page_name_for(i) } }
+
+        slices.map.with_index do |slice, i|
+          pages_with_current = pages.map.with_index { |page, index| page.merge(is_current: (i == index)) }
+          is_first = i.zero?
+          is_last = i == slices.count - 1
+
+          new_vars = { photos: slice.to_h }
+          new_vars[:prev_link] = "#{index_page_name_for(i-1)}.html" unless is_first
+          new_vars[:next_link] = "#{index_page_name_for(i+1)}.html" unless is_last
+
+          pagination = { pagination: { page_name: index_page_name_for(i),
+                                      pages: pages_with_current,
+                                      is_first_page: is_first,
+                                      is_last_page: is_last,
+                                      previous_page_name: index_page_name_for(i-1),
+                                      next_page_name: index_page_name_for(i+1),
+                                      total_pages: slices.count }}
+
+          template_vars.merge(new_vars, pagination)
+        end
+      else # Just the one page, no point in adding any pagination.
+        [template_vars]
+      end
+    end
+
     # Returns all the template vars we use to render a photo page.
     def render_photo_template_vars(hash, selector)
       photo_data = @parser.data[:photos][hash]
       substreams = [@parser.substream_for(hash)] + @parser.links_for(hash).map { |selector| @parser.interesting_substream_for(hash, selector) }.compact
+      page_description = if photo_data[:description] && photo_data[:description].strip.length > 0
+                           photo_data[:description]
+                         else
+                           "A photo by #{Piccle.config.author_name}"
+                         end
 
       template_vars = {
         photo: photo_data,
@@ -119,8 +169,9 @@ module Piccle
         prev_link: @extractor.prev_link(hash, selector),
         next_link: @extractor.next_link(hash, selector),
         include_prefix: Piccle::TemplateHelpers.include_prefix(selector),
-        canonical: "photos/#{hash}.html", # TODO: Other paths live in piccle.rake. Why's this one here?
-        site_metadata: site_metadata
+        canonical: "#{hash}.html",
+        site_metadata: site_metadata,
+        page_description: page_description
       }
 
       photo_title = photo_data[:title] || ""
@@ -129,7 +180,7 @@ module Piccle
 
       if Piccle.config.open_graph?
         template_vars[:open_graph] = open_graph_for(title: photo_data[:title] || "A photo by #{Piccle.config.author_name}",
-                                                    description: photo_data[:description],
+                                                    description: page_description,
                                                     image_url: "#{Piccle.config.home_url}images/photos/#{hash}.#{photo_data[:file_name]}",
                                                     width: photo_data[:width],
                                                     height: photo_data[:height],

data/lib/piccle/streams/base_stream.rb

@@ -28,7 +28,7 @@ class Piccle::Streams::BaseStream
   # Each stream is expected to only meddle within its own namespace, but this is not enforced.
   def order(data)
     if data.key?(namespace)
-      data[namespace] = data[namespace].sort_by(&length_sort_proc(data)).reverse.to_h
+      data[namespace] = data[namespace].sort_by(&length_sort_proc(data)).to_h
       data[namespace].each do |k, v|
         data[namespace][k][:photos] = data[namespace][k][:photos].sort_by(&date_sort_proc(data)).reverse if k.is_a?(String)
       end
@@ -39,9 +39,13 @@ class Piccle::Streams::BaseStream
 
   protected
 
-  # A sort proc designed for hashes. Sorts all string keys in order of how many photos they contain.
+  # A sort proc designed for hashes. Sorts all string keys in order of how many photos they contain, then alphabetically.
   def length_sort_proc(data)
-    Proc.new { |k, v| k.is_a?(String) ? data.dig(namespace, k, :photos)&.length : 0 }
+    Proc.new do |k, v|
+      length = k.is_a?(String) ? data.dig(namespace, k, :photos)&.length || 0 : 0
+      name = k.is_a?(String) ? k.downcase : ""
+      [length * -1, name]
+    end
   end
 
   # A date sort designed for arrays. Sorts all photo hashes in order of the date they were taken.

data/lib/piccle/streams/date_stream.rb

@@ -61,7 +61,7 @@ class Piccle::Streams::DateStream < Piccle::Streams::BaseStream
   def order(data)
     sort_proc = Proc.new { |k, v| k.is_a?(String) ? k : "" }
 
-    data[namespace] = data[namespace].sort_by(&sort_proc).to_h # Sort years
+    data[namespace] = data[namespace].sort_by(&sort_proc).reverse.to_h # Sort years
 
     data[namespace].each do |year_k, v|
       # Sort photos in each year, and then the month keys

data/lib/piccle/streams/event_stream.rb

@@ -14,13 +14,8 @@ class Piccle::Streams::EventStream < Piccle::Streams::BaseStream
     @events = if File.exist?(Piccle.config.events_file)
                 YAML.load_file(Piccle.config.events_file).map do |event| # Convert keys to symbols; bring dates to life.
                   event = event.map { |k, v| [k.to_sym, v] }.to_h
-                  if event[:from].is_a? Date
-                    event[:from] = DateTime.new(event[:from].year, event[:from].month, event[:from].day, 0, 0, 0)
-                  end
-                  if event[:to].is_a? Date
-                    event[:to] = DateTime.new(event[:to].year, event[:to].month, event[:to].day, 23, 59, 59)
-                  end
-                  event
+                  event[:selector] = selector_for(event[:name])
+                  transform_dates(event)
                 end
               else
                 []
@@ -32,7 +27,8 @@ class Piccle::Streams::EventStream < Piccle::Streams::BaseStream
       relevant_events = @events.select { |ev| photo.taken_at.to_datetime >= ev[:from] && photo.taken_at.to_datetime <= ev[:to] }
       result = { namespace => { friendly_name: "By Event", interesting: true }}
       relevant_events.each do |ev|
-        result[namespace][slugify(ev[:name])] = { friendly_name: ev[:name], interesting: true, photos: [photo.md5] }
+        result[namespace][slugify(ev[:name])] = { friendly_name: ev[:name], interesting: true, photos: [photo.md5],
+                                                  collapsed: ev[:collapsed], sort_date: ev[:from] }
       end
 
       result
@@ -43,7 +39,14 @@ class Piccle::Streams::EventStream < Piccle::Streams::BaseStream
 
   # Sorts most recent events first; then organises photos by date. TODO
   def order(data)
-    super(data)
+    if data.key?(namespace)
+      data[namespace] = data[namespace].sort_by { |k, v| k.is_a?(String) ? v[:sort_date] : DateTime.new(1826, 1, 1) }.reverse.to_h
+      data[namespace].each do |k, v|
+        data[namespace][k][:photos] = data[namespace][k][:photos].sort_by(&date_sort_proc(data)).reverse if k.is_a?(String)
+      end
+    end
+
+    data
   end
 
   # Given an event name, get a selector hash for this event.
@@ -63,11 +66,31 @@ class Piccle::Streams::EventStream < Piccle::Streams::BaseStream
       if data.dig(namespace, slug, :photos)&.any?
         most_recent_hash = data[namespace][slug][:photos].first
         oldest_hash = data[namespace][slug][:photos].last # Event starts are the furthest back in time!
-        event_starts[oldest_hash] = { name: event[:name], selector: selector_for(event[:name]) }
-        event_ends[most_recent_hash] = { name: event[:name], selector: selector_for(event[:name]) }
+        event_starts[oldest_hash] = { name: event[:name], selector: selector_for(event[:name]), collapsed: event[:collapsed] }
+        event_ends[most_recent_hash] = { name: event[:name], selector: selector_for(event[:name]), collapsed: event[:collapsed] }
       end
     end
 
     [event_starts, event_ends]
   end
+
+  protected
+
+  # Given an event, munge the dates appropriately.
+  # - If we have an "at" date specified, make the from/to fields match the start and end of the day.
+  # - If we have "from"/"to" specified as dates, line them up with the start/end of the day.
+  def transform_dates(event)
+    if event[:at]
+      event[:from] = DateTime.new(event[:at].year, event[:at].month, event[:at].day, 0, 0, 0)
+      event[:to] = DateTime.new(event[:at].year, event[:at].month, event[:at].day, 23, 59, 59)
+    elsif event[:from] && event[:to]
+      if event[:from].is_a? Date
+        event[:from] = DateTime.new(event[:from].year, event[:from].month, event[:from].day, 0, 0, 0)
+      end
+      if event[:to].is_a? Date
+        event[:to] = DateTime.new(event[:to].year, event[:to].month, event[:to].day, 23, 59, 59)
+      end
+    end
+    event
+  end
 end