flickrage 0.1.1

data/lib/flickrage/cli.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+require 'thor'
+require 'fileutils'
+require 'flickraw'
+require 'flickrage'
+
+module Flickrage
+  # CLI is here
+  #
+  class CLI < Thor # rubocop:disable ClassLength
+    include Flickrage::Helpers::Log
+
+    default_task :help
+
+    map %w(c)  => :collage
+    map %w(-V) => :version
+
+    # Overriding Thor method for custom initialization
+    #
+    def initialize(*args)
+      super
+
+      setup_config
+      set_logger
+    end
+
+    desc 'c / collage', 'Download & generate collage\'s'
+    long_desc <<-LONGDESC
+    `flickrage` is a tool which loves search on the Flickr & making collages from findings.
+
+    You have to enter name of the output file and a max number of downloading files.
+
+    Parameters helps you specify rectangle size for each image, collage name, it's location,
+    ..., and well the grid base size.
+
+    ### Examples
+
+    Set keywords:
+
+    $ flickrage -k some nice grapefruit
+
+    Set Flickr API keys:
+
+    $ flickrage --flickr-api-key SOMELONGKEY --flickr-shared-secret SOMELONGSECRET
+
+    Select output folder:
+
+    $ flickrage -k some nice grapefruit -o ./tmp
+
+    Enter collage file_name:
+
+    $ flickrage -k some nice grapefruit --file-name some.jpg
+
+    Get collage of top 10 images:
+
+    $ flickrage -k some nice grapefruit --max 10
+
+    Get collage of top 20 images:
+
+    $ flickrage -k some nice grapefruit --max 20
+
+    Get collage of top 10 images custom width & height:
+
+    $ flickrage -k some nice grapefruit --max 10 --width 160 --height 120
+
+    VERSION: #{Flickrage::VERSION}
+    LONGDESC
+    method_option :keywords,
+                  type: :array,
+                  required: true,
+                  aliases: %w(-k),
+                  banner: 'some nice grapefruit'
+    method_option :max,
+                  type: :numeric,
+                  enum: (1..20).to_a,
+                  default: 10,
+                  banner: '10',
+                  desc: 'Select number of files.'
+    method_option :grid,
+                  type: :numeric,
+                  banner: '2',
+                  desc: 'Select grid base number.'
+    method_option :width,
+                  type: :numeric,
+                  banner: '120',
+                  desc: 'Set width for resize downloaded images.'
+    method_option :height,
+                  type: :numeric,
+                  banner: '80',
+                  desc: 'Set height for resize downloaded images.'
+    method_option :log,
+                  type: :string,
+                  aliases: %w(-l),
+                  banner: '/Users/someone/.flickrage/main.log',
+                  desc: 'Log file path. By default logging is disabled.'
+    method_option :output,
+                  type: :string,
+                  aliases: %w(-o),
+                  banner: './tmp',
+                  desc: 'Output directory, where all data will be stored.'
+    method_option :file_name,
+                  type: :string,
+                  banner: './some.png',
+                  desc: 'Name for file with collage.'
+    method_option :dict_path,
+                  type: :string,
+                  banner: '/usr/share/dict/words',
+                  desc: 'Path to file with multiline words (dictionary).'
+    method_option :cleanup,
+                  default: false,
+                  type: :boolean,
+                  aliases: %w(-c),
+                  desc: 'Cleanup files before collage.'
+    method_option :verbose,
+                  type: :boolean,
+                  aliases: %w(-v),
+                  desc: 'Verbose mode.'
+    method_option :quiet,
+                  type: :boolean,
+                  aliases: %w(-q),
+                  desc: 'Quiet mode. If don\'t need any messages and in console.'
+
+    method_option :flickr_api_key,
+                  type: :string,
+                  banner: 'YOURLONGAPIKEY',
+                  desc: 'FLICKR_API_KEY. if you can\'t use environment.'
+    method_option :flickr_shared_secret,
+                  type: :string,
+                  banner: 'YOURLONGSHAREDSECRET',
+                  desc: 'FLICKR_SHARED_SECRET. if you can\'t use environment.'
+
+    def collage
+      cleanup if options['cleanup']
+      try_keys_first
+      init_flickraw
+
+      pipeline.run
+    rescue Flickrage::NoKeysError, Flickrage::SearchError, Flickrage::DownloadError,
+           Flickrage::NumberError, Flickrage::PathError => e
+      error_simple(e)
+    rescue => e
+      error_with_backtrace(e)
+    end
+
+    desc 'clean', 'Cleanup folder'
+    method_option :output,
+                  type: :string,
+                  required: true,
+                  aliases: %w(-o),
+                  banner: './some.png'
+    def clean
+      cleanup
+    end
+
+    desc 'version, -V', 'Shows the version of the currently installed Flickrage gem'
+    def version
+      puts Flickrage::VERSION
+    end
+
+    no_commands do
+      def error_simple(e)
+        logger.error e.message
+        raise e
+      end
+
+      def error_with_backtrace(e)
+        logger.error e.message
+        backtrace(e) if options.include? 'trace'
+        raise e
+      end
+
+      def pipeline
+        @pipeline ||= Pipeline.new(options)
+      end
+
+      def cleanup
+        return unless options['output']
+        return unless Dir.exist?(options['output'])
+        FileUtils.rm_rf("#{options['output']}/.", secure: true)
+      end
+
+      def setup_config
+        Flickrage.configure do |config|
+          config.logger       = ::Logger.new(options['log']) if options['log']
+          config.verbose      = options['verbose']
+          config.quiet        = options['quiet']
+          config.logger_level = Logger::DEBUG if config.verbose
+
+          config.flickr_api_key       = options['flickr_api_key']       || ENV['FLICKR_API_KEY']
+          config.flickr_shared_secret = options['flickr_shared_secret'] || ENV['FLICKR_SHARED_SECRET']
+
+          config.dict_path = options['dict_path'] if options['dict_path']
+
+          config.width  = options['width']  if options['width']
+          config.height = options['height'] if options['height']
+
+          config.max    = options['max']  if options['max']
+          config.grid   = options['grid'] if options['grid']
+          config.output = options['output']
+        end
+      end
+
+      def set_logger
+        Flickrage.logger = Log.new(shell: shell)
+      end
+
+      def backtrace(e)
+        e.backtrace.each do |t|
+          logger.error t
+        end
+      end
+
+      def init_flickraw
+        FlickRaw.api_key       = Flickrage.config.flickr_api_key
+        FlickRaw.shared_secret = Flickrage.config.flickr_shared_secret
+      end
+
+      # Check for Flickr API keys
+      def try_keys_first
+        logger.debug 'Checking Flickr Key\'s.'
+
+        return if Flickrage.api_keys?
+        logger.error Flickrage::NoKeysError.new('You must provide Flickr API credentials via --flickr-api-key, --flickr-shared-secret via options. or have it in the environment')
+        exit
+      end
+    end
+  end
+end

data/lib/flickrage/entity.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+module Flickrage
+  module Entity
+    autoload :Image,     'flickrage/entity/image'
+    autoload :ImageList, 'flickrage/entity/image_list'
+  end
+end

data/lib/flickrage/entity/image.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+module Flickrage
+  module Entity
+    class Image < Dry::Types::Struct
+      constructor_type(:schema)
+
+      attribute :id,        Types::Coercible::Int
+      attribute :title,     Types::Coercible::String
+      attribute :keyword,   Types::Coercible::String
+      attribute :url,       Types::Coercible::String
+      attribute :file_name, Types::Coercible::String
+      attribute :width,     Types::Coercible::Int
+      attribute :height,    Types::Coercible::Int
+
+      attribute :download,  Types::Bool.default(false)
+      attribute :resize,    Types::Bool.default(false)
+
+      alias downloaded? download
+      alias resized? resize
+
+      %w(download resize).each do |m|
+        define_method(:"finish_#{m}") do
+          instance_variable_set(:"@#{m}", true)
+          self
+        end
+      end
+
+      def local_path
+        File.absolute_path("#{Flickrage.config.output}/#{file_name}")
+      end
+
+      def resize_path
+        File.absolute_path("#{Flickrage.config.output}/#{Flickrage.config.resize_file_prefix}#{file_name}")
+      end
+
+      def file_name=(file_name)
+        @file_name = file_name
+        self
+      end
+    end
+  end
+end

data/lib/flickrage/entity/image_list.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+module Flickrage
+  module Entity
+    class ImageList < Dry::Types::Struct
+      constructor_type(:schema)
+
+      attribute :images,       Types::Strict::Array.member(Flickrage::Entity::Image).default([])
+      attribute :not_founds,   Types::Strict::Array.member(Types::Coercible::String).default([])
+      attribute :total,        Types::Int.optional.default(0)
+      attribute :compose,      Types::Bool.default(false)
+      attribute :collage_path, Types::Coercible::String
+
+      alias composed? compose
+
+      def downloaded
+        images.select(&:downloaded?)
+      end
+
+      def resized
+        images.select(&:resized?)
+      end
+
+      def finish_compose
+        @compose = true
+        self
+      end
+
+      def combine(image_list)
+        new_images = images + image_list
+        new_total  = new_images.size
+        @images = new_images
+        @total = new_total
+        self
+      end
+
+      def clean
+        @images = images.compact
+        @total  = images.size
+        self
+      end
+
+      def valid?
+        total == Flickrage.config.max
+      end
+
+      def merge_not_founds(new_not_founds)
+        @not_founds = not_founds + new_not_founds
+        self
+      end
+
+      def merge_images(new_images)
+        @images = images | new_images
+        self
+      end
+
+      def size
+        images.size
+      end
+
+      def collage_path=(file_name = nil)
+        file_name = "collage.#{Time.now.to_i}.jpg" if file_name.nil?
+        @collage_path = File.absolute_path("#{Flickrage.config.output}/#{file_name}")
+      end
+    end
+  end
+end

data/lib/flickrage/helpers.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+require 'tty-spinner'
+require 'pastel'
+
+module Flickrage
+  # Helpers for main class.
+  #
+  module Helpers
+    module Log
+      def logger
+        UniversalLogger
+      end
+
+      def speaker
+        UniversalSpeaker
+      end
+    end
+
+    module Dict
+      def sample_words(n = 1)
+        Flickrage.dict.sample(n).map(&:strip)
+      end
+
+      def sample_words_strict(n = 1, except: [])
+        return [] if Flickrage.dict.size < (n + except.size)
+        Flickrage.dict
+                 .sample(n + except.size)
+                 .map(&:strip)
+                  .-(except)
+                 .first(n)
+      end
+    end
+
+    module Tty
+      def spinner(message: '', format: :dots)
+        spin = TTY::Spinner.new('[:spinner] :title',
+                                format: format,
+                                interval: 20,
+                                hide_cursor: true,
+                                success_mark: color(color: :green, message: '+'),
+                                error_mark: color(color: :red, message: 'x'))
+        spin.update(title: message)
+        spin.start
+
+        return spin unless block_given?
+
+        yield(spin)
+      end
+
+      private
+
+      def pastel
+        @pastel ||= Pastel.new
+      end
+
+      def color(color: :green, message: ' ')
+        pastel.send(color, message)
+      end
+    end
+
+    # UniversalLogger is a module to deal with singleton methods.
+    # Used to give classes access only for selected methods
+    #
+    module UniversalLogger
+      %w(debug info warn error fatal unknown).each do |name|
+        define_singleton_method(:"#{name}") { |*args, &block| Flickrage.logger.send(:"#{name}", *args, &block) }
+      end
+
+      def self.close
+        Flickrage.logger.close if Flickrage.logger
+      end
+    end
+
+    module UniversalSpeaker
+      %w(ask yes? no? print_table add_padding).each do |name|
+        define_singleton_method(:"#{name}") { |*args| Flickrage.logger.send(:"#{name}", *args) }
+      end
+    end
+  end
+end

data/lib/flickrage/log.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+require 'logger'
+
+module Flickrage
+  # Shared logger
+  #
+  class Log
+    attr_reader   :shell
+    attr_accessor :quiet, :verbose
+    attr_writer   :buffer, :instance
+
+    def initialize(options = {})
+      @verbose = Flickrage.config.verbose
+      @quiet   = Flickrage.config.quiet
+      options.each { |key, option| instance_variable_set(:"@#{key}", option) }
+      instance.level = Flickrage.config.logger_level if instance
+    end
+
+    def instance
+      @instance ||= Flickrage.config.logger
+    end
+
+    def buffer
+      @buffer ||= %w()
+    end
+
+    def shell=(shell)
+      @shell = shell unless quiet
+    end
+
+    def close
+      instance.close if instance
+    end
+
+    %w(debug info warn error fatal unknown).each_with_index do |name, severity|
+      define_method(:"#{name}") { |*args, &block| log severity, *args, &block }
+    end
+
+    %w(yes? no?).each do |name|
+      define_method(:"#{name}") do |statement, color = :green|
+        shell.send(:"#{name}", statement, color) if shell
+      end
+    end
+
+    def print_table(*args)
+      args[0]&.each { |row| instance.info(row) } if instance
+      shell.print_table(*args) if shell
+    end
+
+    def ask(statement, color: :green, path: false)
+      shell.ask(statement, color, path: path) if shell
+    end
+
+    def add_padding
+      shell.say_status('', '') if shell
+    end
+
+    def log(severity, message = nil, progname = nil, &block)
+      buffer << message
+      instance.add(severity, message, progname, &block) if instance.respond_to?(:add)
+
+      say(message, color(severity)) unless print?(severity)
+    end
+
+    protected
+
+    def print?(type)
+      (type == Logger::DEBUG && !verbose) || quiet
+    end
+
+    def say(message, color)
+      shell.say message, color if shell
+    end
+
+    def color(severity)
+      case severity
+      when 0
+        :white
+      when 3
+        :red
+      when 2
+        :yellow
+      else
+        :green
+      end
+    end
+  end
+end