flickrage 0.1.1

data/lib/flickrage/pipeline.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+require 'concurrent-edge'
+
+module Flickrage
+  class Pipeline
+    include Flickrage::Helpers::Log
+
+    attr_reader :opts
+
+    def initialize(opts = {})
+      @opts = opts
+    end
+
+    #
+    # Main pipeline
+    #
+
+    def run
+      logger.warn('Thank you for choosing Flickrage, you will find me as your Flickr collage companion :)')
+
+      list = Concurrent
+        .future { search_worker.call }
+        .then { |image_list| download_worker.call(image_list) }
+        .then { |image_list| resize_worker.call(image_list) }
+        .then { |image_list| compose_worker.call(image_list) }
+        .then do |image_list|
+          logger.info("#{image_list&.size || 0} images composed")
+          image_list
+        end
+        .rescue { |e| logger.error(e) }
+        .wait.value
+
+      speaker.add_padding
+
+      raise CollageError, 'Try again later...' unless valid_list?(list)
+
+      logger.warn("Congrats! You can find composed collage at #{list.collage_path}")
+
+      list
+    end
+
+    private
+
+    def search_worker
+      @search_worker ||= opts[:search_worker] || Worker::Search.new(opts)
+    end
+
+    def download_worker
+      @download_worker ||= opts[:download_worker] || Worker::Download.new(opts)
+    end
+
+    def resize_worker
+      @resize_worker ||= opts[:resize_worker] || Worker::Resize.new(opts)
+    end
+
+    def compose_worker
+      @compose_worker ||= opts[:compose_worker] || Worker::Compose.new(opts)
+    end
+
+    def valid_list?(list)
+      list.respond_to?(:valid?) && list.valid?
+    end
+  end
+end

data/lib/flickrage/service.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+module Flickrage
+  module Service
+    autoload :Composer,   'flickrage/service/composer'
+    autoload :Downloader, 'flickrage/service/downloader'
+    autoload :Resizer,    'flickrage/service/resizer'
+    autoload :Search,     'flickrage/service/search'
+  end
+end

data/lib/flickrage/service/composer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+module Flickrage
+  module Service
+    class Composer
+      include Flickrage::Helpers::Log
+
+      attr_reader :file_name, :width, :height, :shuffle
+
+      def initialize(file_name, width, height, shuffle: true)
+        @file_name = file_name
+        @width     = width
+        @height    = height
+        @shuffle   = shuffle
+      end
+
+      def run(image_list)
+        compose(image_list)
+        check_image(image_list)
+      rescue StandardError => e
+        logger.debug(e)
+        image_list
+      end
+
+      private
+
+      def compose(image_list)
+        montage = MiniMagick::Tool::Montage.new
+        images(image_list.resized).each { |image| montage << image.resize_path }
+
+        montage_width  = width * (image_list.resized.size / Flickrage.config.grid).to_i
+        montage_height = height * Flickrage.config.grid
+
+        montage.geometry   "#{montage_width}x#{montage_height}+0+0"
+        montage.tile       "x#{Flickrage.config.grid}"
+        montage.mode       'Concatenate'
+        montage.background 'none'
+
+        montage << image_list.collage_path
+        montage.call
+      end
+
+      def images(images)
+        shuffle ? images.shuffle : images
+      end
+
+      def check_image(image_list)
+        File.exist?(image_list.collage_path) ? image_list.finish_compose : image_list
+      end
+    end
+  end
+end

data/lib/flickrage/service/downloader.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+require 'uri'
+require 'net/http'
+
+module Flickrage
+  module Service
+    class Downloader
+      include Flickrage::Helpers::Log
+
+      def run(image)
+        uri = gen_uri(image.url)
+        image.file_name = file_name(uri)
+        download_file(uri, image.local_path)
+        check_image(image)
+      rescue StandardError => e
+        logger.debug(e)
+        image
+      end
+
+      private
+
+      def download_file(uri, path, limit = 10)
+        raise Flickrage::DownloadError, 'Redirect limit arrived' if limit.zero?
+
+        Net::HTTP.start(uri.host, uri.port,
+                        use_ssl: uri.scheme == 'https') do |conn|
+          request = Net::HTTP::Get.new(uri)
+          response = conn.request request
+
+          case response
+          when Net::HTTPSuccess
+            write_file(path, response.body)
+          when Net::HTTPRedirection
+            download_file(gen_uri(response['location']),
+                          path,
+                          limit - 1)
+          else
+            response.error!
+          end
+        end
+      end
+
+      def write_file(path, body, mode = 'wb')
+        File.open(path, mode) do |file|
+          file.flock(File::LOCK_EX)
+          file << body
+        end
+      end
+
+      def gen_uri(url)
+        URI.parse(url)
+      end
+
+      def file_name(uri)
+        File.basename(uri.path)
+      end
+
+      def check_image(image)
+        File.exist?(image.local_path) ? image.finish_download : image
+      end
+    end
+  end
+end

data/lib/flickrage/service/resizer.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+module Flickrage
+  module Service
+    class Resizer
+      include Flickrage::Helpers::Log
+
+      attr_reader :width, :height
+
+      def initialize(width, height)
+        @width  = width
+        @height = height
+      end
+
+      def run(image)
+        return image unless image.downloaded?
+        resize_to_fill(image)
+        check_image(image)
+      rescue => e
+        logger.debug(e)
+        image
+      end
+
+      private
+
+      def resize_to_fill(image, gravity = 'Center')
+        img = MiniMagick::Image.open(image.local_path)
+
+        cols, rows = img[:dimensions]
+        img.combine_options do |cmd|
+          if width != cols || height != rows
+            scale_x = width / cols.to_f
+            scale_y = height / rows.to_f
+            if scale_x >= scale_y
+              cols = (scale_x * (cols + 0.5)).round
+              rows = (scale_x * (rows + 0.5)).round
+              cmd.resize cols.to_s
+            else
+              cols = (scale_y * (cols + 0.5)).round
+              rows = (scale_y * (rows + 0.5)).round
+              cmd.resize "x#{rows}"
+            end
+          end
+          cmd.gravity gravity
+          cmd.background 'rgba(255,255,255,0.0)'
+          cmd.extent ">#{width}x#{height}" if cols != width || rows != height
+        end
+        img.write image.resize_path
+      end
+
+      def file_name(image)
+        image.resize_path
+      end
+
+      def check_image(image)
+        File.exist?(image.resize_path) ? image.finish_resize : image
+      end
+    end
+  end
+end

data/lib/flickrage/service/search.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+module Flickrage
+  module Service
+    class Search
+      include Flickrage::Helpers::Log
+
+      def run(keyword)
+        result = search(keyword)
+
+        return if result.size < 1
+
+        image(result.first, keyword)
+      rescue StandardError => e
+        logger.debug(e)
+        nil
+      end
+
+      private
+
+      def image(result, keyword)
+        return unless result.respond_to?(:url_l)
+
+        Flickrage::Entity::Image.new(
+          id:      result.id,
+          title:   title(result.title),
+          keyword: keyword,
+          url:     result.url_l,
+          width:   result.width_l,
+          height:  result.height_l,
+        )
+      end
+
+      def search(keyword)
+        flickr.photos.search(params(text: keyword))
+      end
+
+      def title(text)
+        return text if text.nil? || text.size < 50
+        text[0..50] + '...'
+      end
+
+      def params(opts = {})
+        {
+          content_type: '1',
+          extras: 'url_l',
+          sort: 'interestingness-desc',
+          per_page: 1,
+          pages: 1
+        }.merge(opts)
+      end
+    end
+  end
+end

data/lib/flickrage/types.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module Flickrage
+  module Types
+    include Dry::Types.module
+  end
+end

data/lib/flickrage/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module Flickrage
+  VERSION = '0.1.1'
+end

data/lib/flickrage/worker.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module Flickrage
+  module Worker
+    autoload :Base,     'flickrage/worker/base'
+    autoload :Resize,   'flickrage/worker/resize'
+    autoload :Download, 'flickrage/worker/download'
+    autoload :Search,   'flickrage/worker/search'
+    autoload :Compose,  'flickrage/worker/compose'
+  end
+end

data/lib/flickrage/worker/base.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+require 'concurrent-edge'
+require 'mini_magick'
+
+module Flickrage
+  module Worker
+    class Base
+      include Flickrage::Helpers::Log
+      include Flickrage::Helpers::Tty
+
+      MAX_ASK_ERRORS = 3
+
+      PRINT_IMAGE_HEADERS_LITE = %w(keyword id).freeze
+      PRINT_IMAGE_HEADERS      = PRINT_IMAGE_HEADERS_LITE + %w(url title width height)
+
+      attr_accessor :opts, :service, :spin
+
+      def initialize(opts = {}, service = nil)
+        @service = service
+        @opts = default_opts.merge(opts)
+        @spin = nil
+        @opts[:ask_error_counter] = 0
+      end
+
+      def call; end
+
+      private
+
+      def default_opts
+        {}
+      end
+
+      #
+      # Output helpers
+      #
+
+      def increment_error_counter(error, value)
+        @opts[:ask_error_counter] += 1
+
+        raise error, value if opts[:ask_error_counter] > MAX_ASK_ERRORS
+      end
+
+      def reset_error_counter
+        @opts[:ask_error_counter] = 0
+      end
+
+      #
+      # Thread pool access
+      #
+
+      def thread_pool
+        Flickrage.config.pool ||= Concurrent::FixedThreadPool.new(Flickrage.config.pool_size)
+      end
+
+      def clean_thread_pool
+        return unless thread_pool
+        thread_pool.kill
+        Flickrage.config.pool = nil
+      end
+
+      #
+      # Update spin
+      # Due lots of changes in the spinner, keeping wrapper here.
+      #
+
+      def update_spin(spin, tags)
+        spin.clear_line
+        spin.update(tags)
+        spin.spin
+      end
+    end
+  end
+end

data/lib/flickrage/worker/compose.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+module Flickrage
+  module Worker
+    class Compose < Base
+      def call(image_list)
+        raise Flickrage::CollageError, 'Not enough images for collage' if image_list.resized&.size < 1
+
+        speaker.add_padding
+        logger.debug('Collage building process')
+
+        image_list.collage_path = init_file_name
+
+        @spin = spinner(message: 'Collage making')
+        result = service.run(image_list)
+
+        if result.composed?
+          spin.success
+        else
+          spin.error('(failed: Collage was not made)')
+          raise Flickrage::CollageError
+        end
+
+        result
+      ensure
+        spin&.stop
+      end
+
+      private
+
+      def service
+        return @service unless @service.nil?
+        @service = Service::Composer.new(opts['file_name'],
+                                         Flickrage.config.width,
+                                         Flickrage.config.height)
+      end
+
+      def init_file_name
+        return opts['file_name'] if validate_file_name
+
+        output = speaker.ask('Please enter the collage file name:', path: true)
+
+        unless valid_file_name?(output)
+          increment_error_counter(Flickrage::FileNameError,
+                                  "#{output}, must be valid, supported extensions: .png, .jpg or .gif")
+          return init_file_name
+        end
+
+        reset_error_counter
+
+        opts['file_name'] = output
+      end
+
+      def validate_file_name
+        return false unless opts['file_name']
+        return true if valid_file_name?(opts['file_name'])
+        opts['file_name'] = nil
+        false
+      end
+
+      def valid_file_name?(value)
+        return false unless value
+        value.match(/^([a-zA-Z0-9\-_\.]+)\.(png|jpg|jpeg|gif)$/)
+      end
+    end
+  end
+end