flickrup 0.0.6 → 0.0.8

data/lib/flickrup/ext/machine_tags.rb

@@ -0,0 +1,23 @@
+class MachineTags
+  def initialize(config, context)
+    @config = config
+  end
+
+  def preupload(image, meta, config)
+
+    tags = config[:tags].split(" ")
+
+    remapped = tags.map do |x|
+      x.sub(/^([^:]+):([^:]+)::/,"\\1:\\2=")
+    end
+
+
+    unless tags == remapped #write back to file
+      meta['Keywords'] = remapped
+      meta['Subject'] = remapped #also write Subject XMP tag
+    end
+
+    config.merge({:tags => remapped.join(" ")})
+
+  end
+end

data/lib/flickrup/ext/prefixed_extension.rb

@@ -0,0 +1,19 @@
+class PrefixedExtension
+  def initialize(config)
+    @config = config
+  end
+
+  def values(prefix_key, config)
+    all_tags = config[:tags].split(" ")
+
+    prefix = @config[prefix_key]
+
+    (selected_tags, tags) = all_tags.partition do |x|
+      x.start_with?("#{prefix}")
+    end
+
+    selected_tags.map do |x|
+      x[(prefix.length)..x.length]
+    end
+  end
+end

data/lib/flickrup/ext/replacement_tags.rb

@@ -0,0 +1,23 @@
+class ReplacementTags
+  def initialize(config)
+    @config = config
+  end
+
+  def preupload(image, meta, config)
+
+    replacements = @config[:tag_replacements]
+
+    if replacements != nil
+      replacements.each do |tag_name, tag_value_replacements|
+        existing = meta[tag_name]
+
+        tag_value_replacements.each do |key, value|
+          if existing == key
+            meta[tag_name] = value
+            break
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flickrup/ext/tag_sets.rb

@@ -0,0 +1,19 @@
+require "flickrup/ext/prefixed_extension"
+
+class TagSets < PrefixedExtension
+  def initialize(config, delegate, context)
+    super(config)
+    @delegate = delegate
+    @flickr = context[:flickr_client]
+  end
+
+  def upload(image, meta, config)
+    sets = values(:tagsetprefix, config)
+
+    uploaded = @delegate.upload(image, meta, config)
+
+    sets.each do |set|
+      @flickr.add_to_set(uploaded, set)
+    end
+  end
+end

data/lib/flickrup/ext/visibility.rb

@@ -0,0 +1,42 @@
+require "flickrup/logging"
+
+class Visibility < PrefixedExtension
+  include Logging
+
+  def initialize(config, delegate, context)
+    super(config)
+    @delegate = delegate
+  end
+
+  def upload(image, meta, config)
+    visibility = values(:visibilityprefix, config)
+
+    config_override = if visibility.length == 0
+      logger.debug("No visibility specified for #{image}.")
+      {}
+    elsif visibility.length == 1
+      config_for_visibility(visibility[0])
+    else #multiple visibilities
+      logger.warn("Multiple visibilities specified. Using the first encountered: #{visibility[0]}.")
+      config_for_visibility(visibility[0])
+    end
+
+    @delegate.upload(image, meta, config.merge(config_override))
+  end
+
+  def config_for_visibility(visibility)
+    if visibility == "offline"
+      logger.debug("Offline Visibility specified. Disabling upload.")
+      {UploaderConstants::NO_UPLOAD => true}
+    elsif visibility == "private"
+      logger.debug("Private visibility specified.")
+      {"is_public" => "0", "is_friend" => "0", "is_family" => "0"}
+    elsif visibility == "friends"
+      logger.debug("Friends visibility specified.")
+      {"is_public" => "0", "is_friend" => "1", "is_family" => "1"}
+    else
+      logger.warn("Unknown visibility #{visibility}. Ignoring.")
+      {}
+    end
+  end
+end

data/lib/flickrup/flickr_client.rb

@@ -0,0 +1,79 @@
+require "flickraw"
+
+class FlickrClient
+
+  def initialize(api_key, shared_secret)
+    @set_name_to_id = {}
+    FlickRaw.api_key= api_key
+    FlickRaw.shared_secret=shared_secret
+
+    @token_file = File.join(ENV['HOME'], ".flickrup")
+    set_client(FlickRaw::Flickr.new)
+
+    if File.exist?(@token_file)
+      token = YAML.load_file(@token_file)
+      client.access_token = token["access"]
+      client.access_secret = token["secret"]
+    end
+
+    begin
+      login = client.test.login
+    rescue FlickRaw::OAuthClient::FailedResponse => e
+      get_token
+    end
+  end
+
+  def client
+    @client
+  end
+
+  def upload_photo(image, config)
+    client.upload_photo(image, config)
+  end
+
+  def add_to_set(photo_id, set_name)
+    set_id = get_set_id(set_name, photo_id)
+    client.photosets.addPhoto(:photoset_id => set_id, :photo_id => photo_id)
+  end
+
+  def get_set_id(set_name, for_photo_id)
+    unless @set_name_to_id.include? set_name
+      sets_response = client.photosets.getList #if we don't have it, refresh
+      @set_name_to_id = Hash[*sets_response.to_a.map{ |set|
+        [set['title'], set['id']]
+      }.flatten]
+      unless @set_name_to_id.include? set_name #if we still don't, create it
+        created = client.photosets.create(:title => set_name, :primary_photo_id => for_photo_id)
+        @set_name_to_id = @set_name_to_id.merge({set_name => created.id})
+      end
+    end
+
+    @set_name_to_id[set_name]
+  end
+
+  def get_token
+    token = client.get_request_token
+    auth_url = client.get_authorize_url(token['oauth_token'], :perms => 'write')
+
+    puts "Open this url in your process to complete the authentication process : #{auth_url}"
+    puts "Copy here the number given when you complete the process."
+    verify = gets.strip
+
+    begin
+      client.get_access_token(token['oauth_token'], token['oauth_token_secret'], verify)
+      token = {"access" => client.access_token, "secret" => client.access_secret}
+      login = client.test.login
+      puts "You are now authenticated as #{login.username}"
+      File.open(@token_file, 'w') { |f| f.write(token.to_yaml) }
+    rescue FlickRaw::OAuthClient::FailedResponse => e
+      puts "Authentication failed : #{e.msg}"
+    end
+
+  end
+
+  private
+  def set_client(client)
+    @client = client
+  end
+
+end

data/lib/flickrup/processor.rb

@@ -1,6 +1,10 @@
 require "flickrup/tagged_image"
 require "flickrup/uploader"
 require "flickrup/logging"
+require "flickrup/ext/tag_sets"
+require "flickrup/ext/replacement_tags"
+require "flickrup/ext/machine_tags"
+require "flickrup/ext/visibility"
 
 class Processor
   include Logging
@@ -10,10 +14,10 @@ class Processor
   end
 
   def paused
-    Dir["#{@config['watch_dir']}/paused"].length > 0
+    Dir["#{@config[:watch_dir]}/paused"].length > 0
   end
 
-  def run(files = Dir["#{@config['watch_dir']}/*.{jpg,JPG,jpeg,JPEG}"])
+  def run(files = Dir["#{@config[:watch_dir]}/*.{jpg,JPG,jpeg,JPEG}"])
 
     logger.debug("Processing #{files.length} files")
 
@@ -26,15 +30,15 @@ class Processor
 
     tagged = images.select { |x| !(x.tags.nil? || x.tags.empty?) }
 
-    uploader = Uploader.new(@config["api_key"], @config["shared_secret"])
+    uploader = get_uploader
 
     if @config[:dryrun]
       logger.info("Would now upload & move #{tagged.length} files, pausing for 5 secs instead")
       sleep 5
     else
       tagged.each { |x|
-        x.doUpload(uploader)
-        x.archive(@config["archive_dir"])
+        x.doUpload(get_preupload_handlers, uploader)
+        x.archive(@config[:archive_dir])
       }
     end
 
@@ -42,4 +46,25 @@ class Processor
 
     tagged.length
   end
+
+  private
+  def get_uploader
+    flickr_client = FlickrClient.new(@config[:api_key], @config[:shared_secret])
+
+    context = {:flickr_client => flickr_client}
+
+    uploader = Uploader.new(flickr_client)
+
+    upload_handlers.reduce(uploader) do |result, clazz|
+      clazz.new(@config, result, context)
+    end
+  end
+
+  def get_preupload_handlers
+    [MachineTags.new(@config, {}), ReplacementTags.new(@config)]
+  end
+
+  def upload_handlers() [TagSets, Visibility] end
+
 end
+

data/lib/flickrup/slow_listener.rb

@@ -33,7 +33,7 @@ class SlowListener
 
   def run
     logger.debug("Watching #{@config['watch_dir']}...")
-    Listen.to(@config['watch_dir']) do |modified, added, _|
+    Listen.to(@config[:watch_dir]) do |modified, added, _|
       unless modified.empty? && added.empty?
         on_change
       end
@@ -45,7 +45,7 @@ class SlowListener
 
     @processing.set PROCESSING
 
-    files = Dir["#{@config['watch_dir']}/*.{jpg,JPG,jpeg,JPEG}"]
+    files = Dir["#{@config[:watch_dir]}/*.{jpg,JPG,jpeg,JPEG}"]
 
     old, new = files.partition { |x| Time.now > File.mtime(x) + @wait }
 

data/lib/flickrup/tagged_image.rb

@@ -17,8 +17,23 @@ class TaggedImage
     @parsed.keywords.to_a
   end
 
-  def doUpload(uploader)
-    uploader.upload(file, tags)
+  def doUpload(preupload_handlers, uploader)
+
+    config = preupload_handlers.reduce({:tags => tags.join(" ")}) do |config, handler|
+      handler.preupload(file, self, config)
+    end
+
+    #maybe save afterwards
+    if @parsed.changed?
+      @parsed.save!
+    end
+
+    uploader.upload(file, self, config)
+
+    #maybe save afterwards
+    if @parsed.changed?
+      @parsed.save!
+    end
   end
 
   def archive(to_dir)
@@ -32,6 +47,17 @@ class TaggedImage
 
     File.makedirs(target_dir)
     FileUtils.mv(@file, File.join(target_dir, File.basename(@file)))
+    logger.info("Archived #{File.basename(@file)} to #{target_dir}")
+  end
+
+  # Returns the value of a tag.
+  def [] tag
+    @parsed[tag]
+  end
+
+  # Set the value of a tag.
+  def []=(tag, val)
+    @parsed[tag] = val
   end
 
 end

data/lib/flickrup/uploader.rb

@@ -1,56 +1,35 @@
 require "yaml"
 require 'rubygems'
-require "flickraw"
 require "flickrup/logging"
+require "flickrup/flickr_client"
+
+module UploaderConstants
+  NO_UPLOAD = :no_upload
+end
 
 class Uploader
   include Logging
 
-  def initialize(api_key, shared_secret)
-    FlickRaw.api_key= api_key
-    FlickRaw.shared_secret=shared_secret
+  def initialize(flickr_client)
+    @flickr = flickr_client
+  end
 
-    @token_file = File.join(ENV['HOME'], ".flickrup")
-    @flickr = FlickRaw::Flickr.new
+  def upload(image, meta, config)
 
-    if File.exist?(@token_file)
-      token = YAML.load_file(@token_file)
-      @flickr.access_token = token["access"]
-      @flickr.access_secret = token["secret"]
-    end
+    if config[UploaderConstants::NO_UPLOAD]
+      logger.info("Skipping upload of #{image} as marked as NO_UPLOAD")
+    else
+      logger.debug("Uploading #{image} with tags #{config[:tags]}")
 
-    begin
-      login = @flickr.test.login
-    rescue FlickRaw::OAuthClient::FailedResponse => e
-      get_token
+      begin
+        rv = @flickr.upload_photo(image, config)
+        logger.debug("Uploaded #{image}")
+      rescue StandardError => err
+        logger.error("Failed to upload #{image}: #{err}")
+      end
     end
 
-  end
-
-  def get_token
-    token = @flickr.get_request_token
-    auth_url = @flickr.get_authorize_url(token['oauth_token'], :perms => 'write')
-
-    puts "Open this url in your process to complete the authentication process : #{auth_url}"
-    puts "Copy here the number given when you complete the process."
-    verify = gets.strip
-
-    begin
-      @flickr.get_access_token(token['oauth_token'], token['oauth_token_secret'], verify)
-      token = {"access" => @flickr.access_token, "secret" => @flickr.access_secret}
-      login = @flickr.test.login
-      puts "You are now authenticated as #{login.username}"
-      File.open(@token_file, 'w') { |f| f.write(token.to_yaml) }
-    rescue FlickRaw::OAuthClient::FailedResponse => e
-      puts "Authentication failed : #{e.msg}"
-    end
-
-  end
-
-  def upload(image, tags)
-    logger.debug("Uploading #{image} with tags #{tags.join(",")}")
-    @flickr.upload_photo(image, :tags => tags.join(" "))
-    logger.debug("Uploaded #{image}")
+    rv
   end
 
 end

data/lib/flickrup.rb

@@ -31,7 +31,8 @@ module Flickrup
 
       logger.level = Logger::Severity.const_get(opts.loglevel)
 
-      config = YAML::load(File.open(opts.config, "r")).merge opts
+      #load config, symbolise, merge with command line config
+      config = YAML::load(File.open(opts.config, "r")).inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}.merge opts
 
       if opts.once
         Processor.new(config).run

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: flickrup
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 15
   prerelease: 
   segments: 
   - 0
   - 0
-  - 6
-  version: 0.0.6
+  - 8
+  version: 0.0.8
 platform: ruby
 authors: 
 - Jonathan Gilbert
@@ -138,6 +138,12 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/flickrup/ext/machine_tags.rb
+- lib/flickrup/ext/prefixed_extension.rb
+- lib/flickrup/ext/replacement_tags.rb
+- lib/flickrup/ext/tag_sets.rb
+- lib/flickrup/ext/visibility.rb
+- lib/flickrup/flickr_client.rb
 - lib/flickrup/logging.rb
 - lib/flickrup/processor.rb
 - lib/flickrup/quick_listener.rb