halation 0.1.0 → 0.2.0

data/lib/halation/coerce.rb

@@ -0,0 +1,21 @@
+module Halation
+  # A collection of methods to coerce values into a desired type.
+  class Coerce
+
+    # @return [String, nil]
+    def self.string(value)
+      value &&= value.to_s
+    end
+
+    # @return [Integer, nil]
+    def self.integer(value)
+      value &&= value.to_i
+    end
+
+    # @return [Boolean]
+    def self.boolean(value)
+      !!value
+    end
+
+  end
+end

data/lib/halation/config.rb

@@ -0,0 +1,53 @@
+require 'yaml'
+require_relative 'coerce'
+require_relative 'config/camera'
+
+module Halation
+  # Application-wide configuraton.
+  class Config
+    # :nodoc:
+    DEFAULT_CONFIG_PATH = File.expand_path("~/.halation/config.yml").freeze
+
+    attr_reader :artist
+    attr_reader :copyright
+    attr_reader :cameras
+
+    def initialize
+      reset
+    end
+
+    # Reset the configuration to default values.
+    def reset
+      @artist = nil
+      @copyright = nil
+      @cameras = []
+    end
+
+    # Load the configuration from a YAML file.
+    def load_file(file_path = nil)
+      file_path ||= File.expand_path("./config.yml") if File.exists?("./config.yml")
+      file_path ||= DEFAULT_CONFIG_PATH
+
+      reset
+
+      YAML.load_file(file_path).tap do |config|
+        @artist = Coerce.string(config["artist"])
+        @copyright = Coerce.string(config["copyright"])
+
+        (config["cameras"] || []).each do |camera|
+          @cameras << Camera.new(camera)
+        end
+      end
+    end
+
+    # @return [String] list of configuration settings.
+    def to_s
+      [
+        "Artist: #{@artist}",
+        "Copyright: #{@copyright}",
+        @cameras.map(&:to_s)
+      ].join("\n")
+    end
+
+  end
+end

data/lib/halation/config/camera.rb

@@ -0,0 +1,42 @@
+require_relative '../coerce'
+require_relative 'lens'
+
+module Halation
+  class Config
+    # A camera profile.
+    class Camera
+      # A user-created ID.
+      attr_reader :tag
+      attr_reader :make
+      attr_reader :model
+      attr_reader :lenses
+
+      def initialize(yaml)
+        @tag = Coerce.string(yaml["tag"])
+        @make = Coerce.string(yaml["make"])
+        @model = Coerce.string(yaml["model"])
+        @lenses = []
+
+        yaml["lenses"].each do |lens|
+          @lenses << Lens.new(lens)
+        end
+      end
+
+      # @return [String]
+      def to_s
+        "Camera\n" <<
+        [
+          "Tag: #{tag}",
+          "Make: #{make}",
+          "Model: #{model}",
+          @lenses.map(&:to_s).join("\n")
+        ]
+          .join("\n")
+          .lines
+          .map { |line| "   #{line}" }
+          .join
+      end
+
+    end
+  end
+end

data/lib/halation/config/lens.rb

@@ -0,0 +1,32 @@
+require_relative '../coerce'
+
+module Halation
+  class Config
+    # A lens profile.
+    class Lens
+      # A user-created ID.
+      attr_reader :tag
+      attr_reader :model
+      attr_reader :focal_length
+
+      def initialize(yaml)
+        @tag = Coerce.string(yaml["tag"])
+        @model = Coerce.string(yaml["model"])
+        @focal_length = Coerce.integer(yaml["focal_length"])
+      end
+
+      # @return [String]
+      def to_s
+        "Lens\n" <<
+        [
+          "Tag: #{tag}",
+          "Model: #{model}",
+          "Focal Length: #{focal_length}",
+        ]
+          .map { |line| "   #{line}" }
+          .join("\n")
+      end
+
+    end
+  end
+end

data/lib/halation/engine.rb

@@ -0,0 +1,91 @@
+require_relative 'config'
+require_relative 'roll'
+require_relative 'tools/exif_tool/image'
+
+module Halation
+  # Performs modifications to the image Exif data.
+  class Engine
+    # Array of image extensions to search for.
+    attr_accessor :image_extensions
+    # Suppress output to stdout if true.
+    attr_accessor :silent
+
+    attr_reader :config
+    attr_reader :roll
+
+    # @see #run
+    def self.run(opts = {})
+      new(opts).run
+    end
+
+    # @option opts [String] :config_path (nil)
+    #   Override the config file that should be used.
+    # @option opts [String] :working_dir (".")
+    #   Override the working directory (contains images and roll.yml).
+    # @option opts [Array<String>] :image_extensions
+    #   Override the list of image extensions to search for.
+    # @option opts [Boolean] :silent
+    #   Suppress output to stdout.
+    def initialize(opts = {})
+      config_path = opts[:config_path]
+      @silent = !!opts[:silent]
+      @working_dir = File.expand_path(opts[:working_dir] || ".")
+      @image_extensions = opts[:image_extensions] || ["tif", "tiff", "jpg", "jpeg"]
+
+      @config = Config.new
+      @config.load_file(config_path)
+
+      @roll = Roll.new
+      @roll.load_file("#{@working_dir}/roll.yml")
+    end
+
+    # @return [Array<String>] detected image files to process, in ascending
+    #   alphabetical order.
+    def image_files
+      Dir[*@image_extensions.map { |ext| "#{@working_dir}/*.#{ext}" }]
+        .sort[0...@roll.frames.count]
+    end
+
+    # Process the batch of images.
+    def run
+      _image_files = image_files
+
+      specified_camera = @roll.camera
+      camera = @config.cameras.find { |camera| camera.tag == specified_camera }
+      raise "Camera #{specified_camera} not found in config.yml" unless camera
+
+      @roll.frames.each_with_index do |frame, i|
+        break if i >= _image_files.count
+
+        specified_lens = frame.lens || @roll.lens
+        lens = camera.lenses.find { |lens| lens.tag == specified_lens }
+        raise "Lens #{specified_lens} not found for frame #{frame.number}" unless lens
+
+        relative_path = _image_files[i].gsub(%r(^#{Dir.pwd}/), "")
+        puts "Processing frame #{frame.number}\n   #{relative_path}" unless @silent
+
+        ExifToolImage.new(_image_files[i]).tap do |exif|
+          exif["Artist"] = @roll.artist || @config.artist
+          exif["Copyright"] = @roll.copyright || @config.copyright
+          
+          date_created = Time.new(frame.date || @roll.date)
+          exif["DateTimeOriginal"] = date_created
+          exif["CreateDate"] = date_created
+
+          exif["Make"] = camera.make
+          exif["Model"] = camera.model
+          exif["LensModel"] = lens.model
+          exif["ISO"] = @roll.iso
+          exif["ExposureTime"] = frame.shutter || @roll.shutter
+          exif["FNumber"] = frame.aperture || @roll.aperture
+          exif["FocalLength"] = frame.focal_length || lens.focal_length || @roll.focal_length
+          exif["Flash"] = frame.flash ? 1 : 0
+          exif["Orientation"] = frame.orientation || 1
+
+          exif.save
+        end
+      end
+    end
+
+  end
+end

data/lib/halation/roll.rb

@@ -0,0 +1,57 @@
+require 'yaml'
+require_relative 'coerce'
+require_relative 'roll/frame'
+
+module Halation
+  # Settings for a roll of film.
+  class Roll
+    # Artist for the roll of film.
+    attr_reader :artist
+    # Copyright for the roll of film.
+    attr_reader :copyright
+    # Default date for all frames (optional).
+    attr_reader :date
+    # Tag of the cameara used.
+    attr_reader :camera
+    # Tag of the default lens used (optional).
+    attr_reader :lens
+    # ISO of the roll of film.
+    attr_reader :iso
+    # Array of frames on the roll of film.
+    attr_reader :frames
+
+    def initialize
+      reset
+    end
+
+    # Reset the configuration to default values.
+    def reset
+      @artist = nil
+      @copyright = nil
+      @date = nil
+      @camera = nil
+      @lens = nil
+      @iso = nil
+      @frames = []
+    end
+
+    # Load the settings from a YAML file.
+    def load_file(file_path)
+      reset
+
+      YAML.load_file(file_path).tap do |roll|
+        @artist = Coerce.string(roll["artist"])
+        @copyright = Coerce.string(roll["copyright"])
+        @date = Coerce.string(roll["date"])
+        @camera = Coerce.string(roll["camera"])
+        @lens = Coerce.string(roll["lens"])
+        @iso = Coerce.integer(roll["iso"])
+
+        (roll["frames"] || []).each do |frame|
+          @frames << Frame.new(frame)
+        end
+      end
+    end
+
+  end
+end

data/lib/halation/roll/frame.rb

@@ -0,0 +1,47 @@
+require_relative '../coerce'
+
+module Halation
+  class Roll
+    # A frame on the roll of film.
+    class Frame
+      # Frame number.
+      attr_reader :number
+      # Date the frame was taken.
+      attr_reader :date
+      # Tag of the lens used.
+      attr_reader :lens
+      # Focal length of the lens, if not specified by the lens profile
+      # (a zoom lens).
+      attr_reader :focal_length
+      # @todo spec
+      # Shutter speed.
+      # @example "1/125", "0.5" (half second), "15" (seconds), "120" (2 minutes)
+      attr_reader :shutter
+      # F-number of the aperture setting.
+      attr_reader :aperture
+      # True if flash was fired.
+      attr_reader :flash
+      # 1 = Horizontal (normal) 
+      # 2 = Mirror horizontal 
+      # 3 = Rotate 180 
+      # 4 = Mirror vertical 
+      # 5 = Mirror horizontal and rotate 270 CW 
+      # 6 = Rotate 90 CW 
+      # 7 = Mirror horizontal and rotate 90 CW 
+      # 8 = Rotate 270 CW
+      attr_reader :orientation
+
+      def initialize(yaml)
+        @number = Coerce.integer(yaml["number"])
+        @date = Coerce.string(yaml["date"])
+        @lens = Coerce.string(yaml["lens"])
+        @focal_length = Coerce.integer(yaml["focal_length"])
+        @shutter = Coerce.string(yaml["shutter"])
+        @aperture = Coerce.string(yaml["aperture"])
+        @flash = Coerce.boolean(yaml["flash"])
+        @orientation = Coerce.integer(yaml["orientation"])
+      end
+
+    end
+  end
+end

data/lib/halation/script.rb

@@ -0,0 +1,150 @@
+require 'optparse'
+require 'fileutils'
+
+require_relative 'engine'
+
+module Halation
+  # The script that runs when the halation binary is executed.
+  class Script
+    private_class_method :new
+
+    # @option opts [Boolean] :args (ARGV)
+    # @option opts [Boolean] :output_stream (STDOUT)
+    # @option opts [Boolean] :skip_exit (false)
+    #   Don't exit the program after calling a handler that would normally exit.
+    #   Used for unit testing.
+    def self.run(opts = {})
+      args = opts[:args] || ARGV
+      output_stream = opts[:output_stream] || STDOUT
+      skip_exit = !!opts[:skip_exit]
+      run_engine = true
+
+      options = {}
+
+      OptionParser.new { |opts|
+        opts.banner = "Usage: halation [options]"
+
+        opts.on("-c", "--config=PATH", String, "Config file path") do |config_path|
+          options[:config_path] = config_path
+        end
+
+        opts.on("--dry", "Dry run") do
+          options[:dry_run] = true
+          # TODO: Implement
+          raise NotImplementedError, "Dry run option is not yet implemented."
+        end
+
+        opts.on("-h", "--help", "Print this help") do
+          output_stream.puts opts
+          run_engine = false
+          exit unless skip_exit
+        end
+
+        opts.on("--new-config", "Generate a new config file") do |path|
+          # TODO: Implement
+          raise NotImplementedError, "Generate config option is not yet implemented."
+          run_engine = false
+          exit unless skip_exit
+        end
+
+        opts.on("--new-roll", "Generate a new roll.yml file") do
+          generate_new_roll
+          run_engine = false
+          exit unless skip_exit
+        end
+
+        opts.on("-p", "--print-config", "Print the configuration settings") do
+          # TODO: Implement
+          raise NotImplementedError, "Print config option is not yet implemented."
+          run_engine = false
+          exit unless skip_exit
+        end
+
+        opts.on("-r", "--recursive", "Traverse into subdirectories") do
+          # TODO: Implement
+          raise NotImplementedError, "Recursive option is not yet implemented."
+        end
+
+        opts.on("--silent", "Suppress messages to stdout.") do
+          options[:silent] = true
+        end
+
+        opts.on("-v", "--version", "Print the version information") do
+          output_stream.puts "halation #{Halation::VERSION}"
+          run_engine = false
+          exit unless skip_exit
+        end
+      }.parse!(args)
+      
+      Halation::Engine.run(options) if run_engine
+    end
+
+    # Generate a new roll.yml file.
+    # Copies "~/.halation/templates/roll.yml" if it exists, otherwise it uses
+    # a default template.
+    def self.generate_new_roll
+      roll_path = "roll.yml"
+
+      if File.exists?(roll_path)
+        output_stream.puts "A roll.yml file already exists in this directory."
+        return
+      end
+
+      # TODO: Make this configurable from config.yml
+      roll_template_path = File.expand_path("~/.halation/templates/roll.yml")
+
+      if File.exists?(roll_template_path)
+        FileUtils.cp(roll_template_path, ".")
+      else
+        File.open(roll_path, "w") do |f|
+          f.puts new_roll_content
+        end
+      end
+    end
+
+    private
+
+    # @return [String] roll.yml default content
+    def self.new_roll_content
+      output = <<YAML
+---
+date: "2016-01-01"
+camera: "rz67"
+lens: 110
+iso: 100
+frames:
+  - number: 1
+    shutter: "1/125"
+    aperture: 8
+  - number: 2
+    shutter: "1/125"
+    aperture: 8
+  - number: 3
+    shutter: "1/125"
+    aperture: 8
+  - number: 4
+    shutter: "1/125"
+    aperture: 8
+  - number: 5
+    shutter: "1/125"
+    aperture: 8
+  - number: 6
+    shutter: "1/125"
+    aperture: 8
+  - number: 7
+    shutter: "1/125"
+    aperture: 8
+  - number: 8
+    shutter: "1/125"
+    aperture: 8
+  - number: 9
+    shutter: "1/125"
+    aperture: 8
+  - number: 10
+    shutter: "1/125"
+    aperture: 8
+YAML
+    end
+
+  end
+end