piccle 0.1.0.rc1

data/lib/piccle/js_renderer.rb

@@ -0,0 +1,37 @@
+# Render using a NodeJS helper program. The Handlebars.rb bindings are tied to an old version of libv8; they render
+# REALLY slowly as a result.
+# This renderer calls out to a NodeJS helper program instead - so all the templating is handled in JavaScript.
+module Piccle
+  class JsRenderer < Renderer
+    def initialize(*args)
+      @renderer = IO.popen(["node", "js-renderer/renderer.js", Piccle.config.output_dir], "r+")
+      super(*args)
+    end
+
+    def render_main_index
+      call_nodejs("index", render_main_index_template_vars)
+    end
+
+    def render_index(selector)
+      call_nodejs("index", render_index_template_vars(selector))
+    end
+
+    def render_photo(hash, selector = [])
+      call_nodejs("show", render_photo_template_vars(hash, selector))
+    end
+
+    protected
+
+    def call_nodejs(template, template_vars)
+      @renderer.write("render_#{template}\n")
+      @renderer.write("#{JSON.dump(template_vars)}\n")
+      buffer = ""
+      loop do
+        line = @renderer.readline
+        break if line.strip == "\x1C"
+        buffer += line
+      end
+      buffer
+    end
+  end
+end

data/lib/piccle/models/keyword.rb

@@ -0,0 +1,6 @@
+require 'sequel'
+
+# Represents a keyword/label/tag in the system. This is pulled out of the image XMP data.
+class Piccle::Keyword < Sequel::Model
+  many_to_many :photos
+end

data/lib/piccle/models/location.rb

@@ -0,0 +1,11 @@
+require 'sequel'
+
+# Represents a location in the system - either just a lat/long point (to be geocoded later) or a lat/long named
+# with "city", "state", "country". Countries are normally countries, but overall it's more like "small area", "wider
+# geographic area", "big geographic area".
+class Piccle::Location < Sequel::Model
+  def before_create
+    self.created_at ||= Time.now
+    super
+  end
+end

data/lib/piccle/models/photo.rb

@@ -0,0 +1,211 @@
+require 'exifr/jpeg'
+require 'xmp'
+require 'digest'
+require 'sequel'
+require 'rmagick'
+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
+  attr_accessor :changed_hash # Has this file been modified?
+  attr_accessor :freshly_created # Have we just generated this file?
+
+  def before_create
+    self.created_at ||= Time.now
+    super
+  end
+
+  def self.from_file(path_to_file)
+    freshly_created = false
+    md5 = Digest::MD5.file(path_to_file).to_s
+
+    photo = self.find_or_create(file_name: File.basename(path_to_file), path: File.dirname(path_to_file)) do |p|
+      # Block executes when creating a new record.
+      freshly_created = true
+      p.set(data_hash(path_to_file))
+    end
+    photo.changed_hash = md5 != photo.md5
+    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?
+
+    photo
+  end
+
+  # Gets a dataset of properties to save about this file. We reuse this between from_file (above) and update_from_file
+  # (below).
+  def self.data_hash(path_to_file)
+    exif_info = EXIFR::JPEG.new(path_to_file)
+    xmp = XMP.parse(exif_info)
+    p = {}
+
+    p[:md5] = Digest::MD5.file(path_to_file).to_s
+    p[:width] = exif_info.width
+    p[:height] = exif_info.height
+    p[:camera_name] = exif_info.model || "Unknown camera"
+    p[:description] = exif_info.image_description
+    p[:aperture] = exif_info.aperture_value
+    p[:iso] = exif_info.iso_speed_ratings
+    p[:iso] = p[:iso].first if p[:iso].is_a? Array
+    p[:shutter_speed_numerator] = exif_info.exposure_time&.numerator
+    p[:shutter_speed_denominator] = exif_info.exposure_time&.denominator
+    p[:focal_length] = exif_info.focal_length.to_f
+    p[:taken_at] = exif_info.date_time_original&.to_datetime
+
+    p[:latitude] = if exif_info.gps_latitude && exif_info.gps_latitude_ref
+                      exif_info.gps_latitude_ref == "S" ? (exif_info.gps_latitude.to_f * -1) : exif_info.gps_latitude.to_f
+                    end
+
+    p[:longitude] = if exif_info.gps_longitude && exif_info.gps_longitude_ref
+                      exif_info.gps_longitude_ref == "W" ? (exif_info.gps_longitude.to_f * -1) : exif_info.gps_longitude.to_f
+                    end
+
+    p[:title] = if xmp && xmp.namespaces && xmp.namespaces.include?("dc") && xmp.dc.attributes.include?("title")
+                  xmp.dc.title
+                end
+    %w[City State Country].each do |location|
+      p[location.downcase.to_sym] = if xmp && xmp.namespaces && xmp.namespaces.include?("photoshop") &&
+                                        xmp.photoshop.attributes.include?(location)
+                                      xmp.photoshop.send(location)
+                                    end
+    end
+
+    # Tweak encoding of potential non-UTF-8 strings
+    %i[description title city state country].each do |attr|
+      p[attr].force_encoding("UTF-8") if p[attr].respond_to?(:force_encoding)
+    end
+
+    p
+  end
+
+  # The year our earliest photo was taken. Used by our copyright footer.
+  def self.earliest_photo_year
+    Date.parse(self.min(:taken_at)).year
+  end
+
+  # The year the last photo was taken. Used by the copyright footer.
+  def self.latest_photo_year
+    Date.parse(self.max(:taken_at)).year
+  end
+
+  # ---- Image attributes (inferred from data) ----
+
+  def portrait?
+    height > width
+  end
+
+  # Is this image landscape?
+  def landscape?
+    width > height
+  end
+
+  # Is this image square?
+  def square?
+    width == height
+  end
+
+  # Have we already generated a thumbnail for this image?
+  def thumbnail_exists?
+    File.exist?(thumbnail_path)
+  end
+
+  # Gets the full path to the thumbnail for this photo.
+  def thumbnail_path
+    File.join(Piccle.config.output_dir, template_thumbnail_path)
+  end
+
+  # Gets the path to use in our generated HTML.
+  def template_thumbnail_path
+    File.join("images", "thumbnails", "#{md5}.#{file_name}")
+  end
+
+  # Does a "full-size" image exist?
+  def full_image_exists?
+    File.exist?(full_image_path)
+  end
+
+  # Gets the full path to the "full" image for this photo.
+  def full_image_path
+    File.join(Piccle.config.output_dir, template_full_image_path)
+  end
+
+  # Gets the path to use in our generated HTML."
+  def template_full_image_path
+    File.join("images", "photos", "#{md5}.#{file_name}")
+  end
+
+  # Gets the path to the photo page.
+  def photo_show_path
+    "#{md5}.html"
+  end
+
+  def original_photo_path
+    File.join(path, file_name)
+  end
+
+  # Munge the shutter speed data into a human-readable string.
+  def friendly_shutter_speed
+    if shutter_speed_numerator && shutter_speed_denominator
+      if shutter_speed_denominator > 1
+        "#{shutter_speed_numerator}/#{shutter_speed_denominator}s"
+      else
+        "#{shutter_speed_numerator}s"
+      end
+    end
+  end
+
+  def friendly_focal_length
+    "#{focal_length.round(1)} mm" if focal_length.positive?
+  end
+
+  # Does this image have both a lat-long pair, AND at least one of (city, state, country)?
+  def geocoded?
+    (latitude && longitude) && (city || state || country)
+  end
+
+  # ---- Piccle internals ----
+
+  # Has this file changed hash? You probably want to call update if so.
+  def changed_hash?
+    changed_hash
+  end
+
+  # Have we just created this file?
+  def freshly_created?
+    freshly_created
+  end
+
+  # Re-read the photo data, and save it to the DB.
+  def update_from_file
+    update(Piccle::Photo.data_hash(original_photo_path))
+  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
+    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|
+        keyword = Piccle::Keyword.find_or_create(name: keyword)
+        add_keyword(keyword) unless keywords.include?(keyword)
+      end
+    end
+  end
+
+  # Generate a thumbnail for this image.
+  def generate_thumbnail!
+    img = Magick::Image.read(original_photo_path).first
+    img.resize_to_fill!(Piccle::THUMBNAIL_SIZE)
+    img.write(thumbnail_path)
+  end
+
+  def generate_full_image!
+    img = Magick::Image.read(original_photo_path).first
+    img.resize_to_fit!(Piccle::FULL_SIZE, Piccle::FULL_SIZE)
+    img.write(full_image_path)
+  end
+end

data/lib/piccle/parser.rb

@@ -0,0 +1,230 @@
+# The "base parser" for Piccle. Repeatedly call parser.parse(Photo), and it pulls out the metadata necessary to generate pages.
+# It'll figure out which details to pull out, links between individual photos, details like ordering, etc.
+#
+# Essentially, we end up building a big @data array that's got all the photo metadata, and the streams populate the various
+# facets of the data. And then another module can render our site from this big specially-structured hash.
+#
+# Our hash looks like this:
+# {
+#   title: "Foo", # The title of this section
+#   photos: { md5_string => Hash[photo_data] }, # Data needed to display
+#   events: [ Hash[event_data] ] # Details about named events. These get special tiles on
+#                                # the front page, but are implemented via a stream.
+#
+
+module Piccle
+  class Parser
+    attr_accessor :data
+    attr_accessor :streams
+
+    def initialize
+      @data = { friendly_name: "All Photos" } # The extracted metadata that we'll use to generate our photo gallery.
+      @photos = {} # An array of MD5 -> Photo object, in case we want to get back to them easily at some point.
+      @streams = [] # Any extra processors that we want to use.
+    end
+
+    # Register a "stream", a thing that can extract extra data from a photo and add it to our data array, for later generation.
+    def add_stream(stream)
+      @streams << stream.new
+    end
+
+    # Do we have any photos in this parsed data yet?
+    def empty?
+      @photos.empty?
+    end
+
+    # Parse a photo. Also passes it to any registered streams, which can subcategorise each photo into sections under its own namespace.
+    # Streams can also return a metadata element, that we can display specially in the photo page.
+    def parse(photo)
+      @photos[photo.md5] = photo
+      @data[:photos] ||= {}
+
+      @data[:photos][photo.md5] = { hash: photo.md5,
+                                    file_name: photo.file_name,
+                                    title: photo.title,
+                                    photo_show_path: photo.photo_show_path,
+                                    description: photo.description,
+                                    width: photo.width,
+                                    height: photo.height,
+                                    taken_at: photo.taken_at,
+                                    created_at: photo.created_at,
+                                    aperture: photo.aperture,
+                                    shutter_speed: photo.friendly_shutter_speed,
+                                    focal_length: photo.friendly_focal_length,
+                                    iso: photo.iso,
+                                    city: photo.city,
+                                    state: photo.state,
+                                    country: photo.country,
+                                    has_location: photo.geocoded?,
+                                    metadata: []
+      }
+
+      @streams.each do |stream|
+        @data = merge_into(@data, stream.data_for(photo)) if stream.respond_to?(:data_for)
+        @data[:photos][photo.md5][:metadata] += stream.metadata_for(photo) if stream.respond_to?(:metadata_for)
+      end
+    end
+
+    # You can iterate over this list to display things.
+    def order
+      @data[:photos] = @data[:photos].sort_by { |k, v| v[:taken_at] || Time.new(1970, 1, 1) }.reverse.to_h
+
+      @streams.each do |stream|
+        @data = stream.order(@data) if stream.respond_to?(:order)
+      end
+    end
+
+    # Loads the event data from the EventStream. It also finds "sentinels", which are photos where we should display a special
+    # tile beforehand to indicate the start/end of the event.
+    def load_events
+      event_stream = Piccle::Streams::EventStream.new
+      order
+      @data[:events] = event_stream.events
+      @data[:event_starts], @data[:event_ends] = event_stream.sentinels_for(@data)
+    end
+
+    # Gets the metadata for a given photo hash.
+    def metadata_for(photo_hash)
+      @data.dig(:photos, photo_hash, :metadata)
+    end
+
+    # Get the friendly name for the given selector.
+    def friendly_name_for(selector)
+      @data.dig(*selector, :friendly_name)
+    end
+
+    # Gets a list of all subsections (ie. all the subindexes that we should render).
+    # It's an array of hash keys, suitable for passing via @data.dig(*keys).
+    # TODO: This could probably be sped up.
+    def subsections
+      previous_size = 0
+      subsection_list = faceted_data.keys.map { |el| [el] }
+      size = subsection_list.count
+
+      # Find all the string keys in our data.
+      loop do
+        subsection_list.each do |key_path|
+          new_keys = string_keys_only(@data.dig(*key_path)).keys
+          new_keys.each { |k| subsection_list << key_path + [k] }
+        end
+
+        # Clean up our state - remove dupes, update counts.
+        subsection_list.uniq!
+        previous_size = size
+        size = subsection_list.count
+        break if previous_size == size
+      end
+
+      subsection_list
+    end
+
+    # Get photo hashes in a given subsection, given a diggable path.
+    def subsection_photo_hashes(subsection_path)
+      @data.dig(*subsection_path).fetch(:photos, [])
+    end
+
+    # Gets the actual photo objects for a given subsection.
+    def subsection_photos(subsection_path)
+      if subsection_path.any?
+        subsection_photo_hashes(subsection_path).map { |hash| [hash, @data[:photos][hash]] }.to_h
+      else
+        @data[:photos]
+      end
+    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"]]
+    # And you could use that to generate a links akin to /by-date/2016/4/19/abcdef1234567890.html.
+    def links_for(md5)
+      # Return each key that includes the photos.
+      subsections.select { |path| @data.dig(*path).fetch(:photos, []).include?(md5) }
+    end
+
+    # Given a photo hash, and a substream selector (which may be omitted, for the main list of photos),
+    # returns an array with *up to* 5 previous/next photos, as well as this image. It's ideal for rendering small
+    # strips of neighbouring images.
+    def substream_hashes_for(hash, selector = [])
+      relevant_hashes = (@data.dig(*selector, :photos) || {})
+      relevant_hashes = relevant_hashes.keys if relevant_hashes.respond_to?(:keys)
+      if photo_index = relevant_hashes.find_index(hash)
+        before_index = [0, photo_index-5].max
+        after_index = [photo_index + 5, relevant_hashes.length - 1].min
+        relevant_hashes[before_index..after_index]
+      else
+        []
+      end
+    end
+
+    # Same as the above, but only returns hashes for "interesting" substreams.
+    def interesting_substream_hashes_for(hash, selector = [])
+      if @data.dig(*selector, :interesting)
+        substream_hashes_for(hash, selector)
+      else
+        []
+      end
+    end
+
+    # Returns a substream hash. This is a bundle of data suitable for rendering a navigation strip within this stream.
+    # It includes a title for the substream, previous/next photos where applicable (ie. for nav arrows), and a set of
+    # photos including the current photo.
+    def substream_for(hash, selector = [])
+      photo_hashes = substream_hashes_for(hash, selector)
+      if photo_hashes.any?
+        substream = {}
+        photo_i = photo_hashes.find_index(hash)
+        substream[:title] = friendly_name_for(selector)
+        substream[:photos] = photo_hashes.map { |h| @data[:photos][h] }
+        substream[:selector_path] = "#{selector.join('/')}/" if selector.any?
+        substream[:previous] = @data[:photos][photo_hashes[photo_i - 1]] if photo_i > 0
+        substream[:next] = @data[:photos][photo_hashes[photo_i + 1]] if photo_i < photo_hashes.length - 1
+        substream
+      else
+        nil
+      end
+    end
+
+    # Same as the above, but only if this stream is flagged as interesting.
+    def interesting_substream_for(hash, selector = [])
+      substream_for(hash, selector) if @data.dig(*selector, :interesting)
+    end
+
+    # Accessor for the photo hashes.
+    def photo_hashes
+      @photos.keys
+    end
+
+
+    # Gets the data that we faceted - the things broken down by stream.
+    def faceted_data
+      @faceted_data ||= string_keys_only(@data)
+    end
+
+    protected
+
+    def string_keys_only(data)
+      data.select { |k, _| k.is_a? String }
+    end
+
+    def merge_into(destination, source)
+      # If the source has a photos key, make sure one exists in the destination, and then append the source's contents.
+      if source.key?(:photos)
+        destination[:photos] ||= []
+        destination[:photos] += source[:photos]
+      end
+
+      # For all the other keys, see if the destination has them. If it does, combine them using OURSELF. Otherwise, just set it to our version.
+      source.keys.each do |key|
+        next if :photos == key
+        if destination.key?(key) && destination[key].is_a?(Hash)
+          destination[key] = merge_into(destination[key], source[key])
+
+        else
+          destination[key] = source[key]
+        end
+      end
+
+      destination
+    end
+  end
+end