piccle 0.1.0.rc1

data/lib/piccle/quilt_generator.rb

@@ -0,0 +1,30 @@
+require 'rmagick'
+
+# Generates an image quilt, ideal for OpenGraph previews.
+module Piccle
+  class QuiltGenerator
+    # Generates a quilt of the given images - up to 9.
+    def self.generate_for(photo_paths)
+      photo_paths = photo_paths.first(9)
+      image_list = Magick::ImageList.new(*photo_paths)
+      image_list.montage do |conf|
+        conf.border_width = 0
+        conf.geometry = "200x200+0+0"
+      end
+    end
+
+    # Returns a tuple of [width, height] output dimensions. When we stitch a quilt together each square is 200px,
+    # but variable numbers of images can lead to quilts of different sizes. OpenGraph tags should include this
+    # size information.
+    def self.dimensions_for(image_count)
+      case image_count
+      when 1 then [200, 200]
+      when 2 then [400, 200]
+      when 3 then [600, 200]
+      when 4 then [400, 400]
+      when 5..6 then [600, 400]
+      else [600, 600]
+      end
+    end
+  end
+end

data/lib/piccle/renderer.rb

@@ -0,0 +1,175 @@
+module Piccle
+  # Renders a bunch of pages, based on the hash data loaded by the given parser.
+  class Renderer
+    def initialize(parser)
+      @parser = parser
+      @extractor = Piccle::Extractor.new(parser)
+    end
+
+    # Given an array that contains a path (not including a :photos key), get that photo
+    # data and render an index page using the :photos data found at that location.
+    #
+    # 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))
+    end
+
+    # Renders the "main" index – the front page of our site.
+    def render_main_index
+      Piccle::TemplateHelpers.render("index", render_main_index_template_vars)
+    end
+
+    # Renders an Atom feed of the given subsection.
+    def render_feed(selector = [])
+      photos = @parser.subsection_photos(selector).sort_by { |k, p| p[:created_at] }.reverse
+      escaped_selector = selector.map { |s| CGI::escape(s) }
+
+      template_vars = {
+        photos: photos,
+        joined_selector: "/#{escaped_selector.join("/")}/",
+        feed_update_time: photos.map { |k, v| v[:created_at] }.max,
+        selector: selector,
+        site_metadata: site_metadata
+      }
+
+      Piccle::TemplateHelpers.render_rss("feed", template_vars)
+    end
+
+    # Render a page for a specific photo.
+    def render_photo(hash, selector=[])
+      Piccle::TemplateHelpers.render("show", render_photo_template_vars(hash, selector))
+    end
+
+    protected
+
+    # Returns all the data we pass into the main index to render.
+    def render_main_index_template_vars
+      template_vars = {
+        photos: @parser.data[:photos],
+        event_starts: @parser.data[:event_starts],
+        event_ends: @parser.data[:event_ends],
+        nav_items: @extractor.navigation,
+        site_metadata: site_metadata
+      }
+
+      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}",
+                                                    image_url: "#{Piccle.config.home_url}quilt.jpg",
+                                                    image_alt: "A quilt of the most recent images in this gallery.",
+                                                    width: width,
+                                                    height: height,
+                                                    page_url: Piccle.config.home_url)
+      end
+      template_vars
+    end
+
+    # Returns all the data we pass into a template for rendering an index page, as a hash.
+    def render_index_template_vars(selector)
+      breadcrumbs = @extractor.breadcrumbs_for(selector)
+      selector_path = "#{selector.join('/')}/"
+      template_vars = {
+        photos: @parser.subsection_photos(selector),
+        event_starts: [],
+        event_ends: [],
+        nav_items: @extractor.navigation,
+        selector: selector,
+        selector_path: selector_path,
+        breadcrumbs: breadcrumbs,
+        site_url: Piccle.config.home_url,
+        include_prefix: Piccle::TemplateHelpers.include_prefix(selector),
+        site_metadata: site_metadata
+      }
+
+      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}",
+                                                    image_url: "#{Piccle.config.home_url}#{selector_path}quilt.jpg",
+                                                    image_alt: "A quilt of the most recent images in this gallery.",
+                                                    width: width,
+                                                    height: height,
+                                                    page_url: "#{Piccle.config.home_url}#{selector_path}")
+      end
+
+      template_vars
+    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
+
+      template_vars = {
+        photo: photo_data,
+        selector: selector,
+        selector_path: selector.any? ? "#{selector.join('/')}/" : "",
+        breadcrumbs: @extractor.breadcrumbs_for(selector),
+        substreams: substreams.select { |stream| stream[:photos].length > 1 },
+        camera_link: @extractor.camera_link(hash),
+        keywords: @extractor.keywords(hash),
+        day_link: @extractor.day_link(hash),
+        month_link: @extractor.month_link(hash),
+        year_link: @extractor.year_link(hash),
+        city_link: @extractor.city_link(hash),
+        state_link: @extractor.state_link(hash),
+        country_link: @extractor.country_link(hash),
+        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
+      }
+
+      photo_title = photo_data[:title] || ""
+      photo_title = "Photo" if photo_title.empty?
+      template_vars[:breadcrumbs] << { friendly_name: photo_title } if selector.any?
+
+      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],
+                                                    image_url: "#{Piccle.config.home_url}images/photos/#{hash}.#{photo_data[:file_name]}",
+                                                    width: photo_data[:width],
+                                                    height: photo_data[:height],
+                                                    page_url: "#{Piccle.config.home_url}/#{hash}.html")
+      end
+
+      template_vars
+    end
+
+    # Gets information about our site, used on pretty much every page.
+    def site_metadata
+      unless @cached_site_metadata
+        min_year = Piccle::Photo.earliest_photo_year
+        max_year = Piccle::Photo.latest_photo_year
+        copyright_year = if min_year == max_year
+                          max_year
+                        else
+                          "#{min_year} – #{max_year}"
+                        end
+
+        @cached_site_metadata = { author_name: Piccle.config.author_name, copyright_year: copyright_year }
+      end
+      @cached_site_metadata
+    end
+
+    # Returns a hash of open graph data based on the parameters passed in.
+    def open_graph_for(title: nil, description: nil, image_url: nil, image_alt: nil, width: nil, height: nil, page_url: nil)
+      open_graph = { title: title, url: page_url, image: { width: width, height: height, url: image_url } }
+      open_graph[:image][:image_alt] = image_alt if image_alt
+      open_graph[:description] = description if description
+      open_graph
+    end
+
+    # Returns a human-readable title for this site.
+    def site_title(breadcrumbs = [])
+      title = "Photography by #{Piccle.config.author_name}"
+      if breadcrumbs.any?
+        title += " - " + breadcrumbs.map { |b| b[:friendly_name] }.join(" - ")
+      end
+      title
+    end
+  end
+end

data/lib/piccle/streams.rb

@@ -0,0 +1,2 @@
+class Piccle::Streams
+end

data/lib/piccle/streams/base_stream.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# Streams are a self-contained way of faceting data for a photo.
+
+class Piccle::Streams::BaseStream
+  #
+  def namespace
+    "by-foo"
+  end
+
+  # Returns a hash that contains data to merge for the given photo.
+  def data_for(photo)
+    {}
+  end
+
+  # def metadata_for(photo)
+  #   [{}]
+  # end
+
+  # Reorder the data within this stream.
+  #
+  # The parser calls #order on every stream once it's loaded all the photos. You can reorder your data as you see fit.
+  # For instance, most general streams will want to order their subphotos by date - but if you're a keyword stream,
+  # you might also put the most popular keywords first.
+  #
+  # The default implementation organises facets with the most popular items first, and reorders the photos by date.
+  #
+  # 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].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
+
+  protected
+
+  # A sort proc designed for hashes. Sorts all string keys in order of how many photos they contain.
+  def length_sort_proc(data)
+    Proc.new { |k, v| k.is_a?(String) ? data.dig(namespace, k, :photos)&.length : 0 }
+  end
+
+  # A date sort designed for arrays. Sorts all photo hashes in order of the date they were taken.
+  def date_sort_proc(data)
+    Proc.new { |hash| data.dig(:photos, hash, :taken_at) || Time.new(1970, 1, 1) }
+  end
+
+  # Converts a sentence into something suitable for use in a URL slug.
+  def slugify(name)
+    name.downcase.gsub(/[^a-z0-9]+/, '-').gsub(/^-+/, '').gsub(/-+$/, '')
+  end
+end

data/lib/piccle/streams/camera_stream.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Browse photos by camera.
+class Piccle::Streams::CameraStream < Piccle::Streams::BaseStream
+  def namespace
+    "by-camera"
+  end
+
+  def data_for(photo)
+    {
+      namespace => {
+        :friendly_name => "By Camera",
+        :interesting => false,
+        slugify(camera_name(photo)) => {
+          friendly_name: camera_name(photo),
+          photos: [photo.md5]
+        },
+      }
+    }
+  end
+
+  def metadata_for(photo)
+    [{
+      friendly_name: camera_name(photo),
+      type: :camera,
+      selector: [namespace, slugify(camera_name(photo))]
+    }]
+  end
+
+  protected
+
+  def camera_name(photo)
+    photo.camera_name || "unknown"
+  end
+end

data/lib/piccle/streams/date_stream.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+# Enables browsing photos by date.
+
+class Piccle::Streams::DateStream < Piccle::Streams::BaseStream
+  def namespace
+    "by-date"
+  end
+
+  # Standard method called by the parser object. This should return a hash that contains sub-categories (optionally)
+  # and a list of :photos for each tier.
+  def data_for(photo)
+    year, month, day = photo.taken_at&.year, photo.taken_at&.month, photo.taken_at&.day
+    if year && month && day
+      { namespace => {
+        :friendly_name => "By Date",
+        :interesting => false,
+        year.to_s => {
+          :friendly_name => "#{year}",
+          :interesting => false,
+          month.to_s => {
+            :friendly_name => "#{Date::MONTHNAMES[month]}",
+            :interesting => false,
+            day.to_s => {
+              :friendly_name => "#{day}#{ordinal_for(day)}",
+              :interesting => false,
+              :photos => [photo.md5]
+            },
+            :photos => [photo.md5]
+          },
+          photos: [photo.md5]
+        }
+      }}
+    else
+      {}
+    end
+  end
+
+  def metadata_for(photo)
+    year, month, day = photo.taken_at&.year, photo.taken_at&.month, photo.taken_at&.day
+    if year && month && day
+      [{ friendly_name: "#{day}#{ordinal_for(day)}",
+        type: :date_day,
+        selector: [namespace, year, month, day]
+      }, {
+        friendly_name: "#{Date::MONTHNAMES[month]}",
+        type: :date_month,
+        selector: [namespace, year, month]
+      }, {
+        friendly_name: year.to_s,
+        type: :date_year,
+        selector: [namespace, year]
+      }]
+    else
+      []
+    end
+  end
+
+  # Standard method called by the parser object. Gives this stream an option to re-order its data. The stream is on
+  # its honour to only meddle within its own namespace.
+  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].each do |year_k, v|
+      # Sort photos in each year, and then the month keys
+      if year_k.is_a?(String)
+        if data[namespace][year_k].key?(:photos)
+          data[namespace][year_k][:photos] = data[namespace][year_k][:photos].sort_by(&date_sort_proc(data)).reverse
+        end
+        data[namespace][year_k] = data[namespace][year_k].sort_by(&sort_proc).to_h
+
+        data[namespace][year_k].each do |month_k, v|
+          # Sort photos in each month, and then the days. TODO.
+        end
+      end
+    end
+    data
+  end
+
+  protected
+
+  def ordinal_for(num)
+    if num % 10 == 1 && num != 11
+      "st"
+    elsif num % 10 == 2 && num != 12
+      "nd"
+    elsif num % 10 == 3 && num != 13
+      "rd"
+    else
+      "th"
+    end
+  end
+end

data/lib/piccle/streams/event_stream.rb

@@ -0,0 +1,73 @@
+require 'yaml'
+
+# A special-case stream that handles named "events". You can define details in events.yaml - with things like a name,
+# dates, and whether it should be collapsed or not on the front page.
+
+class Piccle::Streams::EventStream < Piccle::Streams::BaseStream
+  attr_accessor :events
+
+  def namespace
+    "by-event"
+  end
+
+  def initialize
+    @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
+                end
+              else
+                []
+              end
+  end
+
+  def data_for(photo)
+    if photo.taken_at
+      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] }
+      end
+
+      result
+    else
+      {}
+    end
+  end
+
+  # Sorts most recent events first; then organises photos by date. TODO
+  def order(data)
+    super(data)
+  end
+
+  # Given an event name, get a selector hash for this event.
+  def selector_for(name)
+    [namespace, slugify(name)]
+  end
+
+  # "Sentinels" are data hashes that mark the start and end of an event. We use them to render tiles in the overall
+  # index page, if we have photos for the declared event. Each event has an event_start and an event_end marker.
+  #
+  # Returns an array of 2 items: [event_starts, event_ends]
+  def sentinels_for(data)
+    event_starts = {}
+    event_ends = {}
+    @events.each do |event|
+      slug = slugify(event[:name])
+      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]) }
+      end
+    end
+
+    [event_starts, event_ends]
+  end
+end