sicily 0.1.4 → 0.1.5

data/lib/sicily/batch_processor.rb

@@ -1,38 +1,59 @@
-require "sicily/config"
-require "sicily/file_processor"
-require "sicily/util/notification_util"
+# frozen_string_literal: true
+
+require 'sicily/config'
+require 'sicily/file_processor'
+require 'sicily/util/notification_util'
 
 module Sicily
   class BatchProcessor
-    def run(files, &block)
-      return if files.empty?
-
-      notify_when_done = Sicily.config.notify_when_done
-      pool = Concurrent::FixedThreadPool.new(Sicily.config.num_thread_pool)
-      latch = Concurrent::CountDownLatch.new(files.size)
-      files.each do |file|
-        pool.post do
-          begin
-            process_added_file(file, &block)
-          rescue Exception => e
-            # FIXME : need to log `e.message`
-          end
-          latch.count_down
-        end
+    def initialize(files)
+      @files = files
+      @pool = Concurrent::FixedThreadPool.new(Sicily.config.num_thread_pool)
+      @latch = Concurrent::CountDownLatch.new(@files.size)
+    end
+
+    def run(&user_rule_block)
+      return if @files.empty?
+
+      notify_beginning
+      process_files_in_thread(&user_rule_block)
+      notify_done_when_finished
+    end
+
+    def notify_beginning
+      Util::NotificationUtil.notify_beginning(@files)
+    end
+
+    def process_files_in_thread(&user_rule_block)
+      @files.each do |file|
+        process_each_file_in_thread file, &user_rule_block
+      end
+    end
+
+    def process_each_file_in_thread(file, &user_rule_block)
+      @pool.post do
+        process_added_file(file, &user_rule_block)
+        @latch.count_down
       end
+    end
 
-      pool.post do
-        latch.wait
-        notify(files) if notify_when_done
+    def notify_done_when_finished
+      @pool.post do
+        @latch.wait
+        notify_done
       end
     end
 
-    def process_added_file(file, &block)
-      FileProcessor.new(file).instance_eval(&block)
+    def process_added_file(file, &user_rule_block)
+      file_processor = FileProcessor.new(file)
+      file_processor.instance_eval(&user_rule_block)
+      file_processor.info 'Done'
+    rescue RuntimeError => e
+      Sicily.logger.error e.message
     end
 
-    def notify(files)
-      Util::NotificationUtil.notify(files)
+    def notify_done
+      Util::NotificationUtil.notify_done(@files)
     end
   end
-end
+end

data/lib/sicily/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sicily
   class << self
     attr_accessor :config
@@ -5,15 +7,15 @@ module Sicily
 
   class Config
     attr_reader :forbid_new_file_in_subfolder,
-                :notify_when_done,
-                :num_thread_pool
+                :num_thread_pool,
+                :delay_on_file_monitoring
 
     def initialize
       @forbid_new_file_in_subfolder = true
-      @notify_when_done = true
       @num_thread_pool = 50
+      @delay_on_file_monitoring = 10
     end
   end
 
   Sicily.config = Config.new
-end
+end

data/lib/sicily/error/monitor_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Sicily
+  class MonitorError < RuntimeError
+  end
+end

data/lib/sicily/file_processor.rb

@@ -1,7 +1,15 @@
+# frozen_string_literal: true
+
 module Sicily
   class FileProcessor
     def initialize(path)
       @path = path
+      @tag = File.basename(path)
+      info 'Start processing...'
+    end
+
+    def info(message)
+      Sicily.logger.info "#{@tag}\t=>\t#{message}"
     end
   end
-end
+end

data/lib/sicily/generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sicily
   class Generator
     attr_accessor :filename, :content, :post_generate_message
@@ -15,4 +17,4 @@ module Sicily
     block.call generator
     Sicily.generators << generator
   end
-end
+end

data/lib/sicily/logger.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Sicily
+  class << self
+    attr_accessor :logger
+  end
+
+  class LoggerWrapper
+    def initialize
+      create_logger
+    end
+
+    def unknown(*args)
+      @logger.unknown(*args)
+    end
+
+    def fatal(*args)
+      @logger.fatal(*args)
+    end
+
+    def error(*args)
+      @logger.error(*args)
+    end
+
+    def warn(*args)
+      @logger.warn(*args)
+    end
+
+    def info(*args)
+      @logger.info(*args)
+    end
+
+    def debug(*args)
+      @logger.debug(*args)
+    end
+
+    private
+
+    def create_logger
+      @logger = if $SICILY_LOG_TO_FILE
+                  Logger.new File.join(File.dirname(__FILE__), '../../monitor.log')
+                else
+                  Logger.new STDOUT
+                end
+    end
+  end
+
+  Sicily.logger = LoggerWrapper.new
+end

data/lib/sicily/monitor.rb

@@ -1,16 +1,34 @@
-require "listen"
-require "concurrent"
-require "sicily/batch_processor"
+# frozen_string_literal: true
+
+require 'listen'
+require 'concurrent'
+require 'sicily/batch_processor'
+require 'sicily/error/monitor_error'
 
 module Sicily
   class Monitor
-    def on(path, &block)
+    def on(path, &user_rule_block)
+      Sicily.logger.info "Starting a monitor on #{path}"
+      path = validate_and_expand_path(path)
+      start_listener(path) do |files|
+        BatchProcessor.new(files).run(&user_rule_block)
+      end
+    end
+
+    def validate_and_expand_path(path)
       path = File.expand_path(path)
-      raise "Unknown path : #{path}" unless File.exists?(path)
-      listener = Listen.to(path) do |modified, added, removed|
-        BatchProcessor.new.run(added, &block)
+      raise MonitorError, "Monitor Failed. Unknown path : #{path}" unless File.exist?(path)
+      path
+    end
+
+    private
+
+    def start_listener(path)
+      delay = Sicily.config.delay_on_file_monitoring
+      listener = Listen.to(path, wait_for_delay: delay) do |_modified, added, _removed|
+        yield added
       end
       listener.start
     end
   end
-end
+end

data/lib/sicily/task/dummy_task.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Sicily
   module Task
     module DummyTask
       def dummy
-        puts "This does nothing"
+        info 'dummy'
         @path
       end
     end
   end
-end
+end

data/lib/sicily/task/file_task.rb

@@ -1,21 +1,13 @@
-require "fileutils"
-require "sicily/config"
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'sicily/config'
 
 module Sicily
   module Task
     class Base
       def self.prepare_dest_path(path_src, path_dest)
-        cannot_op = Sicily.config.forbid_new_file_in_subfolder &&
-            Util::FileUtil.is_related?(path_src, path_dest)
-
-        if cannot_op
-          raise [
-                    "Cannot do file operation to child folder",
-                    "  src  : #{path_src}",
-                    "  dest : #{path_dest}",
-                ].join("\n")
-          return
-        end
+        check_if_can_operate(path_dest, path_src)
 
         final_dest_path = Util::FileUtil.eval_dest_path(path_src, path_dest)
         final_dest_path = File.expand_path final_dest_path
@@ -23,20 +15,39 @@ module Sicily
 
         final_dest_path
       end
+
+      def self.check_if_can_operate(path_dest, path_src)
+        return unless cannot_op(path_dest, path_src)
+
+        msg = [
+          'Cannot do file operation to child folder', "src  : #{path_src}", "dest : #{path_dest}"
+        ].join('\n')
+        raise msg
+      end
+
+      def self.cannot_op(path_dest, path_src)
+        forbid_new_file_in_subfolder = Sicily.config.forbid_new_file_in_subfolder
+        related = Util::FileUtil.related?(path_src, path_dest)
+
+        forbid_new_file_in_subfolder && related
+      end
     end
 
     module FileTask
       def mv(path_dest)
+        info "mv to #{path_dest}"
         path_dest = Base.prepare_dest_path(@path, path_dest)
         FileUtils.mv @path, path_dest
       end
 
       def cp(path_dest)
+        info "cp to #{path_dest}"
         path_dest = Base.prepare_dest_path(@path, path_dest)
         FileUtils.cp @path, path_dest
       end
 
       def rm
+        info 'rm'
         FileUtils.rm @path
       end
     end

data/lib/sicily/task/google_photo_task.rb

@@ -1,4 +1,6 @@
-require "sicily/config"
+# frozen_string_literal: true
+
+require 'sicily/config'
 
 module Sicily
   class << self
@@ -17,17 +19,38 @@ module Sicily
   end
 
   module Task
+    class Base
+      def self.google_photo(path)
+        validate_credentials!
+        cmd = build_command(path)
+        execute_command(cmd)
+      end
+
+      def self.execute_command(cmd)
+        `#{cmd}`
+      end
+
+      def self.build_command(path)
+        "upload-gphotos \"#{path}\" -u #{id} -p #{pw}"
+      end
+
+      def self.pw
+        Sicily.config_google.pw
+      end
+
+      def self.id
+        Sicily.config_google.id
+      end
+
+      def self.validate_credentials!
+        raise 'no google credential' if id.to_s.empty? || pw.to_s.empty?
+      end
+    end
+
     module GooglePhotoTask
       def google_photo
-        id = Sicily.config_google.id
-        pw = Sicily.config_google.pw
-
-        if id.to_s.empty? or pw.to_s.empty?
-          raise "no google credential"
-        else
-          cmd = "upload-gphotos \"#{@path}\" -u #{id} -p #{pw}"
-          `#{cmd}`
-        end
+        info 'google_photo'
+        Base.google_photo(@path)
       end
     end
   end

data/lib/sicily/task/resize_task.rb

@@ -1,27 +1,27 @@
-require "sicily/util/image_util"
-require "fastimage_resize"
+# frozen_string_literal: true
+
+require 'sicily/util/image_util'
+require 'fastimage_resize'
 
 module Sicily
   module Task
     class SizeCalculator
       def self.size_to_fit(container_width, container_height, image_width, image_height)
-        if container_width*image_height > container_height*image_width
-          [(image_width*container_height/image_height).to_i, container_height]
+        if container_width * image_height > container_height * image_width
+          [(image_width * container_height / image_height).to_i, container_height]
         else
-          [container_width, (image_height*container_width/image_width).to_i]
+          [container_width, (image_height * container_width / image_width).to_i]
         end
       end
     end
 
     module ResizeTask
       def fit_if_photo(container_width, container_height)
+        info "fit_if_photo to #{container_width}x#{container_height}"
         size = Util::ImageUtil.get_size(@path)
-        image_width = size[0]
-        image_height = size[1]
-
-        dest_size = SizeCalculator.size_to_fit container_width, container_height, image_width, image_height
-        FastImage.resize(@path, dest_size[0], dest_size[1], :outfile => @path)
+        dest_size = SizeCalculator.size_to_fit container_width, container_height, size[0], size[1]
+        FastImage.resize(@path, dest_size[0], dest_size[1], outfile: @path)
       end
     end
   end
-end
+end

data/lib/sicily/task_loader.rb

@@ -1,20 +1,40 @@
+# frozen_string_literal: true
+
 module Sicily
   class TaskLoader
     def load_all_tasks
-      Dir["#{File.dirname(__FILE__)}/task/*.rb"].each {|file|
+      list_all_files.each do |file|
         require file
-
-        module_name = camelize(File.basename(file, ".*"))
-        maybe_module = Task.const_get(module_name)
-        if maybe_module.class.name == "Module"
-          FileProcessor.send(:include, maybe_module)
-        end
-      }
+        include_module_if_exists(file)
+      end
     end
 
     private
+
+    def include_module_if_exists(file)
+      maybe_module = guess_module(file)
+      include_the_module(maybe_module) if really_module?(maybe_module)
+    end
+
+    def include_the_module(maybe_module)
+      FileProcessor.send(:include, maybe_module)
+    end
+
+    def really_module?(maybe_module)
+      maybe_module.class.name == 'Module'
+    end
+
+    def guess_module(file)
+      module_name = camelize(File.basename(file, '.*'))
+      Task.const_get(module_name)
+    end
+
+    def list_all_files
+      Dir["#{File.dirname(__FILE__)}/task/*.rb"]
+    end
+
     def camelize(str)
-      str.split('_').map {|w| w.capitalize}.join
+      str.split('_').map(&:capitalize).join
     end
   end
-end
+end